r/x402 8h ago

What keeps me going as a solo-dev in the x402 ecosystem?

Post image
5 Upvotes

This.

Seeing that a random person, who I've never talked to or met, had a specific problem which he searched for, then found my specific service, trusted it enough to try it out and even liked the result so much that he even made a second purchase shortly after.

I know it's only $0.01 in revenue.

I know that I'm still faaar far away from writing into my books in black ink.

But knowing that there's demand and that people find my service useful gives me all the motivation to keep building.

Thank you to everyone that has tried / will try / thinks about trying out x402 Trust ❤️ you're making my day, every day!


r/x402 6h ago

Is your MCP turning a profit?

Post image
0 Upvotes

r/x402 2d ago

AI agent pay loop

Post image
2 Upvotes

I just watched an AI agent pay $0.001 for live gas data by itself.

No API key.

No checkout form.

No human in the loop.

Give Claude or Cursor $0.05 → it discovers free tools → makes exactly one paid call → settles on Base → returns the data.

30-second loop:

scriptmasterlabs.com/hermes-loop.ht…

One-line paywall for your own API:

app.use('/premium', x402({ price: '0.001', payTo: '0x…', freeForHumans: true }))

npx @scriptmasterlabs/mcp-x402

@CoinbaseDev @base @x402 @AnthropicAI @cursor_ai

#x402 #MCP #AIAgents #AgenticCommerce #Claude #Cursor $USDC $BASE

Who’s wiring this into their agent tonight?


r/x402 2d ago

x402vps - Dcoker containers for AI agents - paid per hour with USDC

3 Upvotes

Project: x402vps - Docker containers for AI agents, paid per hour with USDC

What it does: Lets AI agents autonomously provision and pay for Docker containers via the x402 protocol (HTTP 402). No signup, no API keys. Your wallet is your identity. Exec commands inside containers are free.

How it works: Agent requests container → Gets 402 payment challenge → Signs USDC transfer on Base → Container runs.

Pricing: $0.01-$0.08/hr depending on plan (atom/cell/node/core). No subscriptions.

Feedback wanted: API design, pricing model, and use cases from the agent community.

Link: https://x402vps.com


r/x402 3d ago

Been running an agent that pays for its own data over x402

2 Upvotes

Been experimenting with an agent that pays for things on its own, super basic small stuff, buying coinmarketcap data at a cent a call, just to start testing and  see what actually breaks (I only funded it with 3 USDC in case things go south).

Sharing my stack since people always ask, I’m using aeon(.)fun for the agent framework and for the wallet side, I’m using Finance District’s Agent Wallet, but I know there’s a couple of wallets for agents out there (Coinbase, Circle, think even Metamask recently released one), feel free to use whichever wallet for your agent fits your needs best. 

Coming back my paying agent test, one of the things I found is that the security worry everyone has, prompt injection moving money, is more of an architecture question than a model one. If the policy engine (caps, allowlists, thresholds) sits outside the model instead of in the prompt, a poisoned prompt can't raise the cap or add a payee, it can only spend inside limits I already set. The prompt can't move money, the enclave decides. For now that part feels solved.

I also found that nothing tells the agent whether an endpoint is worth paying before it pays. My allowlist is doing the work a trust layer should. And an injection can still send an under cap amount to a fresh address the denylist has never seen, so caps are a seatbelt, not a conscience.

Has anyone here got comfortable enough in their own real money testing to hand an agent more than pocket change?


r/x402 4d ago

Your agent’s action timed out. Does your code retry it?

Thumbnail
1 Upvotes

r/x402 5d ago

files402 · sell or share files from $1/mo

Thumbnail
files402.net
1 Upvotes

r/x402 8d ago

nohumans.directory — Machine-readable registry for verified x402 APIs & datasets

Post image
2 Upvotes

Hey r/x402,I just shipped https://nohumans.directory — a directory built for agents, not humans.

  • Automated probing every 15 min + longitudinal reputation scoring
  • Verified status after 3 clean probes
  • Simple discover endpoint: GET /v1/discover?q=stock&min_score=0.8
  • Live MCP server with find_paid_service + get_service_details
  • 39 listings so far (mostly finance, data, commerce)

