Reseller workflow

A reseller integration joins two account systems: your customer and billing records, and the ProxyRequest resources that enforce proxy access. Persist the mapping explicitly at every creation step.

WORKFLOW

Provision one reseller customer

1. 01

   Read your reseller profile

   Confirm the authenticated account and role before exposing provisioning controls.

   GET /profile
2. 02

   Load available packages

   Present only products and targeting options returned for the deployment.

   GET /packages
3. 03

   Create the sub-user

   Use your own customer ID as correlation metadata where supported, then store the returned API ID.

   POST /users
4. 04

   Allocate bytes

   Convert the purchased amount to integer bytes and attach it to the created user.

   POST /users/{id}/data/add
5. 05

   Generate proxy access

   Generate credentials for the package and targeting selected by the customer.

   POST /proxies/generate
6. 06

   Activate synchronization

   Consume reseller webhook batches and schedule analytics reconciliation.

   POST /webhooks

Example orchestration

JavaScript

const api = `https://${process.env.PROXYREQUEST_API_HOST}/api/v1`;
const headers = {
  Authorization: `Static ${process.env.PROXYREQUEST_API_KEY}`,
  'Content-Type': 'application/json',
};

const userResponse = await fetch(`${api}/users`, {
  method: 'POST',
  headers,
  body: JSON.stringify({ username: 'customer-reference' }),
});

if (!userResponse.ok) throw new Error(`Create user: ${userResponse.status}`);
const user = await userResponse.json();

await fetch(`${api}/users/${user.id}/data/add`, {
  method: 'POST',
  headers,
  body: JSON.stringify({ data: 10 * 1024 ** 3 }),
});

Python

import os
import requests

api = f"https://{os.environ['PROXYREQUEST_API_HOST']}/api/v1"
headers = {
    "Authorization": f"Static {os.environ['PROXYREQUEST_API_KEY']}",
    "Content-Type": "application/json",
}

user_response = requests.post(
    f"{api}/users",
    headers=headers,
    json={"username": "customer-reference"},
    timeout=15,
)
user_response.raise_for_status()
user = user_response.json()

allocation = requests.post(
    f"{api}/users/{user['id']}/data/add",
    headers=headers,
    json={"data": 10 * 1024**3},
    timeout=15,
)
allocation.raise_for_status()

The snippets illustrate orchestration only. Use the operation schemas in the API Reference for the exact required fields enabled by your deployment.

Make the workflow recoverable

1. Generate an internal operation ID before the first API call and attach it to your logs.
2. Persist the ProxyRequest user ID immediately after creation succeeds.
3. Record the exact byte allocation request and its confirmed result.
4. If the client times out, read the resource state before repeating a write.
5. Mark the customer active only after credentials can be generated and tested.
6. Reconcile billing totals independently from webhook arrival.

Do not assume every write is idempotent

The public contract does not advertise a universal idempotency-key header. After an ambiguous timeout, inspect the user or balance state before sending the same create or allocation request again.

Deprovisioning order

When a customer leaves, stop new commercial activity first, revoke or reset proxy access, remove obsolete API-visible resources as allowed, and retain the accounting records required by your own policy. Never delete your user-ID mapping before the external cleanup is confirmed.