What are “agentic proxies”?

Agentic proxies are mobile proxies an autonomous AI agent can acquire and operate without a human in the loop. Instead of a person signing up, copying an API key, and topping up a balance, the agent pays per request with stablecoins over the open x402 protocol and receives proxy credentials directly. The whole purchase-and-manage loop is exposed as machine-callable endpoints and as MCP tools, so an agent like Claude Code or Cursor can do it natively.

What is the x402 protocol?

x402 revives the long-dormant HTTP 402 “Payment Required” status code as a real machine-to-machine payment flow. The client requests a resource; the server answers 402 with the price and a wallet address; the client pays USDC on-chain (Base or Solana) and retries with the transaction hash as proof in a Payment-Signature header; the server verifies the payment and returns the resource. For proxies, the resource is a set of mobile credentials plus a sessionToken. It needs no accounts, API keys, or card processors.

Do I really not need an API key or an account?

For the x402 path, correct — the agent’s wallet is its identity. There is no signup, no dashboard login, and no stored API key; payment proof on-chain authorizes each request. (The reseller/Pool Gateway path does use psx_/pak_ keys, because there you are provisioning long-lived keys for your own customers.) This is what makes x402 proxies genuinely “agentic”: an agent with a funded wallet can buy bandwidth entirely on its own.

Which blockchains and tokens does it use?

Payments are USDC (a US-dollar stablecoin) on two networks: Base, with roughly 2-second settlement and about $0.01 of gas, and Solana, with roughly 400-millisecond settlement and about $0.0001 of gas. The agent pays from its own wallet; there is no monthly subscription — you pay for the traffic you use.

What is the MCP server and which agents support it?

The Model Context Protocol (MCP) server, @proxies-sx/mcp-server, exposes 72 proxy-management tools across 10 categories (account, ports, rotation, billing, crypto payments, x402 session handling, and more) to any MCP-compatible client — Claude Code, Cursor, Windsurf, Claude Desktop. You install it with npx -y @proxies-sx/mcp-server, and in x402 wallet mode it needs no API key. It is the same idea as Coronium’s own MCP server: make proxies first-class tools your agent can call.

Are these real mobile IPs or datacenter?

Real 4G/5G mobile IPs, served from 131 physical devices across six countries (US, DE, GB, FR, ES, PL). IP type is classified server-side by ASN and cannot be spoofed, which is also how the peer network prices payouts (mobile carriers pay the highest tier). For agents doing scraping, ad verification, or account work, carrier IPs are what survive the bot defenses that block datacenter ranges.

How is this different from buying proxies the normal way?

The normal way is human-shaped: visit a site, create an account, enter a card, top up a balance, copy an API key, store it as a secret. x402 collapses all of that into one HTTP exchange paid by wallet, which an agent can perform unattended and repeat per task. You trade the convenience of a hosted dashboard for true autonomy and pay-as-you-go granularity down to $0.40.

How does this relate to Coronium?

It’s the agent-native layer of the same mobile-proxy ecosystem. Coronium provides dedicated 4G/5G devices, country pages, a managed concierge, and its own MCP server and AI-agent specs; agents.proxies.sx is the x402 + crypto-paid, no-API-key gateway and peer network for autonomous agents (same GitHub org, github.com/bolivian-peru, that ships the open-source reseller kit). If you’re building an AI agent that needs real IPs without a human billing step, this is the path.

AI AGENTS · x402 · MCP

2026 · Researched

Agentic proxies: mobile IPs your AI agent can buy by itself

A new layer of the mobile-proxy stack lets an autonomous agent acquire real 4G/5G IPs with no API key and no account — paying USDC on-chain over the open x402 protocol, and managing everything through a 72-tool MCP server for Claude Code, Cursor and Windsurf. Here’s how the whole agentic proxy stack works.

USDC on-chain Base · Solana 72 MCP tools

x402·agentic checkout

on-chain

AI agent

gw.proxies.sx

GET /v1/x402/proxy

Agent requests a proxy — no API key

Base~2s settle No API keyReal 4G/5G

countries

131

real devices

per GB

MCP tools

API endpoints

API keys needed

What “agentic” changes about proxies

Every proxy product so far was built for a human: you sign up, paste a card, top up a balance, copy an API key, and store it as a secret your code reads. That works when a person is driving. It breaks the moment an autonomous agent is — agents don’t have credit cards, shouldn’t hold your master key, and need to acquire resources mid-task, per task, without stopping to ask.

Agentic proxies remove the human-shaped steps. The agent pays for exactly the bandwidth it needs, from its own wallet, in the same HTTP round-trip that asks for the proxy. It’s the demand-side mirror of the trend we covered in the closing web and Pay-Per-Crawl: as the web turns into a network of machines paying machines, the proxy layer is becoming one an agent can operate end-to-end on its own.

The agent’s checkout

x402: paying for a proxy in one HTTP round-trip

