POOL GATEWAY ACCESS

# get your ready-to-use gateway credentials
curl https://api.proxies.sx/v1/gateway/credentials -H "X-API-Key: YOUR_API_KEY"

# then just point any HTTP client at the gateway (country picked in the username):
curl -x "http://psx_<accountId>-peer-us:YOUR_PROXY_PASSWORD@gw.proxies.sx:7000" https://api.ipify.org

curl "https://api.proxies.sx/v1/x402/pool?tier=peer&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.

Pay however suits you: deposit GB on an account and drive it with an API key, or pay accountless USDC via the x402 protocol on Base or Solana. Either way the credential is metered and capped and tops 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 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: balance at $4.00/GB, duration free - you only pay for traffic. On the account path a GB of pool 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, and the same real ProxySmart 4G/5G carrier modems in the same 6 carrier-modem countries (US, GB, PL, FR, NL, GE) — the mbl tier. The other difference is topology.

PRICING

Duration is free. You only pay for traffic. On the account path you buy balance at $4/GB, $2.40/GB at 250 GB+, and a GB of traffic uses that balance at a rate set by the exit country of the device that served it (live since October 12, 2026):

Which country is in which tier is in the pricing block of GET /v1/gateway/pool/stock (no auth): basePricePerGB, volumeDiscounts, defaultTier and tiers[] with tier, name, burnRate, pricePerGB and countries. On October 13, 2026 Premium listed 27 countries, Plus 25 and Standard every other country; read the lists from the endpoint, because they can change. Field reference and a full example: /pool/skill.md.

x402 purchases do not follow country tiers. The USDC you send buys a GB cap that counts raw traffic: $4 per GB in every country, volume-discounted by the size of the purchase. The same holds for reseller pak_ keys with a cap and for dedicated ports.

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. Most peer stock is residential, and the carrier modems are mobile. 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": "socks5://psx_<account>-mbl-us-sid-<id>-rot-sticky:pak_...@gw.proxies.sx:7001"
  },
  "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 and SOCKS5 :7001 both work for this credential (and every other credential shape), GB metered identically on either.

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: use -sid-. -session- is NOT a token and creates no session; right after the account id it fills the pool and country slots (any pool, any country).

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 (hard carrier filter - -carrier- is preferred on mbl)
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.
# HTTP :7000 and SOCKS5 :7001 both work, for every credential shape - 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

USE IT FROM YOUR AGENT

Same credential in every stack. Username psx_<id>-peer-us-rot-sticky-sid-x = peer pool, US exit, sticky session x (use a stable 8-64 char id per workflow); password = your proxy password or pak_ key. Swap peer for mbl to force a carrier modem (US, GB, FR, NL, PL, GE), or edit the country slot per request.

curl -x "http://psx_<id>-peer-us-rot-sticky-sid-x:PASSWORD@gw.proxies.sx:7000" https://api.ipify.org

# SOCKS5 instead (same credential, same metering):
curl --proxy "socks5h://psx_<id>-peer-us-rot-sticky-sid-x:PASSWORD@gw.proxies.sx:7001" https://api.ipify.org

import requests

PROXY = "http://psx_<id>-peer-us-rot-sticky-sid-x:PASSWORD@gw.proxies.sx:7000"
r = requests.get("https://api.ipify.org", proxies={"http": PROXY, "https": PROXY}, timeout=30)
print(r.text)

import { fetch, ProxyAgent } from 'undici';

const dispatcher = new ProxyAgent('http://psx_<id>-peer-us-rot-sticky-sid-x:PASSWORD@gw.proxies.sx:7000');
const res = await fetch('https://api.ipify.org', { dispatcher });
console.log(await res.text());

import { chromium } from 'playwright';