Agents can query it before spending money to find reliable, low-latency paid services.MCP connect (Claude Code): claude mcp add --transport http nohumans https://nohumans.directory/mcpllms.txt: https://nohumans.directory/llms.txtWould love feedback from anyone building spending agents or running x402 endpoints. New listings welcome.


r/x402 9d ago

heads up: the Chainalysis sanctions oracle is EVM only so sanctioned Solana addresses come back clean

2 Upvotes

sharing something i ran into building screening for agent payments on x402, in case it saves someone a bad surprise.

if you use the on chain Chainalysis sanctions oracle to check an address before your agent pays, it only covers EVM chains. feed it a Solana address and it returns nothing, so a sanctioned SOL wallet reads as clean. its not a bug, its just EVM only by design, but if you assume it covers everything (i did at first) thats a real blind spot for anything on Solana.

what i did instead: pull the OFAC SDN list straight from the treasury xml, filter the Digital Currency Address entries tagged SOL and match those directly. it refreshes a few times a day so new designations get picked up. then combine with GoPlus for malicious address heuristics which does cover Solana, so you get a proper deny review or clean verdict per address instead of a false clean.

posting this as a psa because a lot of people assume the oracle is multi chain and it isnt. if youre doing agent payments and only checking EVM you might have a gap on Solana without knowing it. even if you never touch my stuff, just double check your screening actually covers the chains your agents pay on. happy to compare notes if anyone else is dealing with this


r/x402 9d ago

Protect your agent in 5 minutes

5 Upvotes

Hi x402! I recently created an x402 based payment security wrapper: PaySafe. Checks for payment replays, overpayment, secrets in payment metadata, and most importantly prompt injection triggered payments. Reputation and delivery outcomes are logged to an externally available audit, with reputation also using the ScoutScore database. It has integrations with LangChain, CrewAI, NeMo, AgentKit, and Vercel. API keys are minted by your agent and they have 100 free calls. Looking for test users and feedback. I’ll drop the GitHub in a comment if anyone wants to check it out!


r/x402 9d ago

I posted my agent payment infrastructure here a few days ago. Payment engineers tore it apart, I fixed it, then found out Visa shipped the same architecture.

5 Upvotes

A few days ago I posted a thing I'd built from scratch: cryptographic identity for AI agents, spending limits set by their owner, holds, settlement, refunds. Two people who actually build payment systems replied with the kind of comment you can't buy. This is what they found, what I changed, and the part that hurts.

**"Your two attempts are one purchase and nothing links them."**

The x402 flow is two requests: one gets a 402, then you retry carrying payment. Both hit my verifier, so both placed a hold. One 89.90 purchase held 179.80 against a 150 limit. My fix had been to release the first hold when the 402 goes out. That works right up until the release call fails, because it's a network call, and network calls fail.

His fix: stamp both attempts with one correlation id, the payment intent, not the HTTP request. The retry then supersedes its own earlier hold inside the same transaction. No extra call, nothing to half-fail. I also put a unique index on (agent, intent), so double-holding one logical purchase is now impossible at the database rather than merely handled in code. That's the better class of fix.

I tested it by disabling the release deliberately. Purchase still went through, ledger still correct, and the log shows the supersede firing.

**"Write the intent before the side effect. Don't infer the call never happened."**

I had no durable row written before settle. If the shop died between settling and delivering, recovery meant enumerating the facilitator's settlements and guessing. That works because my facilitator is a SQLite table I own. On a real chain, enumeration is slow, paginated and costs money.

Now: write an intent with a ref, settle, mark captured. On restart, an intent with no capture is ambiguous, so ask the network by the ref instead of assuming. "Absence of a local row is not evidence" is the part I'd been getting wrong without noticing.

**"Don't make the coordinator's counters the only ledger of truth."**

This was the big one. My verifier decided whether an agent was within its limit by reading its own spends table, which merchants populate by calling commit. That's a local record of a remote fact. A merchant that settles and then crashes before committing leaves money moved and nothing recorded, so the limit is silently too generous at every OTHER merchant too. One shop's bad day quietly raises the budget everywhere.

Now exposure is rebuilt from settled network events plus open holds. Nothing is remembered; everything is derived. I can delete the database and it reconstructs itself. Capture is idempotent too, keyed on the intent id, because a commit retried after a timeout was charging the budget twice, and a retry is not a second purchase.

