Per request
The default. One x402 micropayment per fetch, settled as it happens.
- No account, no key
- Residential exit included
- Failed requests refunded
- Budget ceilings enforced
The first residential proxy and VPN an AI agent can use on its own. No account to create, no key to leak — one x402 micropayment per request, settled on-chain in fractions of a cent.
[ WHY AGENTS GET STUCK ]
An agent can't sign up for a VPN — signup needs an email, a card and a checkbox. It can't safely hold your API key, because a key in a context window is a key one prompt injection away from leaving. And the moment it runs from a datacenter, it gets captcha-walled by everything worth reading.
Signup flows want an email, a card and a human clicking accept.
Long-lived credentials in a context window are a breach waiting to happen.
Cloud ranges are blocked or captcha-walled by almost everything.
Flat plans give you no way to cap what one runaway loop can spend.
THE WAY IT WORKS TODAY
WITH ION AGENTS
The paymentisthe authentication. There is nothing else to hold, rotate or leak.
[ HOW x402 WORKS ]
402 Payment Required has been in the spec since 1997, unused. x402 finally gives it a settlement layer — and it turns out to be exactly the primitive software needs to buy things for itself.
A plain HTTP request to the gateway. No Authorization header, because there is no account for one to point at.
A 402 response carries the amount, the asset and the address — machine-readable, so no human has to read a pricing page.
A signed payment from the agent's own wallet, within the budget its operator set. Settlement takes milliseconds and costs a fraction of a cent.
The request exits through a consenting residential connection in the geography that was asked for. No captcha, because nothing looks automated.
[ QUICKSTART ]
There is no console to log into and no key to provision, so the getting-started guide is the code. Fund a wallet, set a budget, point the client at the gateway.
import { IonAgent } from "@ice/agent";
const agent = new IonAgent({
wallet: process.env.ION_WALLET,
budget: "2.00 USDC", // hard ceiling
geo: "US/tx/austin"
});
const page = await agent.fetch(url);
// paid 0.0004 · exit 24.28.119.60 · 240 ms
console.log(agent.spent()); // "0.0128 USDC"
# 1 — ask. no auth header at all.
curl https://p.ice.io/v1/fetch \
-d '{"url":"https://example.com"}'
402 Payment Required
x-402-amount: 0.0004
x-402-asset: USDC
x-402-address: 0x9f2c…44e1
# 2 — pay and repeat, one header.
curl https://p.ice.io/v1/fetch \
-H "x-402-payment: $SIGNED" \
-H "x-ion-geo: DE/berlin/telekom" \
-d '{"url":"https://example.com"}'
200 OK
{
"mcpServers": {
"ion": {
"command": "npx",
"args": ["-y", "@ice/mcp-proxy"],
"env": {
"ION_WALLET": "0x…",
"ION_BUDGET": "2.00 USDC",
"ION_GEO": "US/tx/austin"
}
}
}
}
// exposes: ion_fetch, ion_browse, ion_geo
{
"status": 200,
"exit": {
"type": "residential",
"isp": "Spectrum",
"cc": "US"
},
"timing": { "connect": 21, "total": 240 },
"payment": {
"rail": "x402",
"amount": "0.0004 USDC",
"settled": true
},
"captcha": false,
"logs_retained": 0
}
[ WHAT YOU GET ]
Nothing to provision, nothing to rotate, nothing that survives a prompt injection. An agent that gets compromised can spend the budget in its wallet and not one cent more.
$0.0004 a request, settled the moment it happens. No plan to size in advance, no unused commitment at the end of the month, no invoice reconciliation.
Every request exits through a real household on a real consumer ISP, in the geography you asked for. The captcha rate drops to what a person at home sees.
Hard limits per session, per day and per agent, enforced at the wallet. The worst case for a broken loop is a small number, not a support ticket.
Each agent spends from its own wallet, so attribution is arithmetic rather than guesswork. Usage streams to a webhook in real time.
Billing runs on the payment rail, not on request records, so what your agents fetch is never written down on our side at all.
Set a ceiling when you construct the agent. The client refuses to sign past it, the gateway refuses to serve past it, and both are enforced before anything is spent rather than reported after. There is no overage bill, because there is no mechanism to produce one.
[ PRICING ]
There is no plan to choose and no seat to buy. Fund a wallet and spend what you actually use.
The default. One x402 micropayment per fetch, settled as it happens.
For fleets moving serious traffic — same network, billed on bytes instead of calls.
Building on ION for yourself as well? The consumer stack includes agent credit.
Settled in USDC on the ION chain · First gigabyte free · No card, no invoice, no sales call
[ COMPARE ]
| Feature comparison | Consumer VPN | Proxy API with keys | ION Agents |
|---|---|---|---|
| Signup needed | Human, card, email | Human, then a key | None |
| Credential to leak | Account password | Long-lived API key | None |
| Blast radius if compromised | The whole account | Whole plan balance | Wallet budget only |
| Billing granularity | Monthly | Prepaid blocks | Per request |
| Per-agent attribution | No | Key per agent, manual | Wallet per agent |
| Exit type | Datacenter | Mixed | Residential |
| Captcha rate | High | Medium | Household baseline |
[ USE CASES ]
A research agent that hits a captcha is a research agent that stops. Residential exits keep long autonomous runs going without a human unblocking them.
Fares and prices are geo-personalised. An agent that exits inside the market sees what its user would see, not the datacenter version.
Check availability, pricing and content from dozens of countries on a schedule, paying only for the checks that actually run.
Because settlement is per request, a platform can pass exact cost through to its own users with no plan sizing in between.
Pin an exit geography so a benchmark sees the same internet on every run, and attribute cost to the run that spent it.
Hand a sandboxed tool a wallet with two dollars in it. That is the entire security review for its network budget.
[ FAQ ]
You fund a wallet once and the SDK handles everything after that — signing, settlement, retries, refunds on failure. If you'd rather not touch it at all, the same network is available through ION Proxies with ordinary card billing. x402 exists here because it's the only way an agent can pay without a human, not because payments needed to be more interesting.
The wallet holds only what you put in it, and budgets are enforced in two places — the client refuses to sign past the ceiling and the gateway refuses to serve past it. Set a session budget of two dollars and two dollars is the entire worst case, including for an agent that has been prompt-injected.
Settlement adds a few milliseconds and is pipelined against the fetch, so median end-to-end response is 240 ms including the exit hop. Payments also batch on the rail behind the scenes — the per-request accounting is exact without a per-request chain write.
It's retried on a fresh exit inside the gateway. If it still fails, the payment is refunded automatically — you only pay for responses you actually got. The refund count is in every usage report.
Same network, same exits, same targeting. The difference is the front door: ION Proxies expects a human to hold an account and a key, ION Agents expects nobody to. If your agents run under your own supervision with your key, the proxy API is simpler. If they run autonomously, or you're handing network access to code you don't fully trust, this is the one you want.
Yes — allowlists and blocklists per wallet, plus the network-wide category blocks that apply to everyone. Node operators can also refuse categories on their own connection, so restrictions exist on both ends.
The gateway and the agent API are live for early partners today, ahead of the consumer apps. Keys and trial credit are issued in join order.
[ 06 · AGENTS ]
API access, a free trial gigabyte, and founding rates for teams that build before launch.
Keys issued in join order · no sales call required