x402 turns the dormant HTTP 402 “Payment Required” status into a real machine-to-machine payment flow. Five steps, no card processor, no account:

Request

The agent calls GET /v1/x402/proxy with a country and traffic amount. No account, no API key, no signup.

402 Payment Required

The server answers with HTTP 402 and a machine-readable body: the price ($4/GB), the wallet to pay, and the accepted networks.

Pay on-chain

The agent sends USDC from its own wallet on Base or Solana — settlement in seconds for a fraction of a cent.

Retry with proof

The agent repeats the request with a Payment-Signature header carrying the on-chain transaction hash.

Credentials issued

The server returns the proxy host/port/login and a sessionToken (x402s_…) used for every later session call.

x402 quick start

# 1. Agent requests a proxy — no key, no account
curl "https://api.proxies.sx/v1/x402/proxy?country=US&traffic=1"

# 2. Server replies 402 Payment Required with the price + wallet
#    { "price": "$4/GB", "pay_to": "0x…", "networks": ["base","solana"] }

# 3. Agent sends USDC on-chain, then retries with the tx hash as proof
curl "https://api.proxies.sx/v1/x402/proxy?country=US&traffic=1" \
  -H "Payment-Signature: <onchain_tx_hash>"

# → 200 OK
#   { host, http_port, socks_port, login, password,
#     sessionToken: "x402s_…" }   # used for all later session calls

Base

~2-second settlement · ~$0.01 gas

Solana

~400-millisecond settlement · ~$0.0001 gas

Tools, not docs

MCP: the proxy becomes something your agent can call

A REST API still needs the agent to read docs and hand-roll requests. The Model Context Protocol (MCP) server exposes the whole proxy surface as 72 typed tools across 10 categories — account, ports, rotation, billing, crypto payments, x402 sessions — so Claude Code, Cursor, Windsurf and Claude Desktop can buy, rotate and replace proxies as first-class actions. In x402 wallet mode it needs no API key.

install the MCP server

# Give Claude Code / Cursor / Windsurf 72 proxy tools.
# In x402 wallet mode, no API key is required.
npx -y @proxies-sx/mcp-server

It’s the same pattern as Coronium’s own MCP server and our machine-readable agent specs — wire it into the same agents you set up in our Claude Code and Cursor proxy guides.

Three ways to plug into the network

Buy bandwidth, earn it, or resell it — each is a few endpoints away.

Buy — pay per request

Your agent pays USDC on-chain at $4/GB ($0.40 minimum) via x402 and gets real 4G/5G credentials. Free port replacements (max 3) and traffic top-ups are themselves x402 calls.

GET /v1/x402/proxy

Earn — share bandwidth

Run a peer node (Windows .exe, Node, Go, Android) and earn USDC per GB you serve, priced by IP tier: mobile > residential > datacenter. Payouts from a $5 minimum.

POST /v1/peer/agents/register

Build & resell

Mint per-customer pool keys (pak_*), drop in a <PoolPortal /> React component or the Next.js storefront, and resell pool access under your own brand. MIT-licensed toolkit.

POST /v1/reseller/pool-keys

Under the hood: the pool gateway

Beyond per-request x402, there’s a long-lived Pool Gateway for steady workloads and resale: one HTTP endpoint on :7000 and SOCKS5 on :7001. Routing is encoded right in the username — pool, country, carrier, session stickiness and rotation mode — so a single credential can express exactly what you want.

pool gateway URL grammar

# Long-lived pool gateway — HTTP :7000 · SOCKS5 :7001
http://{username}:{pak_key}@gw.proxies.sx:7000

# Username tokens steer the route:
#   mbl  → premium mobile pool      peer → best-effort peer pool
#   us|de|gb|fr|es|pl → country      sid-… → sticky session
#   rot-sticky | rot-auto10          → rotation mode
http://psx_acme-mbl-us-sid-cust123-rot-sticky:pak_a1b2c3@gw.proxies.sx:7000

mbl vs peer

mbl is the premium dedicated-mobile pool; peer is the best-effort shared network.

Honest by design

IP type is classified server-side by ASN and can’t be spoofed; “stickiness pins the modem, not the IP.”

Why this matters if you build AI agents

Agents that browse, scrape, verify ads, or operate accounts hit the same wall a human does: the target blocks datacenter IPs and flags anything that doesn’t look like a real device. Until now, giving an agent a clean mobile IP meant a human pre-provisioned it. x402 + MCP closes that gap — the agent requests, pays, and connects on its own, with carrier-grade IPs that pass the checks.

It slots into the same toolchain as the rest of our agent work: Browser Use, Claude Computer Use, scraping in the agentic era, and Coronium’s dedicated 4G/5G mobile proxies for the jobs that want a managed, human-backed setup instead.

Agentic proxies FAQ

Give your agent its own proxies

Pay-per-request mobile IPs over x402, a 72-tool MCP server, and a managed 4G/5G fleet behind it — pick the autonomy you want, from fully agentic to fully concierge.