POOL GATEWAY ACCESS

curl "https://api.proxies.sx/v1/x402/pool?tier=mbl&country=us&traffic=1"

WHAT IT IS

Pool Gateway Access is a single credential that routes through a shared pool of real 4G/5G mobile proxies. A Dedicated Port gives you one modem on one port; one Pool Gateway credential reaches every country in your tier through one host. You select the country per request in the proxy username - no per-country repurchase.

Payment is USDC via the x402 protocol on Base or Solana. No account registration. No API key. The credential is metered and capped: its GB cap is exactly the USDC you paid. Top it up the same way.

POOL VS DEDICATED

DEDICATED PORT = one real port on one modem, its own host:port, one country fixed at purchase - the modem is exclusively yours and rotates only when YOU hit the rotate URL (carrier NAT can still re-issue the exit IP). 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.

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.

PRICING

Duration is free. You only pay for traffic. The GB cap equals the USDC you send.

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.

Live tier catalog: GET /v1/x402/pool/pricing

ENDPOINTS

HOW TO BUY (x402)

Buy request parameters (query string on /v1/x402/pool)

Step 1: Request access

curl "https://api.proxies.sx/v1/x402/pool?tier=mbl&country=us&traffic=1"

With no payment header it returns HTTP 402 with the tier catalog and the wallets to pay:

