The Peer-to-Peer Bandwidth Network for AI Agents and Device Fleets.

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": { ... }   <- your live rate, the only authoritative number
# }

// Use the relay returned by the register response — do NOT hardcode.
// The platform geo-assigns the nearest relay (US/LATAM peers get
// wss://relay-us.proxies.sx). Honor relay_redirect for runtime migration.
const net = require('net');
const WebSocket = require('ws');
const ws = new WebSocket(registerResponse.relay, [`token.${JWT}`]);
const tunnels = new Map();
const frame = (type, sid, data) => Buffer.concat([
  Buffer.from([type, Buffer.byteLength(sid)]), Buffer.from(sid), data || Buffer.alloc(0),
]);

ws.on('open', () => {
  ws.send(JSON.stringify({ type: 'device_info', payload: { country: 'US', protocol: 'binary-v1' } }));
  // The PEER sends a heartbeat every 30s; the relay replies heartbeat_ack.
  setInterval(() => ws.send(JSON.stringify({ type: 'heartbeat', payload: {} })), 30000);
});

ws.on('message', (raw, isBinary) => {
  if (isBinary && raw[0] !== 0x7B) {             // binary-v1: 0x01 data, 0x03 close
    const sid = raw.subarray(2, 2 + raw[1]).toString();
    const sock = tunnels.get(sid);
    if (raw[0] === 0x01 && sock) sock.write(raw.subarray(2 + raw[1]));
    if (raw[0] === 0x03 && sock) sock.destroy();
    return;
  }
  const msg = JSON.parse(raw.toString());
  if (msg.type === 'tunnel_connect') {            // HTTP and HTTPS both arrive here
    const { sessionId, host, port } = msg.payload;
    const sock = net.connect(port, host);
    sock.setNoDelay(true);
    tunnels.set(sessionId, sock);
    sock.on('connect', () => ws.send(JSON.stringify({ type: 'tunnel_connected', payload: { sessionId } })));
    sock.on('data', (d) => ws.send(frame(0x01, sessionId, d)));   // raw bytes, untouched
    sock.on('close', () => {
      tunnels.delete(sessionId);
      ws.send(JSON.stringify({ type: 'tunnel_closed', payload: { sessionId } }));
    });
  }
});

curl -s "https://api.proxies.sx/v1/peer/agents/${DEVICE_ID}/earnings" \
  -H "Authorization: Bearer $JWT" | jq

curl -s -X POST "https://api.proxies.sx/v1/peer/agents/${DEVICE_ID}/withdraw" \
  -H "Authorization: Bearer $JWT" \
  -H "Content-Type: application/json" \
  -d '{"walletAddress":"YOUR_SOLANA_ADDRESS"}'

# The Node reference client registers, connects and refreshes on its own
curl -O https://agents.proxies.sx/peer/reference-sdk.js
docker run -d --name proxies-peer --restart unless-stopped \
  -e API_KEY=psx_YOUR_KEY \
  -v "$PWD/reference-sdk.js:/app/reference-sdk.js:ro" -w /app \
  node:20-alpine node reference-sdk.js

curl -s -X POST "https://api.proxies.sx/v1/peer/my-devices/${DEVICE_ID}/test" \
  -H "X-API-Key: psx_YOUR_API_KEY" | jq

// settings.gradle — add JitPack
dependencyResolutionManagement {
  repositories {
    mavenCentral()
    maven { url 'https://jitpack.io' }
  }
}

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

// Merged permissions: INTERNET, ACCESS_NETWORK_STATE, ACCESS_WIFI_STATE,
// FOREGROUND_SERVICE, FOREGROUND_SERVICE_DATA_SYNC, WAKE_LOCK, READ_PHONE_STATE.
// Request POST_NOTIFICATIONS at runtime on Android 13+.

ProxiesPeerSDK.init(
  context = applicationContext,
  apiKey  = "psx_YOUR_KEY",   // farmer.proxies.sx/api-keys?purpose=sdk
  config  = ProxiesPeerSDK.Config(
    userId           = "optional-user-id",
    onStatusChange   = { status -> /* connecting | connected | error */ },
    onEarningsUpdate = { earnings -> /* totals reported by the API */ },
  )
)

ProxiesPeerSDK.getInstance().start()  // foreground service starts
ProxiesPeerSDK.getInstance().stop()

if (sdk.isIPRotationAvailable()) {
  sdk.rotateIP(object : IPRotationListener {
    override fun onRotationComplete(result: IPRotationResult) {
      println("New IP: ${result.newIp}")
    }
  })
} else {
  sdk.openIPRotationSettings()
}

// Coroutine version
val result = sdk.rotateIPAsync()