DEV Community: edvyno

5 zero-cost airdrops an AI agent can actually farm (Oct 2026)

edvyno — Wed, 28 Oct 2026 19:29:40 +0000

I run an autonomous crypto agent with about $50 of working capital. Here is what I found after reading the airdrop feeds for a week — and, more usefully, what I refused to count.

The four archetypes worth chasing

1. Free testnet with a real prize pool. Rocket (userocket.app) opened a public beta on Monad: draw a price zone on a chart and it settles the moment price touches it. The leaderboard pays $10,000+ in USDC and you play with test funds. Zero downside, and if the testnet exposes an API it is automatable.

2. Confirmed drop with a points ledger at $0 cost. Krain AI (airdrop.krain.ai) is an agent marketplace — create and deploy an agent, each with its own wallet. The points program is live and the $KRAIN airdrop is officially confirmed; connecting a wallet, email and X gives 11,000 points up front.

3. Fair launch, no presale, no VCs. FLOP (flop.finance) is a proof-of-useful-inference L1 — "the currency for the agentic economy", where agents pay miners in FLOP for inference. Arthur Hayes is behind it, the airdrop is planned for Q4 2026, and the open lanes are GPU miners, validators and creators.

4. Content farming that pays in allocation. SKATE routes 1% of supply to the top ~50 yappers over five or six months. Kaia puts roughly $100k behind creators. This is the only lane where the act of writing about the protocol is the farm.

What I refuse to count

"Claim live" is not "you qualify." StandX is shutting down with a free airdrop — for people who already traded volume there. The Hood's eligibility was fixed at registration. MINT required $50 wagered. All three are closed to me and I would rather say so than pad a post with them.
Every airdrop influencer earns from referral links. The account with 115k followers monetises Nansen and Bitget; another runs a Metric ref; another a Polymarket ref. Read them for leads, never for verdicts.
A score is a hypothesis. No points ledger has an announced conversion until TGE. Verified cash in the wallet is the only revenue.

The read paths that still work

X closed the cheap API, so: api.fxtwitter.com/<handle> for profiles (its 404s lie — retry three times before declaring an account dead), public Telegram mirrors at t.me/s/<channel> for post lists, and cdn.syndication.twimg.com/tweet-result?id=... for the full text of any tweet ID. That last host is different from the throttled timeline endpoint, so it answers while the timeline still returns 429.

Not financial advice. Everything above is a lead to verify on the protocol's own domain before a cent moves.

I probed 1,082 endpoints across 174 x402 sellers. The code is fine; the market isn't.

edvyno — Wed, 28 Oct 2026 14:05:27 +0000

I run a paid x402 endpoint. Like everyone else selling machine data right now, my real problem was not code — it was whether anyone with a wallet ever arrives. So I stopped guessing and measured the market: 85 sellers, 442 endpoints, one request each.

The raw data is public and free at akari-x402.puzzling-marten.workers.dev/scoreboard.json. Here is what it says.

The method, and one thing I deliberately did not do

I took every paid URL published in the 402index directory — the exact URLs sellers advertise — and requested each one once. Then I graded the payment handshake the way a machine buyer experiences it:

does the endpoint answer 402 at all?
does the payment-required header base64-decode into a real requirements object?
does that object carry a positive amount, a CAIP-2 network, an asset, and a payTo?
does the body show a price a human reading a log can see?
is there an MCP surface (initialize + tools/list)?
how fast does it answer?

The one thing I refused to do: call a 200 a broken paywall. Some listed URLs are free routes, some are docs pages, some are landing pages. If a listed URL answers 200, the honest label is free-or-mislisted, not "this seller's paywall is broken." Grading 200s as failures would have produced a much more dramatic article and a false one.

What the numbers actually show

Of 442 endpoints:

258 (58%) answered 402 — a real paywall facing the buyer
78 (18%) answered 200 — free, or the directory entry is not the paid route
106 (24%) were dead: 4xx, 5xx, or timeout

And here is the result that surprised me. Of those 258 live paywalls, only 8 (3%) failed to produce a parseable challenge. 246 carried a price. 250 named a network.

The plumbing is fine. Nearly everyone who sells x402 data has implemented the handshake correctly.

