PROXIES.SX

TWO WAYS TO ACCESS

Same real 4G/5G modems, same $4/GB, same countries - two ways for an agent to buy and drive them. 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 — dedicated ports, the pool gateway, 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

and it creates ports, buys GB, rotates IPs, and reads usage as native tools (79 tools). 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 modems in the same countries at the same $4/GB with the same volume discounts. The only difference is authentication.

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

Real mobile IPs, not datacenter relabelled as "residential" - the cheap kind that gets flagged the moment you hit a protected site. 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

Two ways to buy - Dedicated Port and Pool Gateway Access, both x402-gated at api.proxies.sx, paid in USDC. One way to earn - the Peer Network, where agents and devices share bandwidth for USDC.

Dedicated Port

Your own port on a real 4G/5G modem. The country set is live and rotating (NL, PL, US, GE, FR, GB as of last edit; it shifts with carrier supply - read live availability, not this sentence). HTTP and SOCKS5, city/carrier targeting, auto IP rotation. Free port replacement (max 3) and session top-up. Buy a Dedicated Port.

Pool Gateway Access

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. Metered and capped. v1 tier mbl (production modems), $4/GB. Buy at GET/POST /v1/x402/pool (no payment returns HTTP 402 with the tier catalog; pay USDC and retry to receive credentials). Pool Gateway page · Quickstart · skill.md · Rotation Cookbook (copy-paste IP rotation + footguns).

DEDICATED PORT vs POOL GATEWAY - WHICH ONE?

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. POOL GATEWAY = one credential on gw.proxies.sx:7000, every country in the tier - country, session and rotation are declared per-request in the proxy username.

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 DEDICATED PORT WHEN

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

PICK POOL GATEWAY WHEN

> Multi-country work from one purchase: same key, edit us → gb → pl → fr in the username per request.
> High fan-out: hundreds of parallel sticky sessions (distinct -sid- values land on different modems) through one credential.
> A fleet of agents shares one secret, one top-up, one credit meter - instead of N ports with N passwords.
> You want zero babysitting: default auto10 rotates modems every 10 min with no API calls, and dead modems are routed around automatically.

Same for both: $4.00/GB, 0.1 GB ($0.40) minimum, duration free - you only pay for traffic. 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, and the same real ProxySmart 4G/5G carrier modems in the same ~6 countries (US, GB, PL, FR, NL, GE). The difference is topology, not hardware or price.

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. Per-GB rates are set by IP type (mobile > residential > datacenter) and are dynamic - read earningsPerGB in the registration response for live values. Start earning.

MCP SERVER

@proxies-sx/mcp-server v2.2.0 on npm - 79 tools for AI agents to manage proxy infrastructure via the Model Context Protocol (61 API-key tools incl. the ops + pool groups, 18 wallet-only x402 tools incl. buying Pool Gateway access with USDC). 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", "PREFERRED_NETWORK": "base" }
    }
  }
}

Tool Categories (79 total)

You don't load 79. A scraper needs ~5: purchase_shared_traffic, create_port (or mint a pool credential), rotate_port, list_available_countries, get_account_usage. The rest are advanced surfaces (x402, reseller, ops) you only pull in if you use them - the count is coverage, not required context.

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

Per-GB earnings accumulate automatically. IP type is classified server-side via ASN lookup - the value your device reports is ignored. Rates are dynamic: read earningsPerGB from the registration response. 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> } }
#
# Per-GB rates are set by the platform - read earningsPerGB for live values.
# 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

Earnings depend entirely on 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.1")

// 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 Example

import { Hono } from 'hono';
import { x402Middleware } from '@proxies-sx/x402-hono';
import { verifySolanaPayment } from '@proxies-sx/x402-solana';

const app = new Hono();
app.use('/api/*', x402Middleware({
  price: 10000,  // $0.01 in micro-units
  recipient: 'YOUR_SOLANA_WALLET',
  verify: verifySolanaPayment,
}));
app.get('/api/data', (c) => c.json({ data: 'premium content' }));

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.