Mobile & residential proxies your AI agent can buy

TWO WAYS TO ACCESS

Same residential + mobile network, same countries - two ways for an agent to buy and drive it. Pick by how it authenticates: an API key it holds, or a wallet it pays from. Most integrations use the account + API key path; x402 is there for wallet-only agents.

① Account + API key / MCP — the standard path

Create an account at client.proxies.sx, deposit GB, and generate an API key. Your AI agent then has full access to the same API these products expose — Private modems, the pool gateway, dedicated ports, rotation, usage, billing — by sending X-API-Key: psx_..., in any language, no wallet required. Prefer Claude, Cursor, or another MCP client? Point it at the MCP server:

npx @proxies-sx/mcp-server

(or the hosted https://api.proxies.sx/mcp, nothing to install) and it rents Private modems, reads live stock, builds proxy URLs, rotates IPs and reads usage as native tools (20 by default, 96 with --toolset=full). One balance, persistent keys, one dashboard — how most integrations run.

② Autonomous x402 (USDC) — for account-less agents

No account, no key: the agent pays USDC over HTTP 402 per purchase. Ideal for wallet-native agents and one-off buys. Full protocol below.

Both paths reach the same network, and balance or USDC buys a GB at $4 with the same volume discounts. They differ in authentication and in what a GB of pool traffic uses: on the account path 1.00, 0.375 or 0.1875 GB of balance by exit country (Premium, Plus, Standard: $4.00, $1.50, $0.75 per GB of traffic; tier lists in the pricing block of GET /v1/gateway/pool/stock); on x402 always 1 GB, so $4 per GB of traffic in every country.

x402 PAYMENT PROTOCOL

HTTP 402 Payment Required for machine-to-machine USDC payments. No account, no API key. The same protocol gates both buy products: Dedicated Port (/v1/x402/proxy) and Pool Gateway Access (/v1/x402/pool).

How It Works

1. Request without payment    GET /v1/x402/proxy?country=US&traffic=1
2. Receive 402 response       price, recipient wallet, supported networks
3. Send USDC on-chain         Base (~2s) or Solana (~400ms)
4. Retry with payment proof   Payment-Signature: <tx_hash>
5. Receive proxy credentials  host, port, username, password, session token

Payment Networks

Pricing

x402 purchases do not follow country tiers: $4.00 per GB of traffic in every country. The hosted (datacenter) class is not on sale at the moment. Peers are classed by the network that announces their address; on October 13, 2026 about 1% of peers on sale were still unclassified. Use -iptype-residential or -iptype-mobile to exclude them. Verify any exit IP on ipinfo.io / MaxMind / IP2Location before you pay.

Quick Start

# 1. Request proxy (receive 402 with payment info)
curl -s 'https://api.proxies.sx/v1/x402/proxy?country=US&traffic=1'

# 2. After sending USDC, retry with tx hash
curl -s 'https://api.proxies.sx/v1/x402/proxy?country=US&traffic=1' \
  -H "Payment-Signature: YOUR_TX_HASH"

# 3. Check session
curl -s https://api.proxies.sx/v1/x402/manage/session \
  -H "X-Session-Token: x402s_YOUR_TOKEN"

# 4. Replace offline port (free, max 3)
curl -s -X POST https://api.proxies.sx/v1/x402/manage/ports/replace \
  -H "X-Session-Token: x402s_YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"country":"US"}'

# 5. Top up session (pay for more traffic)
curl -s -X POST https://api.proxies.sx/v1/x402/manage/session/topup \
  -H "X-Session-Token: x402s_YOUR_TOKEN" \
  -H "Payment-Signature: NEW_TX_HASH" \
  -H "Content-Type: application/json" \
  -d '{"addTrafficGB":2,"addDurationSeconds":86400}'

Dedicated Port x402 Endpoints (+ agent registry)

Pool Gateway endpoints (GET/POST /v1/x402/pool, /v1/x402/pool/pricing, /v1/x402/manage/pool/*) are in the Pool Gateway section below and in /pool/skill.md. Live per-component health: GET /v1/x402/status.

Token = X-Session-Token: x402s_<hex> header. x402 = Payment-Signature: <tx_hash> header.

Post-Purchase Management

Port Replacement - If proxy goes offline, POST /manage/ports/replace for free replacement. Max 3 per session.
Session Top-Up  - Add traffic ($4/GB) or duration (free). POST /manage/session/topup with Payment-Signature.
Port Recreation - If port deleted but session has credit, POST /manage/ports/recreate.
IP Rotation     - GET /v1/rotate/:token to rotate IP without auth.

PRODUCTS

Three ways to buy - Private modems (a whole modem per day, week or month, paid from the account balance), Pool Gateway Access (recommended for metered GB) and the Dedicated Port (legacy, nearly full); the last two are also x402-gated at api.proxies.sx, paid in USDC. The Peer Network is the flagship supply behind them - residential + mobile IPs across the countries listed live at /v1/gateway/pool/stock - and the one way to earn.

Private modems - for anything dedicated

One whole 4G/5G carrier modem rented to you alone by the day, week or month, with unlimited traffic for the rental, paid from the account balance (not per GB, not via x402). Own HTTP and SOCKS5 host:port, rotate the IP by API or a private link, an auto-rotation interval, OpenVPN on supported lines, OS fingerprint (p0f) on some lines, Replace keeps the paid time, opt-in auto-renew. Plans in stock with their prices, no key needed: GET /v1/pricing (privateModems.plans[]); buying needs an API key with the modems:purchase scope. Private modems page · Agent guide (skill.md) · Quickstart.

Pool Gateway Access - recommended

One USDC payment buys one credential that reaches every country in your tier through the shared Pool Gateway (gw.proxies.sx:7000) - no per-country repurchase. It routes the whole network: request tier=peer for the flagship peer network (residential + mobile IPs across the countries listed live at /v1/gateway/pool/stock), or tier=mbl for the carrier modems in 6 countries. Both $4 per GB of traffic in every country on x402 (country tiers apply on the account path only), metered and capped - the gateway probes peers and routes around dead ones, so broken peers cost you nothing. Buy at GET/POST /v1/x402/pool (no payment returns HTTP 402 with the tier catalog; pay USDC and retry to receive credentials), or drive the same gateway with your account API key + deposited GB (see TWO WAYS TO ACCESS). Pool Gateway page · Quickstart · Agent guide (skill.md) · Rotation Cookbook (copy-paste IP rotation + footguns).

Dedicated Port (legacy)

The legacy per-port pool, nearly full: for a dedicated or unlimited-traffic need start with Private modems. The specialized option: your own port on a real 4G/5G modem in one of the 6 carrier-modem countries (NL, PL, US, GE, FR, GB as of last edit; it shifts with carrier supply - read live availability, not this sentence). Pick it when you need a public rotate URL for a true carrier-IP reset, or a single pinned host:port. HTTP and SOCKS5, city/carrier targeting, auto IP rotation. Free port replacement (max 3) and session top-up. Buy a Dedicated Port.

POOL GATEWAY vs DEDICATED PORT - WHICH ONE?

POOL GATEWAY = one credential on gw.proxies.sx:7000 over the whole network, every country in the tier - country, session and rotation are declared per-request in the proxy username. DEDICATED PORT = one real port on one modem, its own host:port, one country fixed at purchase - the IP holds until YOU hit the rotate URL.

The pool username IS the routing API (no SDK needed - just build the string):

psx_<accountId>-<pool>-<country>[-rot-<mode>][-sid-<name>]
#   pool:    mbl | peer | any            country: 2-letter ISO or 'any'
#   rot:     auto5|auto10|auto20|auto60 (soft-rotate) | sticky (pin) | ondemand
#   sid:     REQUIRED for a session to stick across connections
#            (use -sid-, NOT -session- - the latter is silently ignored)

# US modem, rotate every 10 min, pinned session "job42":
curl -x "http://psx_ab12cd-mbl-us-rot-auto10-sid-job42:PASS@gw.proxies.sx:7000" https://api.ipify.org

Copy-paste rotation recipes (curl / python / node) + the footguns: rotation cookbook.

IP caveats (both): mobile carriers re-NAT egress IPs on their own cadence - a dedicated port holds a MODEM you control the rotation of, not a fixed IP; pool -rot-sticky pins the MODEM for the session, never the IP. Pool sessions need a -sid-<id> token to stick across connections (-session- is silently ignored).

PICK POOL GATEWAY WHEN (the default for most agents)

> Country coverage: the peer network reaches the countries listed live at /v1/gateway/pool/stock (many have only a few devices, so check the count before a large run); retarget us → gb → pl → fr in the username per request from one credential, no repurchase.
> High fan-out: hundreds of parallel sticky sessions (distinct -sid- values land on different endpoints) through one credential.
> A fleet of agents shares one secret, one top-up, one credit meter - instead of N ports with N passwords.
> Zero babysitting: default auto10 rotates every 10 min with no API calls, dead peers/modems are routed around automatically, and you are metered so failures never cost you.

PICK DEDICATED PORT WHEN

> You need on-demand true carrier-IP resets via the public rotate URL - the pool cannot do this at all (pool rotation only re-picks an endpoint, it never resets a carrier IP).
> Cookie-bound / login / 2FA work where you want one held modem whose IP changes only when you trigger it - no selector re-picks under you.
> You must hard-pin a city or carrier at purchase, or you pay via facilitator signed intents (EIP-3009) - only this product accepts either.

Same for both: balance at $4.00/GB, duration free - you only pay for traffic. On the account path a GB of Pool Gateway traffic uses 1.00, 0.375 or 0.1875 GB of balance by exit country; a dedicated port and every x402 purchase (0.1 GB / $0.40 minimum) use 1 GB per GB. Accountless x402 flow (HTTP 402 → pay USDC on Base ~2s or Solana ~400ms → retry with Payment-Signature), same replay protection, same x402s_ session token for management. The other difference is topology: the Pool Gateway spans the whole network (peer: the countries listed live at /v1/gateway/pool/stock + the 6-country carrier modems), while a Dedicated Port is one carrier modem in one of those 6 countries (US, GB, PL, FR, NL, GE).

Will it work on my target? Check live per-country stock before a run and component health at /status/. Real mobile/residential IPs clear IP-reputation gates (DataDome t=bv, Cloudflare, PerimeterX) that flag datacenter proxies - but no vendor can promise a given site: verify your exit yourself on ipinfo.io / MaxMind before you scale. If a target still blocks clean mobile + residential, it's a genuinely hard target - that's what our managed Data Works tier is for.

Peer Network

Share mobile/residential bandwidth and earn USDC. Your payout is a revenue share set by Proxies.sx and customized per partner - there is no fixed public percentage; rates are configured by our team, can be tailored to you, and move with demand, paid NET. Read earningsPerGB in the registration response for your live per-GB value. Start earning.

MCP SERVER

@proxies-sx/mcp-server v3.2.0 on npm, also hosted at https://api.proxies.sx/mcp (send Authorization: Bearer psx_...): tools for AI agents to manage proxy infrastructure via the Model Context Protocol (Private modems, Pool Gateway, Private Pool and Reserved IPs, account, billing, dedicated ports, rotation, support, ops). It lists 20 tools by default, led by the Private modem and card top-up tools, and all 96 with --toolset=full. A wallet-only x402 mode (local npx) adds its own 16 x402_* tools, incl. buying Pool Gateway access with USDC on Base. The server self-describes via tools/list.

Install

npx -y @proxies-sx/mcp-server

Claude Desktop Config

// API Key mode (account required)
{
  "mcpServers": {
    "proxies-sx": {
      "command": "npx",
      "args": ["-y", "@proxies-sx/mcp-server"],
      "env": { "PROXIES_API_KEY": "psx_your_key" }
    }
  }
}

// x402 mode (no account needed)
{
  "mcpServers": {
    "proxies-sx": {
      "command": "npx",
      "args": ["-y", "@proxies-sx/mcp-server"],
      "env": { "AGENT_WALLET_KEY": "your_private_key" }
    }
  }
}

Tool Categories (96 tools, API-key mode)

You don't load 96: by default the server lists 20 (buy, use, manage). A scraper needs ~4: pool_get_stock, pool_get_my_credentials, pool_build_proxy_url, get_account_usage. The rest are advanced surfaces (dedicated ports, Private Pool, x402, reseller, ops) you only pull in if you use them - the count is coverage, not required context. Counts below are those of the package's tools.json; tools/list in API-key mode with --toolset=full returns exactly these 96.

PEER NETWORK - EARN USDC

Share your internet bandwidth, get paid in USDC on Solana. AI agents and humans connect via WebSocket, route traffic, earn automatically. This section is a summary - the canonical contract (binary tunnel protocol, self-test, SDK implementer checklist) is the Peer Network page and /peer/skill.md; if this page ever disagrees with them, they win.

Earnings by IP Type

Your payout is a revenue share set by Proxies.sx and customized per partner - there is no fixed public percentage; rates are configured by our team, can be tailored to you, and move with demand. Paid NET and accumulating automatically. IP type is classified server-side via ASN lookup - the value your device reports is ignored. Read earningsPerGB from the registration response for your live per-GB value. Min payout: $5 USDC (agents; Android SDK devices: $10).

How It Works

1. Register     POST /v1/peer/agents/register - get JWT + device ID
2. Connect      wss://relay.proxies.sx with Sec-WebSocket-Protocol: token.{JWT}
3. Tunnel       Receive tunnel_connect - open TCP to the target - stream bytes both ways
4. Earn         Earnings credited per GB. Request payout min $5 USDC to Solana wallet.

Fastest start - use a ready, tested SDK (it does the whole protocol for you): Node.js · Go · Windows · Android. Full guide at the Peer Network page. The inline snippets below are only for building your own client - if you do, implement the streaming tunnel_connect flow documented in /peer/skill.md, not the legacy proxy_request.

Register

curl -s -X POST https://api.proxies.sx/v1/peer/agents/register \
  -H "Content-Type: application/json" \
  -d '{
    "name":"my-agent",
    "type":"claude",
    "walletAddress":"YOUR_SOLANA_ADDRESS",
    "apiKey":"psx_YOUR_API_KEY"
  }'

# Response:
# { "deviceId": "agent_abc123", "jwt": "eyJ...", "refreshToken": "a1b2...",
#   "relay": "wss://relay.proxies.sx",
#   "earningsPerGB": { "mobile": <number>, "residential": <number>, "datacenter": <number> } }
#
# Your payout is a revenue share set by Proxies.sx and customized per partner,
# NET - there is no fixed public percentage; read earningsPerGB for your live
# per-GB value. Tier order: mobile > residential > datacenter. Rates can change anytime.
# Min payout: $5 (agents) / $10 (Android SDK).
# JWT expires in 1h - refresh via POST /v1/peer/agents/{id}/refresh.

Connect to Relay

const ws = new WebSocket('wss://relay.proxies.sx', [`token.${JWT}`]);

ws.onopen = () => {
  ws.send(JSON.stringify({ type: 'device_info', payload: { country: 'US' } }));
};

ws.onmessage = (event) => {
  const msg = JSON.parse(event.data);
  if (msg.type === 'proxy_request') {
    const { requestId, method, url, headers, body } = msg.payload;
    fetch(url, { method, headers, body: body ? atob(body) : undefined })
      .then(async (res) => {
        const buf = await res.arrayBuffer();
        ws.send(JSON.stringify({
          type: 'proxy_response',
          payload: { requestId, statusCode: res.status,
                     headers: Object.fromEntries(res.headers),
                     body: btoa(String.fromCharCode(...new Uint8Array(buf))) }
        }));
      });
  }
  if (msg.type === 'heartbeat') ws.send(JSON.stringify({ type: 'heartbeat_ack' }));
};

This snippet shows the connection handshake plus the legacy JSON proxy_request flow for illustration. Production clients must handle the binary tunnel_connect protocol - full lifecycle, message shapes, and the two porting mistakes that cause intermittent auth are in /peer/skill.md.

Peer API Endpoints

Security

Earning Potential

Your payout is a revenue share set by Proxies.sx and customized per partner - there is no fixed public percentage; rates are configured by our team, can be tailored to you, and earnings scale with demand routed through your IP - there is no fixed monthly figure. Always pull the current earningsPerGB at registration and multiply by your own throughput. Illustrative relative shape only:

Actual earnings depend on demand, location, uptime, and carrier ASN reputation.

Android SDK

// build.gradle
implementation("com.github.bolivian-peru:android-peer-sdk:1.3.2")

// Usage
ProxiesPeerSDK.init(context, "api-key", config)
ProxiesPeerSDK.getInstance().start()  // Start sharing
ProxiesPeerSDK.getInstance().stop()   // Stop sharing

SDK & PACKAGES

npm Packages

GitHub

Framework Integrations

x402 SDK release status and integration

Release status (October 12): the three x402 libraries are npm 1.0.1, which ships the compiled runtime files and rejects a failed payment verification. Do not use 1.0.0: its tarballs omit the compiled files. The hosted Proxies.sx purchase API has a separate release lifecycle.

import { Hono } from 'hono';
import { x402 } from '@proxies-sx/x402-hono';
import { verifyAndClaimSolanaPayment } from './payments.js'; // Your application

const app = new Hono();
app.get('/api/data', x402({
  amount: 0.01, // USDC
  network: 'solana',
  recipient: 'YOUR_SOLANA_WALLET',
  verifyPayment: verifyAndClaimSolanaPayment,
}), (c) => c.json({ data: 'premium content' }));

This example shows the 1.0.1 API, not a standalone payment processor. verifyAndClaimSolanaPayment is an application-owned adapter, not a package export. It must verify a confirmed successful USDC payment on the configured network to your recipient, require the quoted amount, and atomically claim the transaction in a durable ledger bound to the order/resource before returning { valid: true, amount, payer, txHash }. Reject failed RPC checks, wrong recipients/networks, insufficient amounts and reused claims. The library provides no replay ledger or working default facilitator; do not omit this adapter.

LINKS

Discovery Files (machine-readable)

Hierarchy: if this page disagrees with a skill.md, the skill.md wins; if a skill.md disagrees with the live API, the live API wins.

Live Domains

Social

Twitter/X | Telegram | GitHub | Dashboard

Support: maya@proxies.sx or Telegram. When reporting an error, quote the req id from the error message.