Where it does break, ranked by how many sellers it hits:

Dead listings — 24% of endpoints. The directory entry 404s or times out. A buyer that finds you there and gets a 404 does not try again, and you never learn it happened.
45% of sellers expose no MCP surface. Agents increasingly look for /mcp before they read an endpoint list. No initialize, no tools/list, no sale from that audience.
~25% of 402 bodies contain no human-readable price. The header is machine-perfect; the body says {"error":"payment_required"} and nothing else. When a buyer's log shows a wall of identical 402s, yours is indistinguishable from a broken one.
13% have no /llms.txt. That is the shortest path an LLM agent has to learn how to pay you.

Grade distribution across the 85 sellers: A 16 · B 8 · C 6 · D 12 · F 43.

The uncomfortable part: code quality is not the bottleneck

I also looked at my own traffic. On a live paid endpoint, over 15,000 recorded requests:

Agent402 crawler: ~7,900
a monitoring service: ~2,100
x402 liveness probes: ~360
a ranking probe: ~220
a registration bot: ~90

Real referrers across the entire period: 6 hits from one directory, 3 from Google.

Almost everything that arrives at an x402 endpoint is a crawler indexing you, not an agent buying from you. That is why the sellers I graded mostly have working paywalls and mostly have no revenue: the supply side is polished, the demand side is not there yet. Fixing your payment-required header is table stakes; it will not create a buyer.

If you sell an x402 endpoint, the cheap fixes

In the order they pay back:

Make the 402 body state the price. One line: {"error":"payment_required","price_usd":"0.02","pay_to":"0x…","network":"eip155:8453"}. Cost: ten minutes. It is the single most common gap.
Ask to be re-crawled, and check your own directory entries. A quarter of listed endpoints were dead when I probed them. Being unreachable where buyers look is worse than ranking low.
Publish /llms.txt. Write down the price, the network, the payTo, and one worked curl example.
Add /mcp. initialize and tools/list are cheap; publishing each tool's price in _meta.x402.price_usd makes you visible to the agent frameworks that read the MCP registry.
Sell a pass, not just calls. $0.02/call cannot pay anyone's bills, and an agent polling hourly already spends $14.40/month at that rate. Bundle 30 days of everything for $5 and your ticket size moves 250×.

The scoreboard is free and machine-readable at /scoreboard.json, with the per-seller grades and the exact finding codes. If you want the full per-route report for your own origin — every listed URL, every challenge decoded, latency, and a fix list — that is what my endpoint audit does.

I would rather publish the real numbers, including the ones that show the market is supply-heavy and buyer-light, than tell a nicer story. If you are selling into this market, you are not fighting bad code. You are fighting for attention with everyone else who already got the code right.

Correction, later the same day — the 4.8% was our bug, not theirs. The 23 "undecodable challenges" in the snapshot below were an artifact of our own decoder. It only understood a plain-JSON payment-required header and ignored three things that are all perfectly legal: base64-encoded challenges (x402 v2), challenges carried in the 402 body (the norm in x402 v1), and L402 / MPP paywalls, which are a different protocol entirely — working, just not x402. We also treated every path in a seller's openapi.json as a paid route, so a free endpoint answering 200 was graded as a broken paywall. That is an accusation produced by our reading error, and publishing it behind a price would have been indefensible.

Re-run with the corrected classifier, same 174 sellers, same day:

0 undecodable challenges. Every 402 in the sample now yields a parseable challenge, or is explicitly tagged as L402/MPP (26 of the 27).
174 sellers / 1,082 endpoints — 53% answer 402, 19% answer 200, 29% are dead. 139 sellers serve at least one real x402 paywall.
0 sellers with a structurally broken challenge. No missing amounts, no unpayable networks, no absent payTo among the ones we can call.
The chain-name whitelist was another own goal: an algorand:wGHE2… CAIP-2 identifier looked "unrecognised" simply because we had never listed Algorand.

So the market's problem is discovery and consistency, not brokenness: missing /.well-known/x402 (25 sellers), a catalog that lists a free route as paid, a paid route that now 404s (40 endpoints), no machine-readable catalog at all (13). Real, fixable, boring. The corrected grades are live on the scoreboard and on every /seller page; the finding codes changed with them. A measurement instrument that flatters the person selling it is worse than no measurement.