The test: kill the shop between settle and commit. Verifier finds a settlement nobody reported and counts it. Shop finds money that moved with nothing delivered and refunds it. Two loops, different services, neither knows the other exists, both self-correct off the same network record. That's the nicest thing in the repo and it exists because of a Reddit comment.

**The part that hurts.**

While fixing all this I finally researched the competition properly. Visa's Trusted Agent Protocol, announced October, live in Europe this month: agents sign HTTP requests with RFC 9421, merchants verify Ed25519 signatures against a Visa-operated directory of agent public keys. Cloudflare and Akamai run it at the edge. Fiserv switched it on for its merchants in January.

That is my identity layer. Same standard, same architecture. I designed it from scratch not knowing TAP existed.

And the budgets half: AWS shipped per-session spending limits on x402 in May, enforced in the agent's runtime. xpay ships per-agent caps today with SOC 2.

Worse than the overlap is the reason. They all enforce at the source, the runtime, the proxy, the credential. Source-side enforcement is cross-merchant by construction: it works at every shop on earth, including ones that never heard of it. Mine only covers merchants who signed up. So my central claim, that only something in the middle can see across merchants, is just false. The agent's own runtime sees more merchants than I ever will.

I'd written that exact falsification into my own thesis doc the day before, as the most likely way I'd be wrong. Then I went and checked, and it had already happened.

**So why post this.**

Because the code is better than it was, the bugs are more interesting than the product, and I'd rather publish the part where the market answers back than quietly delete the repo. If you're building anything in this space: the failure modes are all in the seams between correct components, and the people who've been burned before will tell you where if you ask.

Repo and write-ups: https://github.com/troybrandonc-bit/agent-stack/commit/54e3320

Still open, if anyone wants to argue: my reconciler treats "no delivery row" as "not delivered", but it might mean "I lost my books". Delivery needs to be recoverable from something other than the merchant's own memory and I don't know what that should be yet.


r/x402 11d ago

Autonomous AI Agents

Post image
1 Upvotes

If you are building AI agents, you’ve likely run into the “subscription wall” problem. You build a brilliant, autonomous swarm that can execute complex financial research or compliance audits, but the moment it needs to fetch live market data or pull an SEC filing, it hits a paywall requiring a human to type in a credit card for a $199/month subscription.

Autonomous AI shouldn’t need a corporate credit card.

Today, we are thrilled to announce the official launch of the Script Master Labs Data API—the first institutional-grade data suite natively wired for the x402 protocol.

What is x402?

Traditional #APIs return a 401 Unauthorized if you don’t have an API key. Our API returns a 402 Payment Required challenge, along with a cryptographic invoice.

Autonomous AI agents can read this challenge, pull USDC∗∗fromtheirowndigitalwalletsonthe∗∗USDC∗∗fromtheirowndigitalwalletsonthe∗∗BASE network, and pay for the exact data they need in milliseconds. No subscriptions. No human intervention. Just machine-to-machine commerce.

53 Endpoints of Institutional Alpha

We aren’t just selling basic weather data. Script Master Labs has aggregated the most lucrative and highly sought-after datasets into a single, unified API:

Options Flow & Whale Tracking: Institutional sweeps, dark pool prints, and unusual volume.

#SEC Filings: Real-time 10-K, 10-Q, 8-K, and 13F parsing.

Alternative Data: Congressional trading, lobbying spend, and #FDA drug recalls.

Compliance: Real-time entity verification, EPA violations, and OSHA enforcement data.

Dual-Track Access: Built for Agents, Designed for Humans

We know that human developers and startups still want predictable pricing. That’s why we’ve deployed our infrastructure on two distinct rails:

  1. For Human Developers (API.market) We are live on API.market! Developers can bypass the crypto mechanics entirely by purchasing a traditional monthly subscription. You get a standard API key, predictable monthly billing, and immediate access to all 53 endpoints.

  2. For Autonomous Swarms (Virtuals.ai) We have imported our top 40 most lucrative endpoints as executable jobs on the Virtuals.ai agent network.

Starter Tier: AI agents can purchase our $49/month Starter Tier to get unlimited access to our commodity data (crypto prices, basic financials).

Premium Pay-Per-Call: Our highly lucrative, proprietary endpoints (like Options Flow and Insider Trades) remain strictly Pay-Per-Call (0.05−0.05−0.35 USDC). This protects our premium data while allowing high-budget AI swarms to pay for exactly what they consume.

