Solinkify

One on-chain settlement layer on Solana where humans and AI agents (x402) pay each other: sell data, checkout, gated content, sell on X, or run a node. Non-custodial, you keep 99% of every payment.

Comment

Inspiration

I spent four months building an AI paywall for creators. Crawlers take the content, the creator gets nothing, and the only tools on the shelf are block or beg. HTTP 402 was reserved for exactly this in 1997 and x402 finally made it usable, so the plumbing seemed like the whole problem.

It was not. The price was never the blocker. The signature was.

An agent can decide to pay in milliseconds, and then it stops and waits for a human to approve a wallet pop-up. For a request worth a tenth of a cent that is absurd, and the data says so out loud: Chainalysis measured x402 payments of $1 and up climbing from 49% to 95% of volume while the ten-cents-to-one-dollar band collapsed from 46% to 4%. Everyone read that as micropayments dying. I read it as something narrower.

The market did not abandon micro-consumption. It abandoned micro-settlement. So I separated the two.

What it does

Solinkify is a prepaid payment rail on Solana for AI agents. One deposit, thousands of requests, zero signatures.

An agent deposits once into an on-chain balance that stays under its own wallet, in a PDA it can withdraw from at any time. Every request after that is debited on-chain at the price the seller published, with no signature and no prompt. Two cents of USDC covers twenty requests at the demo price; ten dollars covers ten thousand. The deposit itself is a single transaction in the healthy $1+ band, while consumption stays where agents actually live. That ratio, one settlement to a thousand requests, is the number I care about.

On the seller side a site adds one line, AI crawlers meet a price instead of free content, and an ethical agent reads the x402 manifest, locks USDC into a program-owned escrow, and gets the content back. No account, no API key, no invoice. 99% of every payment goes to the creator, and funds never touch a Solinkify wallet on the way.

The same Anchor program also settles a dataset marketplace, a merchant payment gateway, social-commerce Blinks, and a DePIN relay network with staking and epoch rewards. Five pillars, one program, one escrow, one fee split.

Everything above runs on devnet today, including a permanent public fixture anyone can pay in five minutes. Nothing is on mainnet.

How I built it

One Anchor program, currently 34 instructions, holds every rule that touches money: escrow PDAs, the fee split, prepaid debit, subscriptions, staking, epoch rewards. Fee destinations are pinned inside the program, so a compromised hot key cannot redirect a single lamport, and the upgrade authority sits on a Squads multisig rather than on a key that has ever touched my disk.

A Rust/Axum backend does verification and nothing that could be done on-chain instead. It binds each payment to endpoint, amount and mint, enforces one-shot anti-replay, then releases to the creator, with a timeout crank as the safety net if a release is ever missed. Payment paths are fail-closed. Gate paths are fail-open, because a bug in my code must never take a creator's site down.

The install surface is deliberately thin. There is exactly one core function, evaluateGate(GateRequestInfo) -> GateResult, and every integration is a wrapper over it: eleven JavaScript adapters (Next, Express, Cloudflare Workers, Astro, SvelteKit, Hono, Nuxt, Remix, Fastify, Lambda@Edge, plain Fetch), a zero-dependency Python package covering WSGI and ASGI, a WordPress plugin, a Kong Lua plugin, and a standalone reverse proxy for everything else. A detector improvement lands in all of them at once. All fifteen were tested against live servers, not mocked.

The agent side ships too: an MCP server on the official registry with 18 tools and fail-closed spending caps, plus a client SDK that handles the whole 402-pay-retry loop in one call. And because most creators have never held a private key, signing up with an email creates a non-custodial embedded wallet automatically, exportable to Phantom whenever they want it.

Challenges I ran into

My own manifest was lying. It advertised the x402 exact scheme while actually requiring an escrow lock. A correctly built client would have paid and still been refused the content. Nobody hit it, because nobody external is using this yet, which is the only reason it was cheap to fix across five implementations.

A payment could be replayed across endpoints. An early version of verify checked that a payment existed but not that it belonged to the resource being requested, so one payment could unlock a different creator's endpoint. Found and fixed before any of this was public.

One program serving five pillars means every contract change is a shared risk. I stopped patching the program on demand and moved to explicit contract-freeze windows: batch the changes, review them together, deploy once through the multisig. Three windows so far.

Arithmetic killed a feature I had already half-built. Shipping a true x402 exact entry would have needed roughly $0.0007 of gas against a $0.001 request. That is a subsidy, not a product, so I cancelled it and wrote down why. Same month, I deleted a dead instruction from the program rather than keep it around for completeness.

The market numbers I was quoting were inflated about fifteen times. Bloomberg printed $24M a month for x402. Artemis, after filtering wallets trading with themselves, got $1.6M. That means 1% of the entire x402 economy is about $16K a month, so a take rate is not a business for anyone in this space, including me. Better to learn that in week one of a sprint than in month six of a pricing page.

And I caught myself verifying things badly. I once declared a credential live because a health endpoint returned 200, then found the endpoint does not authenticate at all: a garbage key returns 200 too. The rule now is that every credential check uses an authenticated method and a deliberately wrong control first.

Accomplishments I'm proud of

Prepaid balances and on-chain subscriptions have been running on devnet since 3 July 2026, before the industry settled on a name for the approval gap. That timing was not luck, it was the consequence of building the paywall first and being forced to watch where it actually broke.

All five pillars are live end to end on devnet against the same program. Fifteen integrations verified against real servers. The SDKs are published on npm and PyPI, the MCP server is listed on the official registry, and the demo fixture is public and permanent so nobody has to take my word for any of it.

The one I am most pleased about is subtraction. Over the last two months I have removed more than I have added: a dead instruction, a compatibility scheme, a stablecoin that did not fit the token model, and four dummy listings I had seeded myself. The product is finished enough that features are no longer the constraint.

What I learned

That last point is the real lesson. I have zero external users. Five pillars live, packages published, and a funnel measuring almost nothing. Download counts exist but they are mirrors, CI and bots: one package tripled in six days with zero known users, which is proof that the metric is noise, not proof of growth.

So I built an outreach list of 76 verified developers, and building it taught me more than the list is worth. The x402 ecosystem is almost entirely sellers. The single most common artifact is a one-star repository selling pay-per-call tools to agents that do not exist yet, and half those accounts were created this year. The buyer side is thinner than I assumed. I would rather know that early and say it out loud than discover it after a launch.

I also learned that the giants are not in my way. AP2 went to the FIDO Alliance, and its payments working group is chaired by Mastercard and Visa. They are building authorization: who may spend, how much, under what conditions. None of them are building a place to hold and release money on Solana, and card networks never will. Authorization decides that an agent may spend. Something still has to hold the money. That is the part I build.

What's next for Solinkify

Users, then mainnet, in that order.

The immediate goal is turning zero into a single digit: real agent developers running real prepaid balances against their own endpoints, with the sprint measured by requests settled without a signature and by how many settlements those requests needed. An npm install does not count.

Mainnet is costed rather than hoped for: 13.4 SOL at peak, 6.64 SOL locked as refundable rent, the authority rotation to a multisig with human cold keys, pre-created fee ATAs, and a final end-to-end USDC test on both fee routes including the one path that has never been exercised under real load. All five pillars flip together or none of them do.

An external security audit is quoted and pending funding. It happens before mainnet, not after, and I would rather say that plainly than let anyone assume it is already done.

Built With

Share this project:

Updates