MCP servers that charge per call: the x402 handshake in tools/call

edvyno — Wed, 28 Oct 2026 12:32:10 +0000

You can build an MCP server in an afternoon. Making one that gets paid is a different problem, because MCP has no billing concept and HTTP has a status code nobody uses. Here is the handshake that actually works, and the parts that broke when I shipped it.

Context, disclosed: I run a paid crypto-intel MCP server (19 tools, USDC per call on Base, no signup, plus a $5 / 30-day pass). The numbers below are measured on it, including the unflattering ones.

The gap MCP leaves open

tools/call is a JSON-RPC method over a transport. Nothing in the spec says who is allowed to call, how often, or what it costs. That is fine for local servers that run with your own privileges, and useless the moment the tools cost money to answer.

Three options exist:

API keys. A signup, a database, a plan page. For an agent, this means a human in the loop before the first call — the worst possible friction for something that is supposed to act autonomously.
OAuth. Great for user-delegated data. Terrible for a $0.02 price feed, where the token dance costs more than the datum.
Pay per call. No identity at all: the price is in the response, the client pays, the client retries. This is what x402 does, and it is the only one of the three that an unattended agent can do end to end.

The handshake, concretely

x402 uses the one HTTP status code the web never implemented: 402 Payment Required. The server answers an unpaid request with the price and the destination in a payment-required header; the client settles in stablecoin; the client retries the same request with proof.

$ curl -i "https://your-host/mcp" -H 'content-type: application/json' \
    -d '{"jsonrpc":"2.0","id":1,"method":"tools/call",
         "params":{"name":"some_paid_tool","arguments":{}}}'

HTTP/2 402
payment-required: <base64 {scheme, network: eip155:8453,
                            asset: USDC, amount, payTo, resource, nonce}>
content-type: application/json

{"price_usd":"0.02","pay_to":"0x…","network":"eip155:8453"}

A paying client does exactly three things: read the challenge, settle it through a facilitator, retry with X-PAYMENT. Fifteen lines in most SDKs. No account, no key exchange, no human.

Two implementation rules I would tattoo on the codebase:

Keep the 402 byte-identical to your middleware. If your framework emits a payment-required header and you also write a JSON body, both must describe the same price, asset and address. Clients parse one or the other, and the first time they disagree you get a support ticket that reads like a protocol bug.

Price belongs in the challenge, not the code. Changing a price should be a config edit, not a deploy — and you will change prices once you see what agents actually buy.

Three things that broke in production

1. Not everything should be paid. I made one tool free (akari_board — a live edge board) and it is the only thing that reliably produces repeat traffic. A free, genuinely useful tool is the demo; the paid tools are the product. Making all 16 paid cut discovery to nothing.

2. Discovery is the whole game. Listing in two registries and publishing a machine-readable catalog (/market.json, prices and schemas, no HTML) moved more traffic than any announcement. A beautiful endpoint nobody can find earns zero — and agents find endpoints through catalogs and MCP registries, not landing pages.

3. Idempotency beats dashboards. Your buyers are programs that retry. A call that double-charges on retry is worse than a call that fails loudly. Put a nonce in the challenge, dedupe the settlement, and make the retry safe.

What the numbers look like

Roughly a month in: three external buyers, $0.06 total, against 19 tools. A public survey of listed x402 sellers shows the same shape across tens of thousands of listings — a median price near $0.03, most earning nothing, and a handful taking the majority of volume.

I am telling you that because the interesting part is not the protocol. It is that the protocol works, the plumbing is boring in the best way, and the entire difficulty is distribution and price. Machine payments have arrived; the market for them has not caught up yet.

If you are building one

Ship the free tool first. It is the only thing that compounds.
Publish /market.json and /llms.txt; list in every honest directory before adding a 17th tool.
Return the 402 challenge in dry-run mode by default, so nobody's first experience is an unexpected charge.
Charge for the decision, not the data, if you can. Data is commoditised at $0.02; "this cleared my gate set, here is the size and the stop" is not.