{
  "x402Version": 1,
  "error": "Payment required",
  "accepts": [
    { "scheme": "exact", "network": "base",
      "maxAmountRequired": "4000000",
      "payTo": "0xF8cD900794245fc36CBE65be9afc23CDF5103042",
      "asset": "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913" },
    { "scheme": "exact", "network": "solana",
      "maxAmountRequired": "4000000",
      "payTo": "6eUdVwsPArTxwVqEARYGCh4S2qwW2zCs7jSEDRpxydnv",
      "asset": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" }
  ]
}

maxAmountRequired is micro-USDC (6 decimals): 4000000 = $4.00 = 1 GB. The live 402 also carries an accepts[].outputSchema - ignore it: it is inherited from the dedicated-port product and is wrong for pool purchases (the real parameters are in the table above).

Step 2: Pay USDC on-chain

Send the USDC ($4 = 1 GB) to the recipient wallet on Base (~2s) or Solana (~400ms).

Step 3: Retry with the payment

curl "https://api.proxies.sx/v1/x402/pool?tier=mbl&country=us&traffic=1" \
  -H "Payment-Signature: <your_transaction_hash>"

You receive one gateway credential (username token + secret) plus a session token to manage it:

{
  "product": "pool",
  "proxy": {
    "host": "gw.proxies.sx",
    "httpPort": 7000,
    "username": "psx_<account>-mbl-us-sid-<id>-rot-sticky",
    "password": "pak_xxxxxxxxxxxxxxxxxxxxxxxx",
    "http": "http://psx_<account>-mbl-us-sid-<id>-rot-sticky:pak_...@gw.proxies.sx:7000",
    "socks5": null
  },
  "credit": {
    "allocatedGB": 1,
    "usedGB": 0,
    "remainingGB": 1,
    "expiresAt": "2026-08-01T00:00:00.000Z"
  },
  "sessionToken": "x402s_...",
  "manage": { "credit": "...", "topup": "...", "usage": "...", "regenerate": "...", "connection": "..." }
}

Persist three fields: (1) proxy.password - the pak_ secret, your gateway password; (2) sessionToken (top-level) - the x402s_ token, the ONLY way to manage or recover the credential; (3) your payment tx hash - proof of purchase. The returned proxy.username already carries your -sid- and -rot- tokens (the values you passed at buy time, or generated defaults). Use it as returned; edit only the country slot per request.

HTTP :7000 only in v1 - this x402-purchased credential is rejected on :7001 (SOCKS5). SOCKS5 is available for reseller-minted pak_ keys and regular account credentials, not the house/x402 credential.

BUILD THE USERNAME (ROUTING DSL)

One credential reaches every country in the tier. You pick the country and behaviour per connection by composing the username from --delimited tokens. The gateway lowercases the whole username and splits on -, so no token value may contain a hyphen. The pak_ secret is the password.

Anatomy

psx_<account>-mbl-<country>[-sid-<id>][-rot-<mode>][-failover-<policy>][-carrier-<slug>]   :   pak_<secret>
└──────────────────────────── username ────────────────────────────┘       (password)

required:  psx_<account>   .   mbl   .   country (2-letter ISO)
optional:  everything in [ ] - order-independent, each has a safe default

Default nuance: a username with no -rot- token gets auto10 at the gateway; the username returned by the purchase carries -rot-sticky unless you passed a different rot= at buy time.

Session ID (sid) rules - the one agents get wrong

The sid is the "port name" that makes a session persist. Use 8-64 chars of [a-z0-9_], no hyphens. The gateway parser is self-healing (it accepts whatever survives sanitization), but at purchase time a sid that sanitizes to fewer than 8 chars is silently replaced with a random one - your intended stickiness is lost. Keep to 8-64 and both the buy path and the gateway path agree:

Derive a sid from any string: lowercase it, delete every char that is not [a-z0-9_], make sure it is 8-64 chars (pad a short one), then reuse it for every request that should share an exit IP. "Order #99/A" -> order_0099a. Note: -session- is NOT a token - only -sid- creates a session.

Rotation modes

sticky-strict is the one sanctioned compound: the gateway parses it as rot=sticky plus a strict flag (the DSL splits on -), so its internal hyphen is safe - it does not break the no-hyphen rule for token values.

Sticky pins the MODEM, not the IP - mobile carrier CGNAT can still re-NAT the exit IP across calls. For the strongest hold pair sticky-strict with a stable -sid-.

Live countries (source of truth)

The mbl tier serves US, GB, PL, FR, NL, GE (Georgia), but supply moves. Read the live stock endpoint (online counts per country, no IPs) before targeting a country:

curl https://api.proxies.sx/v1/gateway/pool/stock
# { "pools": { "mbl": { "us": 40, "nl": 26, "pl": 21, "gb": 18, "fr": 17, "ge": 3 } } }

Worked examples (swap in your account + pak)

# 1) US, sticky for one customer - same exit IP across the whole workflow
http://psx_abc123-mbl-us-sid-cust_8f3a21bd-rot-sticky:pak_xxxx@gw.proxies.sx:7000

# 2) UK, default rotation - no sid, so each new connection may land on a different modem
#    (add -sid- for a stable auto10 session that re-picks the modem every ~10 min)
http://psx_abc123-mbl-gb:pak_xxxx@gw.proxies.sx:7000

# 3) Netherlands, strongest IP hold for a login/cookie flow
http://psx_abc123-mbl-nl-sid-login_7782-rot-sticky-strict:pak_xxxx@gw.proxies.sx:7000

# 4) US on T-Mobile specifically (soft carrier match - mbl uses -carrier-, not -asn-)
http://psx_abc123-mbl-us-sid-job_us01-rot-sticky-carrier-tmobile:pak_xxxx@gw.proxies.sx:7000

# Note: SOCKS5 (:7001) is NOT available for x402-purchased pool credentials in v1.
# Use HTTP :7000 only. SOCKS5 works for reseller paks and account credentials - see pool-quickstart.html.

Generate it in code (mirrors the gateway exactly)

// JavaScript
function poolUsername(account, country, { sid, rot } = {}) {
  const slug = s => String(s || '').toLowerCase().replace(/[^a-z0-9_]/g, '').slice(0, 64);
  let u = `psx_${account}-mbl-${country.toLowerCase()}`;
  if (sid) u += `-sid-${slug(sid)}`;                  // stable id, no hyphens
  if (rot && rot !== 'auto10') u += `-rot-${rot}`;     // omit for the default
  return u;
}
const user  = poolUsername('abc123', 'us', { sid: 'cust_8f3a21bd', rot: 'sticky' });
const proxy = `http://${user}:${pak}@gw.proxies.sx:7000`;

# Python
import re
def pool_username(account, country, sid=None, rot=None):
    slug = lambda s: re.sub(r'[^a-z0-9_]', '', (s or '').lower())[:64]
    u = f"psx_{account}-mbl-{country.lower()}"
    if sid: u += f"-sid-{slug(sid)}"
    if rot and rot != "auto10": u += f"-rot-{rot}"
    return u
user  = pool_username('abc123', 'us', sid='cust_8f3a21bd', rot='sticky')
proxy = f"http://{user}:{pak}@gw.proxies.sx:7000"

Output formats (HTTP :7000 - every common proxy-string layout)

Use it

Success prints the exit IP of a US mobile modem. A 407 means bad credentials or an exhausted/disabled cap - check /v1/x402/manage/pool/credit.

curl -x "http://psx_abc123-mbl-us-sid-cust_8f3a21bd-rot-sticky:pak_xxxx@gw.proxies.sx:7000" https://api.ipify.org

MANAGE YOUR CREDIT

After purchase, manage the credential with the session token (X-Session-Token header):

# Remaining GB
curl "https://api.proxies.sx/v1/x402/manage/pool/credit" \
  -H "X-Session-Token: x402s_..."

Response - metering is live and read-through (remainingGB = allocatedGB - usedGB):

{
  "tier": "mbl",
  "allocatedGB": 1,
  "usedGB": 0.2143,
  "remainingGB": 0.7857,
  "enabled": true,
  "expiresAt": "2026-07-12T00:00:00.000Z",
  "sessionToken": "x402s_..."
}

When usedGB reaches the cap, enabled flips to false automatically and the gateway rejects auth with 407. Top up to re-enable:

# Top up with more USDC (returns a 402, pay it, retry with Payment-Signature)
curl -X POST "https://api.proxies.sx/v1/x402/manage/pool/topup?addTrafficGB=2" \
  -H "X-Session-Token: x402s_..."

Lost the password but kept the session token? GET /v1/x402/manage/pool/connection re-emits the full credentials. POST /v1/x402/manage/pool/regenerate rotates the pak_ secret and keeps the username.

FOR AI AGENTS

A wallet-only agent buys Pool Gateway Access end-to-end with no human and no account:

1. GET /v1/x402/pool -> 402 catalog with pricing + wallets
2. Sign and send the USDC transaction from the agent wallet
3. Retry with the Payment-Signature header -> receive the credential; persist password, sessionToken, and the tx hash
4. Use one key across every country via the username DSL; top up the same way

Support: maya@proxies.sx or https://t.me/proxies_sx - quote the req id from any gateway error body.

Resellers can mint their own per-customer pak_ keys for the same gateway - see Build & Resell.

PAYMENT WALLETS