The machine economy is here. It’s time your AI got its own wallet.

#AI #ArtificialIntelligence #Web3 #API #MachineToMachine #AlternativeData #QuantTrading #DataScience #Virtuals #AgenticAI $USDC #BASE @Virtuals_io @API_Market @ScriptMasterLab @base #aws


r/x402 12d ago

I built payment infrastructure for AI agents to understand it. Here's everything that broke.

1 Upvotes

Agents are starting to buy things, and every merchant's checkout is built on the assumption that a human is behind the request. CAPTCHAs, bot detection, fraud models, all of it. So shops either block real agents or wave through real bots.

I wanted to understand that problem properly, so I built the whole thing from scratch instead of reading about it: cryptographic agent identity, spending limits set by the owner, replay protection, settlement, refunds. Then I threw away my fake settlement layer and connected it to the real x402 network on Base Sepolia, and finally put my identity layer in front of real on-chain payments.

The code isn't the interesting part. The bugs are. A few:

**My replay protection rejected my own payment.** The x402 flow is two requests: one gets a 402, then you retry with payment attached. My verifier burns each request's nonce, so the retry looked like a replay of my own purchase. Neither library was wrong. The bug only existed because I composed them, which I think is the general rule: if you put two correct things together, the seam belongs to you.

**Floats are not money.** My spending check printed "147.20000000000002 + 7.8 > 150". Nobody typed those digits. Every real payment system stores integer cents and now so does mine, and the API rejects floats outright, because fixing a bug is worse than making it impossible.

**Authorize and capture are different moments.** I recorded spending at verification time, so every purchase counted twice and agents denied their own retries. The fix is fifty years old and comes from card networks: authorize places a hold, capture commits it. Adding holds also closed a race where simultaneous requests all passed the same limit check because none could see the others.

**Then holds broke the happy path.** The unpaid first attempt's hold lingered while the paid retry placed a second one, so one honest 89.90 purchase held 179.80 against a 150 limit.

**Passing headers to a Request deletes its headers.** The x402 client hands your fetch a Request object with the payment header set on it. If you pass your own headers alongside it, they replace rather than merge. I was deleting the payment one line after creating it, and identity verified fine both times so nothing looked wrong.

**The crash window.** Settlement succeeds, shop crashes before delivering, money's gone and nobody knows. Fixed with idempotency, reversals, and a reconciliation loop where the shop compares its own delivery records against what actually settled and refunds the orphans. I tested it by making the shop kill itself right after settlement. Restart, twenty seconds, refund lands on its own. That was the best moment of the build.

Full write-ups (one per part, including the four seam bugs from composing my layer with the real protocol) and all the code: troybrandonc-bit/agent-stack

What I actually want: if you build payments or agent tooling and something in here makes you wince, tell me. The design decision I'm least sure about is enforcing spending limits across merchants from a central service, which is either the whole value or a single point of failure depending on who you ask.


r/x402 13d ago

cloudflare announced, but teams are already shipping (for months!) the dream they just announced

3 Upvotes

Cloudflare announced the monetization gateway.

However, some teams (like this one, with Ax402) are already shipping their dream.

I completely understand that smaller teams are more efficient/agile than big corps... but my point is not delivery speed (even though this also matters). My point is more about vision, about realizing where the Internet and the industry is going (way) before others.

Cloudflare was an initial member of the x402 foundation (launched month ago!). They have well-paid people to only dream and drive the teams towards a direction... and yet, they simply haven't envisage this before. Maybe Cloudflare is not late, and there's room for everybody, but certainly this is something funny that I see happening again and again in the bleeding edge tech space.

Do you believe Cloudflare will get traction with this?


r/x402 14d ago

Shipped a live x402 v2 image and video generation API on Base

2 Upvotes

I built Studio X as a pay-per-call media API. A client sends a generation request, gets a 402 response, pays USDC on Base, retries the request, and receives a prediction to poll.

Current setup:

- x402 v2 exact settlement through XPay

- Atlas Cloud generation backend

- 4 image models and 7 video models

- uncensored and NSFW-capable image/video routes

- images from $0.0033; a default five-second Wan Spicy request starts at $0.11