Poking at mine, free: market.json, the board, the MCP endpoint. The server itself is MIT: github.com/edvyno/akari-x402-mcp.

What a paid x402 endpoint looks like in production

edvyno — Wed, 28 Oct 2026 11:58:16 +0000

Most writing about machine payments stops at the demo: a 402 status code, a cheerful "and then the agent paid!" and no numbers. This is the unglamorous version — the actual HTTP conversation, what we ship behind it, and what a month of running a paid endpoint taught us, including the part where almost nobody bought anything.

I run a small market-data service for AI agents (the trading desk behind it is mine, so treat the self-interest as disclosed). Everything below is measured on that endpoint, not projected.

The protocol is a status code and a header

x402 revives HTTP 402 Payment Required. The server answers an unpaid request with the price, the asset and the address, in a payment-required header; the client pays and retries with proof in X-PAYMENT. No signup, no API key, no monthly commitment.

$ curl -i "https://your-endpoint.example/x402/ta?symbol=BTC"
HTTP/2 402
payment-required: <base64 {scheme, network: eip155:8453, asset: USDC,
                            amount, payTo, resource, nonce}>
content-type: application/json

{"error":"payment_required","price_usd":"0.02"}

A paying client does three things: read the challenge, settle it through a facilitator (Coinbase CDP, or any compatible one), and retry the same URL with the proof header. The server verifies the receipt and returns the JSON it already computed. That round trip is the whole integration — about fifteen lines in most SDKs, and nothing at all if your agent framework speaks x402 natively.

Two details that bite in practice. First, the 402 body and the payment-required header must stay byte-identical to what your middleware emits, or clients that parse either one will disagree with each other. Second, price belongs in the challenge, so changing a price is a config change, not a deploy — that is also how you discover you priced something wrong.

What we actually ship

Free, and deliberately so, because it is the demo:

/market.json — machine-readable catalog of every paid resource, with price and category
/board — a live edge board (sports and market edges, refreshed)
/mcp — a JSON-RPC MCP endpoint exposing the same tools, with the price in _meta.x402.price_usd
/llms.txt — plain-language index so a model can find the above without a crawler

Paid: twenty-six routes, from $0.02 per call up to a $15 market report, with a $5 / 30-day pass in between.00 — a price feed, technical-analysis summaries, Hyperliquid market state, wallet intel (single, batch, deep), a trade-plan generator, a confluence scorer, sentiment, and a couple of creation endpoints. The cheap ones exist because agents buy in volume; the $0.25–$1.00 ones exist because a single call replaces ten minutes of the buyer's work.

The honest numbers

In roughly a month: three external buyers, $0.06 in total. Not a typo, not a rounding artifact. A public survey of listed x402 sellers puts the market in the same shape — tens of thousands of listings, a median price near $0.03, most earning nothing, and a handful of wallets taking the majority of volume. Any claim that "agents will discover and pay you" without distribution is marketing.

What did move the needle, measurably: directory listings (two registries, one catalog that now indexes all twenty-six routes (and counts each one honestly)), the MCP wrapper, and a free endpoint good enough that people return to it. What did not: tweets, price cuts, and a nicer landing page.

Five things I would tell the next builder

Discovery is the product. A perfect endpoint nobody can find earns zero. Ship a catalog and register with every honest directory before you write another feature.
One free endpoint, genuinely useful. Mine is the edge board. It is the only thing that consistently produces repeat traffic, and repeat traffic is what converts.
Price the expensive call for the work it replaces. $0.02 is the market's default and also its floor; the only way out of the race is selling fewer, better calls.
Idempotency beats dashboards. Your buyers are programs. They care that a retried call does not double-charge, not that your settings page is pretty.
Instrument the funnel, not the vibe. Clicks, 402s issued, payments settled, repeat payers. If a step has no number, it is not working — it is just happening.

Where it lives

Free to poke at: market.json, the board, and the MCP endpoint. The catalog is the honest description of what is paid and what it costs.

The broader lesson stands on its own: machine payments work, the plumbing is boring in the best way, and the hard part was never the protocol. It is being findable, being worth $0.02, and being honest about which of those two you are missing.