const browser = await chromium.launch({
  proxy: { server: 'http://gw.proxies.sx:7000', username: 'psx_<id>-peer-us-rot-sticky-sid-x', password: 'PASSWORD' },
});
const page = await browser.newPage();
await page.goto('https://api.ipify.org');
console.log(await page.textContent('body'));
await browser.close();

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(proxy={
        "server": "http://gw.proxies.sx:7000",
        "username": "psx_<id>-peer-us-rot-sticky-sid-x",
        "password": "PASSWORD",
    })
    page = browser.new_page()
    page.goto("https://api.ipify.org")
    print(page.text_content("body"))
    browser.close()

package main

import (
	"fmt"
	"io"
	"net/http"
	"net/url"
)

func main() {
	proxy, _ := url.Parse("http://psx_<id>-peer-us-rot-sticky-sid-x:PASSWORD@gw.proxies.sx:7000")
	client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxy)}}
	res, err := client.Get("https://api.ipify.org")
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()
	b, _ := io.ReadAll(res.Body)
	fmt.Println(string(b))
}

# pip install browser-use            (Python 3.11+, then: playwright install chromium)
# Chromium ignores credentials in HTTP_PROXY/HTTPS_PROXY, so pass the proxy to the browser profile.
import asyncio, uuid
from browser_use import Agent, BrowserSession, BrowserProfile, ChatOpenAI

sid = uuid.uuid4().hex[:12]                      # one sticky exit per run
profile = BrowserProfile(proxy={
    "server": "http://gw.proxies.sx:7000",
    "username": f"psx_ACCOUNT_ID-peer-us-rot-sticky-sid-{sid}",
    "password": "PROXY_PASSWORD",
})
agent = Agent(task="Open https://api.ipify.org?format=json and read the ip",
              llm=ChatOpenAI(model="gpt-4o-mini"),
              browser_session=BrowserSession(browser_profile=profile))
asyncio.run(agent.run())

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.

FAQ

How do I use Proxies.sx with browser-use?

Pass the proxy to the browser profile: BrowserProfile(proxy={server: http://gw.proxies.sx:7000, username: psx_<id>-peer-us-rot-sticky-sid-x, password: your proxy password}) and hand it to Agent via BrowserSession. Chromium drops credentials given in HTTP_PROXY/HTTPS_PROXY, so env vars alone do not work. Change the country slot (us, gb, de ...) or the -sid- value per task.

How do I set the proxy in Playwright?

Pass the proxy option at launch: server http://gw.proxies.sx:7000, username psx_<id>-peer-us-rot-sticky-sid-x, password your proxy password or pak_ key. It is the same option in Node and Python. Give each browser context its own -sid- value if you want each on its own exit.

Rotating or sticky - which do I want?

-rot-auto5, auto10, auto20 and auto60 re-pick an endpoint on that interval (auto10 is the default); -rot-ondemand re-picks only on a new connection; -rot-sticky pins one endpoint for the session. sticky and auto* need a -sid-<id>, or every connection is a fresh session. Sticky pins the modem, not the IP: mobile carriers re-NAT their egress on their own schedule. Unknown tokens are dropped silently - there is no -session- token, only -sid-.

When should I use mobile (mbl) rather than residential (peer)?

peer is the default: residential and mobile IPs across the countries listed live at /v1/gateway/pool/stock. mbl forces a real carrier modem and exists in exactly six countries: US, GB, FR, NL, PL and GE (Georgia, not Germany - use peer-de for Germany). Pick mbl when the target trusts carrier-grade mobile IPs most; pick peer for every other country or when you want a residential exit. Same price either way.

What does the Pool Gateway cost?

Balance costs $4 per GB, falling to $2.40 per GB at 250 GB and above. A GB of traffic uses 1.00, 0.375 or 0.1875 GB of balance by the exit country: $4, $1.50 or $0.75 per GB of traffic at the base price. The tier of each country is in the pricing block of GET /v1/gateway/pool/stock. x402 purchases cost $4 per GB of traffic in every country. Duration is free - you pay only for traffic, metered identically on HTTP :7000 and SOCKS5 :7001. Sign up at client.proxies.sx/signup, deposit GB and mint an API key at client.proxies.sx/account - or pay per purchase in USDC via x402 with no account.

PAYMENT WALLETS