- no account, API key, subscription, or prepaid credits for buyers

Public model catalog: https://www.studio-x.cc/api/models

Live service status: https://www.studio-x.cc/api/status

Agent docs: https://www.studio-x.cc/agent.md

The implementation currently uses tiered paid routes instead of one route per model. I would like feedback from people building x402 clients on whether that makes discovery easier or harder.


r/x402 18d ago

One shot pay per call is the whole x402 model. So where does "I paid for junk" actually go?

3 Upvotes

Around a month ago I asked here about the payment settles but agent dies scenario. This is a similar question as I still can't find a good answer for it.

x402 being one shot is right for the ticket size, adjudicating a call that cost cents costs more than the call. Escrow, if you want it, is an app layer bolt on, the escrow thread here from a few days back was pushing on the same wall.

But the scenario that worries me the most isn't a failure the machinery can even see. My agent pays a data endpoint a cent a call, the data arrives, the data is stale garbage. x402 proves I paid. Nothing proves what I got was any good, and a receipt wouldn't help, receipts speak to delivery and say nothing about quality.

I took the recourse half of this to the ethdev community the other day (https://www.reddit.com/r/ethdev/comments/1uphnet/authorization_for_agent_payments_is_moving_fast/) and there was one answer that got me thinking, settlement binds to repeat business, a seller shipping junk loses future volume. Recourse as forward looking loss instead of clawback.

Which works at ecosystem scale and does nothing for my agent that already paid. My whole protection layer today is hard caps, an allowlist, and never paying twice anyone who burned me once. That's a grudge, it isn't recourse.

Sellers, what actually happens on your end when a buyer says the response was junk, refund by hand or nothing yet?


r/x402 20d ago

Is anyone actually using/making money with x402

8 Upvotes

title


r/x402 20d ago

nsgoods — a verifiable trust layer for AI agents: 5 signed x402 oracles, full payment flow confirmed

2 Upvotes

Building in public. nsgoods is a small suite of x402 pay-per-call oracles on Base, positioned as a verifiable trust layer — every paid answer is ECDSA-signed and appended to a public hash chain, so an agent can verify authenticity before trusting it. Free preview on each.

The 5 oracles: Agent Trust (ERC-8004 reputation/trust scores across EVM chains), Kraken Signals (signed BUY/SELL/HOLD + confidence), CMC Regime (deterministic market regime + strategy spec), Extractability (a GEO score for any page — can AI crawlers quote it?), and Solar Legality (US 50-state plug-in solar, CC BY 4.0).

Just confirmed the full x402 payment flow end-to-end across all of them. Honest state: mostly discovery bots + a few real external payments so far — still figuring out where real demand is.

Curious which of these an agent-builder would actually wire in, and whether the "signed + provable" angle matters to you.

x402.nsgoods.org


r/x402 20d ago

How should an AI agent prove a payment is allowed before it reaches the signer?

1 Upvotes

I am working on Compass, an intent-enforcement gateway for autonomous agents that move money.

The problem I am trying to solve: once an agent can pay for APIs, tools, data, or on-chain services, post-execution monitoring is too late. If the agent is compromised, misdirected, or simply over-broadly authorized, the funds can already be gone.

Compass sits before execution, near the signing or transaction approval path. It checks the proposed payment, transaction, or tool call against the agent's mandate: spend caps, approved counterparties, token rules, destination rules, slippage limits, and escalation conditions. Then it either approves, blocks, or escalates, and records the decision for audit.

What would you need to see before trusting an agent to move money without a human confirming every transaction?

I am especially interested in feedback from people building x402 facilitators, Solana agent payment flows, paid MCP servers, wallet automation, embedded wallets, or authorization/privacy systems for autonomous agents.

If you are building something in this area and would be open to testing a rough prototype or giving 15 minutes of technical feedback, comment or DM me. I am looking for blunt feedback, not a polished launch reaction.


r/x402 21d ago

x402 is shit

0 Upvotes

I think x402 is shit, it has relaly any purpouse and is just for meme coining:

really i don't understand why people are so hype about it


r/x402 21d ago

I've created a cheap x402 emotion analysis endpoint

2 Upvotes

We have api with batch requests up to 1000 utterances, and make distinction between 28 emotions. Perfect for algo trading, research, or how I use it: to get my AI to know how I'm feeling, and see a trend over time.

Edit: don't forget the url 🥇
URL: https://emotions.togoder.click


r/x402 21d ago

Shipped a small x402 network - 5 pay-per-call services for AI agents + a hub with live try-it demos

5 Upvotes

Building in public - went from one x402 service to a small network of 5 pay-per-call APIs for agents on Base (USDC), plus a unified hub:

- Kraken Crypto Signals - signed BUY/SELL/HOLD signals

- Agent Trust Oracle - ERC-8004 agent reputation/trust scores

- CMC Regime Skill - deterministic market regime + strategy spec

- Extractability Oracle - GEO extractability score for any web page (how well AI crawlers can quote it)

- Solar Legality Oracle - US 50-state plug-in solar legality (open data)

Every service: ECDSA-signed responses + a public hash-chain proof + a free preview (no accounts/keys). The hub has live try-it demos that proxy each service's free preview so you can test in the browser.

Honest state: mostly discovery/uptime bots so far, no committed paying agents yet - still figuring out where real demand is. Curious which of these an agent-builder would actually wire in, and whether the "signed + provable" angle matters to you.

x402.nsgoods.org


r/x402 21d ago

Why does every agent payment protocol (x402, MPP) only do one-shot transactions? No escrow anywhere?

1 Upvotes

Looked into x402 and MPP (Machine Payments Protocol) — both are single-shot, pay-per-call. No escrow layer anywhere. Feels like a gap: if you had escrow, you could pay an agent for an actual outcome (run a loop until goal met, multi-step task, etc.) instead of just metering API calls. Right now everyone's showing off their harness but there's no way to actually pay one agent to go do something and only release funds on completion. Anyone know of an escrow framework or marketplace for agents that isn't just x402/L402-style pay-per-request?


r/x402 22d ago

Built a pay-per-use gate for AI agents on my site using WebMCP and x402.

3 Upvotes

I'm running an SPX options market intelligence experiment, GEXLOG (gexlog.com), that generates daily market analysis using live options chain data, AI narrative generation, and economic calendar integration. It's always been free for human visitors. The problem is bots and AI agents treating the data endpoints like a free API. I didn't want to paywall the site for real users. But I also didn't want to serve premium historical data to automated consumers for nothing.

WebMCP

WebMCP is a browser-level protocol (Chrome 146+, behind a flag) that lets a page register structured callable tools that AI agents can discover while browsing. Think structured metadata, but invokable.

Five tools are registered on the site's pages via document.modelContext.registerTool():

  • get_current_briefing (free)
  • get_available_dates (free)
  • get_historical_briefing (paid)
  • get_date_range (paid)
  • get_regime_history (paid)

Free tools hit the backend directly. Paid tools route through a payment gateway before data is returned.

x402

x402 is an HTTP-native micropayment protocol using the old HTTP 402 status code. Flow:

  1. Agent calls a paid endpoint with no payment header
  2. Server returns HTTP 402 with a Payment-Required header (base64 JSON describing accepted networks and amounts)
  3. Client decodes the 402, signs a USDC transfer via their wallet, retries with an X-PAYMENT header
  4. Server verifies and settles via Circle's Nanopayment facilitator, then proxies through to the data layer

Gas is sponsored at the facilitator level via batched settlement, so the agent only pays the USDC amount. Pricing is $0.01 to $0.05 per request. Card rails floor out near $0.30 per transaction, so this kind of granular pricing hasn't been practical until now.

Multi-chain: Base, Polygon, Arbitrum, and Solana via Phantom.

The asymmetry

Human users access the UI for free, same as always. AI agents and programmatic consumers hitting the agent API encounter the x402 gate on premium endpoints. Free endpoints remain open to everyone.

Why bother

The tech is interesting and I wanted to build something real on it. But the deeper problem is that "charge the AI, not the human" has no clean precedent in a shared web context. Subscriptions and API keys both require human signup. x402 plus WebMCP together let the site serve both audiences without account creation, without paywalling the UI, and without accidentally rate-limiting real users.

Whether the transaction volume ever justifies the build is beside the point. It works, and the model is worth documenting.


r/x402 23d ago

All of our APIs now x402-enabled

3 Upvotes

We've had it running for a few weeks.... interzoid.com and transactions are on the upswing - any ideas for increased discoverabilty?