A creator platform needs three hard things to work: a way to get discovered (distribution), a way to know who someone is (identity), and a way to move money (payments). Build all three yourself and you have an eighteen-month project before you have shipped anything a creator can use. Farcaster already provides all three as open infrastructure on Base. That is why Sparkz is Farcaster-native, not Farcaster-adjacent - and why "the game is internet traffic, and Farcaster eats first" is a design principle, not a slogan.
Distribution: channels are the discovery layer
Farcaster channels work like topic feeds - /base, /memes, a creator's own channel
- and anyone can create one. For Sparkz this is a clean mapping: **a Capsule maps to
a channel**, and the channel's followers are the Capsule's supporters. The Meme Engine publishes cast-first into that channel, where a crypto-native audience already lives, instead of shouting into an ad-driven feed and paying for reach. Discovery is organic and the surface is proven - a polished Mini App plus a relationship with a channel's moderators can reach a large, high-intent audience for a few weekends of engineering rather than a marketing budget.
Identity: Sign in with Farcaster
Sign in with Farcaster (SIWF) is the "sign in with Google" of this world. One Farcaster ID (an fid) is a persistent identity across every app, and AuthKit handles the cryptographic flow - no passwords, no seed phrases exposed. When someone signs into Sparkz, we get their handle, profile, public social graph, and connected wallet addresses. That means a supporter's reputation is portable: the same identity follows them across Capsules, and backing carries attribution automatically. Sparkz already ships SIWF today.
Payments: USDC on Base, in-feed
Mini Apps (the evolution of Frames) are sandboxed web apps that run inside the feed with a real wallet connection. They can sign a user in, mint, swap, send notifications through a webhook, and take USDC payments on Base - settling in seconds for cents of gas. For Sparkz this is exactly the "back the album" mechanic: a supporter backs a Capsule with USDC without ever leaving the feed, and the receipt is written the moment it happens. Sparkz already publishes a Mini App manifest (/.well-known/farcaster.json) so a link to a Capsule opens as a launch card in-feed.
The infrastructure: Neynar
Neynar is the indexing and signer layer that makes all of this practical. It provides REST APIs for casts, users, and channels; webhooks for real-time events (cast.created, reaction.created, follow.created); and managed signers so an app can cast on behalf of an account without running its own key infrastructure. This is what lets the Sparkz agent cast autonomously, and it is the natural home for the next SignalSource adapter: today the Meme Engine's signals are flagged by a human; wiring a Neynar webhook into the same adapter interface turns Farcaster activity itself into the signal source - no rebuild.
How it maps onto the loop
Every step of the Sparkz loop has a native Farcaster home:
- Flag - a human today; a Neynar webhook (mentions, reactions, follows) next.
- Publish - a cast into the Capsule's channel.
- Back - USDC in a Mini App, in-feed.
- Measure - reach, reactions, and referrals read straight back from Neynar.
- Receipt - stored in Supabase now, mintable on Base later.
Because identity, distribution, and payments are already solved, the only thing Sparkz has to build is the part that is genuinely ours: the Capsule schema, the Meme Engine, and the receipts that compound into the moat. That is the difference between a three-month product and an eighteen-month one.
Note on figures: Farcaster's public metrics and the exact ownership of its infrastructure shift over time; the architectural facts above (channels, SIWF/AuthKit, Mini Apps, Neynar's APIs, USDC on Base) are the durable ones this design relies on.