Live · x402 exact
ETH perpetual snapshot
# the 402 offer, no payment involved
curl -si https://provider-x402.subethalabs.com/v1/eth/snapshot \
| grep -i payment-requiredSubEtha Router
Your wallet speaks one rail.
The API speaks another.
An API can be perfectly good and still be unreachable — not because of the data, but because it settles on a rail your wallet does not hold. The Router takes a payment on one rail and pays the provider on another. Two legs, two separate funds. No swap, no bridge.
Hackathon-stage implementation on testnet. Unaudited, not production. Both legs settle for real on chain today, and the Router is reachable as a hosted MCP endpoint.
2 rails / 1 requestLIVE PROVIDERS
X402provider-x402
Base Sepolia · USDC10000
Base Sepolia · USDC10000
MPPprovider-mpp
Tempo Moderato · pathUSD10000
Tempo Moderato · pathUSD10000
Reading the 402 offer is free and open to anyone. Paying needs testnet funds on that rail.
01 / Why
The barrier is the rail,
not the data.
Paid APIs are converging on pricing per call over HTTP 402. How you pay has not converged: x402 exact on one chain, MPP tempo charge on another, each with its own asset.
Without a router
Hold the wrong asset and the endpoint is closed.
You need the exact asset, on the exact chain, that each provider demands. Two providers, two rails, two funded wallets — before you read a single byte.
With the router
Pay once, on the rail you already hold.
The Router pays the provider on theirs, from its own prefunded balance, and hands back the provider's response unchanged.
The mismatch, concretely
Same request.
Two incompatible answers.
- Both providers price the same shape of request: one call, 10000 base units.
- Neither will accept the other's asset, and neither runs on the other's chain.
- Holding one of these does not get you the other, so an agent funded for x402 simply cannot read the MPP provider.
What each provider demands
x402 exact
network eip155:84532 (Base Sepolia)
asset USDC
amount 10000
MPP tempo charge
chainId 42431 (Tempo Moderato)
currency pathUSD
amount 10000
Same price. No common rail.
02 / Try it
Two providers are live.
Check them yourself.
Self-hosted market-data providers we run. You need no wallet, no account and no permission from us to see the payment contract — an unauthenticated request returns the whole offer in the open.
Live · MPP tempo charge
Uniswap v3 spot reference
# the 402 challenge, no payment involved
curl -si https://provider-mpp.subethalabs.com/v1/eth/snapshot \
| grep -i www-authenticateBoth answer GET /v1/eth/snapshot and publish /health and /manifest. Payment is testnet; the market data is a read-only mainnet reference and is not an executable quote. Neither provider is operated by Hyperliquid or Uniswap.
03 / How it works
Two payments,
deliberately unlinked.
The Router converts nothing. It takes a payment on the inbound rail and makes a separate payment on the outbound rail, each prefunded on its own chain. Calling it a swap or a bridge would be wrong.
01 · QUOTE
Read the real offer
The Router reads the provider's live offer before quoting, so the price you approve is bound to the offer that will actually be paid.
02 · APPROVE
Explicit, bound approval
Nothing moves on a conversational turn alone. Approval is bound to one quote, and an offer that changes after approval is refused.
03 · PAY IN
Your rail, your asset
The inbound leg settles on the rail you already hold, against the Router's own address on that chain.
04 · PAY OUT
The provider's rail
A separate payment, from the Router's prefunded balance on the provider's chain. The two legs are never exchanged for one another.
05 · RECORD
At most once
A durable journal records each purchase. Repeat or concurrent requests re-send neither leg, and an uncertain outcome stays uncertain rather than retrying blindly.
04 / Scope
What runs today.
Stated narrowly on purpose, so the parts that are still being built are not mistaken for the parts that work.
Live
Two providers, publicly reachable
Both serve their 402 over HTTPS and can be inspected by anyone, without a wallet.
verified
Live
Real testnet settlement on both rails
x402 exact on Base Sepolia and MPP tempo charge on Tempo Moderato, each settled end to end against the live providers.
verified
Live
Router paying a provider
The outbound leg — the Router paying a provider on the provider's own rail — settles for real.
verified
Live
Paying the Router over x402
The inbound leg settles on chain with real funds: a caller holding only Base Sepolia USDC reaches a provider that only takes MPP. Both legs are recorded, on two different networks.
verified
Live
MCP access for agents
Discover, quote, approve and pay through the Router, over local stdio or the hosted HTTP endpoint. Both have settled real payments.
verified
Live
A hosted endpoint
One line of setup, with nothing to clone and no key to place. The Router never holds the caller's key — you sign locally and it receives only the signed credential.
verified
In progress
The SubEtha inbound leg
Paying the Router through SubEtha's own private rail, rather than x402. This one still runs against a synthetic counterparty, so the privacy claim is not yet settled on chain the way the x402 leg is.
building
Finality (deciding when a payment is canonical) is not implemented, and the existing chat UI has not been verified against this end to end. Both are listed here rather than left for you to discover.
05 / Use it
Point an agent at it.
One line.
The Router runs as an MCP server you can register with Claude Code. Nothing to clone, no install, and no key to place anywhere — you sign each payment locally and the Router receives only the signed credential.
What you need
About one cent, and no gas.
- Base Sepolia USDC — 10000 base units ($0.01) per call. A few calls' worth is plenty.
- No gas. The x402 EIP-3009 path has the facilitator submit the transaction and pay for it.
- Discovery and quoting are free. Only
purchasecosts anything.
The Router holds no key of yours. Its source reads no private key, from the environment or anywhere else, so a hosted Router cannot spend a caller's funds.
Register the hosted Router
claude mcp add --transport http \
subetha-router \
https://router.subethalabs.com/mcp
Then, from the agent
1. subetha_router_quote
→ what you will pay, with decimals
2. subetha_router_purchase
→ the quote + your signed credential
3. subetha_router_status
→ the real tx for both legs
Two things worth knowing before you try it.
Leave a few seconds between payments. The public x402 facilitator collides with its own pending transactions when calls arrive back to back — measured at 2 failures in 20 with no gap, and 0 in 15 with a three second gap.
You may see paid_data_unavailable. That means the payment went through but fetching the data did not, so the funds did move. The Router does not retry on its own, because a blind retry is how you pay twice. Retrying the call works. Our own production check hit this on the first attempt and succeeded on the second.
06 / FAQ
The short answers.
Is this a swap or a bridge?+
No. Nothing is converted and nothing crosses a chain. The Router receives a payment on one rail and makes a separate, independently funded payment on the other. The two legs are never exchanged for one another, which is why the balances on each chain have to be prefunded.
What actually settles for real today?+
Both legs. A caller paying over x402 on Base Sepolia reaches a provider that only accepts MPP on Tempo, and both payments are recorded on their own chains. What is still synthetic is the SubEtha inbound rail specifically — paying the Router privately, through SubEtha rather than x402 — so that part of the privacy story is not yet settled on chain.
Does the Router hold my key?+
No. You sign each payment locally and the Router receives only the signed credential. Its source reads no private key, from the environment or anywhere else, so the hosted Router cannot spend a caller's funds even though it settles their payments.
Do I need a wallet to check the providers?+
Not to read the offer. An unauthenticated GET returns the entire 402 challenge — price, asset, chain, recipient — and that is what the buttons above fetch live. You only need testnet funds on the matching rail if you want to actually pay and receive the data.
Can the Router spend without my approval?+
Approval is bound to one specific quote. A conversational turn alone moves nothing, and if the provider's offer changes between quoting and paying, the purchase is refused rather than paid at the new terms.
What happens if a request is retried?+
A durable journal records each purchase, so repeat or concurrent requests re-send neither leg. An outcome that cannot be confirmed is kept as uncertain rather than retried blindly, since a blind retry is how you pay twice.
Is this production software?+
No. It is a hackathon-stage implementation on testnet, unaudited, and not operated as a service. The market data the providers return is a read-only mainnet reference and is not an executable quote.
07 / Context
Why we ended up
building this.
We were building SubEtha — private machine payments for x402, settled on zERC20 — and kept hitting the same wall from the other side: a payment method is only as useful as the set of APIs that accept it. Routing is what makes a rail worth holding. The privacy work and this are the same problem approached from two ends.