Can I build a proxy reseller dashboard by pasting one prompt into Claude Code?

Yes. Copy PROMPT.md from the open-source coronium-reseller-kit and paste it into Claude Code (or Cursor, Windsurf, Aider). The agent scaffolds a working Next.js 14 App Router dashboard (~1,400 LOC) plus a standalone Node + Express webhook receiver in one shot. The repo ships AGENTS.md and llms.txt so the agent understands the Coronium API v3 surface without hand-holding. You supply branding and a server-side API key, which turns a multi-week backend build into an afternoon.

Do I need a backend team or my own servers to start reselling mobile proxies?

No. There is no hardware to own in the API-wholesale model, unlike phone-farm programs that make you buy Android phones and SIMs. You buy dedicated 4G/5G modems programmatically from your funded balance, and the AI-scaffolded kit handles the dashboard, buy flow, and webhook receiver. The only thing you host is the kit’s server-side app, which keeps your JWT off the browser.

What happens when a 4G or 5G modem dies or its IP changes — do my customers just break?

No. Coronium pushes modem.replaced and modem.dead webhooks that carry the full new credentials. The kit’s auto-swap handler receives the event and updates the affected customer’s stored proxy server-side automatically, so the connection self-heals before a ticket is filed. You can also call restart (rotate) and replace from the API yourself. This eliminates the single biggest hidden reseller cost: manually re-issuing dead-modem credentials.

How do I map proxies to my end customers without a sidecar database?

Every Coronium modem carries a freeform metadata JSON field. The kit writes the customer identity (customer_id, tags) into that field, so the mapping lives on the device itself and travels with it through replacements. There is no separate user/billing database to host, secure, migrate, or keep in sync, and no spreadsheet to drift. The kit’s metadata-strategy doc explains the recommended schema.

What profit margin should I charge when reselling mobile proxies?

Per the kit’s pricing-markup doc, wholesale runs roughly $49–$69 per modem-month and a common retail markup is 1.3×–2.2×, with 1.3× as the floor. A $59 modem at 1.8× retails near $106 for about $47 gross profit per modem-month. Real margin depends on your support quality and churn, which is exactly why automating dead-modem auto-swap and honest rotation matters. Use the proxy farm calculator to model your own numbers.

How do I keep my API key secure, and when I rotate an IP how do I know it changed?

The kit keeps the 365-day Bearer JWT server-side only, so it never reaches the browser, and customer-protection is enforced server-side so a customer cannot touch inventory they do not own even by tampering with the client. For rotation, call the endpoint with ?sync=true, which returns the honest post-rotation IP outcome instead of a fire-and-forget 200 — your dashboard reports the real new IP or an honest failure, killing a whole class of "rotation did nothing" tickets.

Which AI coding agents can scaffold the Coronium reseller kit?

Claude Code, Cursor, Windsurf, and Aider all work. The repo includes PROMPT.md (the one-shot prompt), AGENTS.md (agent instructions), and llms.txt (machine-readable context) specifically so any file-aware coding agent can read the Coronium API v3 surface and wire up the dashboard. Coronium also ships an MCP server for deeper in-editor proxy management.

Is it legal to white-label and resell mobile proxies under my own brand?

Reselling is a standard, legitimate business model. Coronium applies an Acceptable Use Policy and KYC to you as the reseller; you in turn apply your own AUP and KYC to your end customers. The per-modem metadata field gives you a per-customer audit trail to identify and cut off abusers, which is what your AUP enforcement and any provider request will need. You own the brand, billing, support relationship, and markup while Coronium stays your wholesale supplier — not your retail competitor.

RESELLER BUSINESS

Open-source · MIT

2026 · 14 min read

Build a Mobile Proxy Reseller Dashboard in One AI Prompt

You don’t need a backend team to start a 4G/5G mobile-proxy reseller business. Paste one prompt into Claude Code, Cursor or Windsurf and the open-source Coronium Reseller Kit scaffolds a working Next.js dashboard — customer mapping, buy flow, and self-healing auto-swap webhooks — on top of the Coronium API. Here’s exactly how it works, with real code and honest markup math.

TL;DR

Reselling = buy dedicated 4G/5G modems wholesale via API (~$49–$69/mo), mark up 1.3×–2.2×, sell under your own brand.
The open-source MIT kit turns a multi-week build into one AI-agent prompt — no servers, no phone farm, no sidecar database.
Dead modems self-heal: a push webhook delivers fresh credentials and your customer never notices.
Want the strategy-first version? Read the reseller business playbook. This post is the build.

On this page

The reseller model in 60s
API-wholesale vs phone-farm
The one-prompt build
The 5 patterns
The API v3 surface
Economics & markup
7-step checklist
Legality & AUP
FAQ

The mobile proxy reseller business model in 60 seconds

A mobile-proxy reseller buys dedicated 4G/5G mobile proxies at wholesale, adds a markup, and resells them to their own end-customers under their own brand. You set the price, own the billing relationship, and handle first-line support; your supplier (Coronium) runs the physical modems, the carrier SIMs, and the network. The spread between wholesale and retail is your recurring margin.

The catch every generic guide skips: a real reseller needs software — a dashboard to track which customer owns which proxy, a buy flow, a health view, and a way to handle modems that die. That software is the entire reason most people never launch. The Coronium Reseller Kit exists to delete that blocker.

API-wholesale vs phone-farm reselling (and why no hardware wins)

There are two ways to resell mobile proxies. The phone-farm model (iProxy, Proxy-Seller-style) makes you buy Android phones and SIMs and babysit the hardware. The API-wholesale model — what this kit is built for — carries zero hardware or SIM operations: you provision dedicated modems with an API call and mark them up. Here’s the honest comparison.

	API-wholesale (this kit)	Phone-farm	White-label storefront
Own physical hardware?	No — modems are Coronium’s	Yes — you buy Android phones + SIMs	No
Own the code?	Yes — MIT, forkable (~1,400 LOC)	Partial — their farm app	No — rented dashboard
Dead-modem auto-swap?	Yes — push webhook + new creds	No — you babysit devices	Varies / opaque
Customer database needed?	No — metadata field maps it	Usually yes	Hosted for you (locked in)
AI-agent scaffold?	Yes — one prompt	No	No
Markup control	Full	Full	Limited
Time to launch	Hours	Days–weeks	Hours, but locked in

The fast path

Scaffold a working reseller dashboard in one prompt

The kit is built for AI coding agents. Fork the repo, then paste the prompt below into Claude Code, Cursor, Windsurf, or Aider. The agent readsAGENTS.md and llms.txt, uses the included Next.js example as its foundation, and wires up the whole thing against the Coronium API — customer CRUD, proxy inventory, buy flow, and the webhook handler — roughly 1,400 lines of TypeScript, generated for you.

Paste into your AI coding agent

Read the AGENTS.md at https://raw.githubusercontent.com/bolivian-peru/coronium-reseller-kit/main/AGENTS.md
and use https://github.com/bolivian-peru/coronium-reseller-kit/tree/main/examples/nextjs-dashboard
as the foundation. Scaffold me a reseller dashboard for Coronium mobile 4G/5G
proxies with these features (skip any I don't list):

- Customer list (CRUD on end-customers stored locally)
- Buy proxies on a customer's behalf — pick country/carrier, attach customer_id
  via the metadata field, show resulting credentials
- Per-customer detail page with their proxies + health status + credential copy
- Webhook handler at /api/coronium/webhook that processes modem.replaced and
  modem.dead events — update local mapping, log event, ack 200 immediately
- Health overview: poll /account/proxies/health every 60s, highlight dead modems

My CORONIUM_API_KEY is in .env. Deploy target: Vercel. Use Next.js App Router,
TypeScript, Tailwind. Don't invent features I didn't ask for — keep it
minimal and readable. End by running `npm run dev`, opening the browser, and
buying ONE proxy to verify the end-to-end loop works.

Prefer to start by hand? Clone and run the working example directly:

Human path — clone & run

git clone https://github.com/bolivian-peru/coronium-reseller-kit
cd coronium-reseller-kit/examples/nextjs-dashboard
cp .env.example .env          # paste your CORONIUM_API_KEY
npm install && npm run dev
open http://localhost:3000

Why an open-source kit you own beats a rented storefront

Most "reseller programs" hand you a hosted dashboard you can never modify or export — your business lives inside their storefront. The Coronium kit is MIT-licensed: you fork it, change it, ship it, and host it yourself. No lock-in, no per-seat storefront tax, and every line is auditable. The proxies stay in Coronium; the product is yours.

The 5 patterns that make a reseller stack actually work

1. Customer mapping via the metadata field — no database

Don’t build a sidecar table mapping your customer-ids to modem-ids; it drifts the moment a modem gets replaced. Every modem carries a freeform metadata JSON field that is returned in every list and persists across rotations. Write the customer identity there once.

metadata-strategy

// No sidecar DB. The customer mapping lives ON the modem and survives swaps.
// Write it once at buy-time:
{ "metadata": { "customer_id": "acme-007", "plan": "tiktok-5pack" } }

// Every GET /account/proxies returns the same metadata verbatim — filter client-side:
const mine = proxies.filter(p => p.metadata?.customer_id === 'acme-007');

2. Push-based auto-swap — support tickets that answer themselves

When a customer’s modem dies, Coronium auto-provisions a same-country replacement, transfers the remaining paid time, and POSTs your webhook with the full new credentials. Your handler just re-points the customer. The dead-proxy escalation — the #1 reseller support cost — disappears.

modem.replaced event

{
  "event": "modem.replaced",
  "old_modem_id": "69b5926c942c49e02b9f50c7",
  "new_modem_id": "6a1cf4d2942c49e02b1234ab",
  "new_modem": {
    "country_code": "US",
    "host": "172.56.171.4",
    "http_port": "8042",
    "socks_port": "5042",
    "proxy_login": "admin",
    "proxy_password": "kP3aL9zXq7Wm",
    "tariff_expired_at": 1780987974498,
    "isOnline": true
  },
  "ts": 1779192208000
}

minimal handler

// /api/coronium/webhook  — ack first, process async, be idempotent
app.post('/api/coronium/webhook', async (req, res) => {
  res.sendStatus(200);                       // 1. ack within 5s — we don't retry
  const e = req.body;
  if (e.event === 'modem.replaced') {
    // 2. mapping travels in metadata; just point the customer at the new creds
    await customers.updateProxy(e.old_modem_id, e.new_modem);
    await notifyCustomer(e.new_modem);       // email the new host/port/login
  } else if (e.event === 'modem.dead') {
    await flagForManualReplace(e.old_modem_id, e.reason); // no stock right now
  }
});

3. Server-side-only JWT + enforced customer protection

Your CORONIUM_API_KEY (a 365-day Bearer JWT) never touches the browser — every call goes through your own server routes. And customer-protection is enforced server-side: you can’t accidentally overwrite, release, or quarantine a customer’s active modem through the reseller API, so you don’t need extra guards in your UI.

4. Honest IP rotation with ?sync=true

A plain rotate call returns 200 the instant it’s queued — before the IP actually changes. For any rotation your code branches on, append?sync=true and get the truth.

rotate honestly

# Fire-and-forget returns 200 the instant it is queued — the IP may be unchanged.
# Append ?sync=true to block up to 25s and get the HONEST outcome:
curl -X POST "https://api.coronium.io/api/v3/modems/$MODEM_ID/restart?sync=true" \
  -H "Authorization: Bearer $CORONIUM_API_KEY"
# 200 { "new_ip": "..." }   → confirmed rotated
# 502 rotation_failed       → confirmed failure (tell the customer the truth)
# 503 rotation_timeout      → unknown, retry

5. Idempotent buy flow

Pass an Idempotency-Key header on buy requests so a network retry never double-charges your balance — safe to retry within 24h. A stock-out returns409; surface it as "try a different country," don’t retry-loop.

The Coronium API v3 surface a reseller touches

Auth is a single Authorization: Bearer <jwt> header. The full interactive reference is public (no login) at dashboard.coronium.io/api-docs. These are the endpoints the kit uses:

Method · Path	Purpose
GET /account/proxies	List every proxy you own — metadata returned verbatim
GET /account/proxies/health	Per-proxy is_alive + recommendation (cache 30–60s)
GET /tariffs/available	Live in-stock tariffs, filtered by country / carrier
POST /payment/buy-modems-with-crypto-balance	Provision N proxies, attach metadata.customer_id
POST /modems/{id}/restart?sync=true	Rotate IP and return the real new_ip (or honest failure)
POST /modems/{id}/replace	Swap a broken proxy — same country, paid time carried over
GET /modems/rotate-modem-by-token/{token}	Token-auth rotation for end-customer scripts
PUT /account/webhook	Register your HTTPS webhook for auto-swap events

Buy a proxy and attach it to a customer

POST /payment/buy-modems-with-crypto-balance

curl -X POST https://api.coronium.io/api/v3/payment/buy-modems-with-crypto-balance \
  -H "Authorization: Bearer $CORONIUM_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "tariff_id": "61ef075c5a33f238ac15a8e7",
    "modemCount": 1,
    "metadata": { "customer_id": "acme-007", "tag": "tiktok-batch" }
  }'

Register your auto-swap webhook (once)

PUT /account/webhook

curl -X PUT https://api.coronium.io/api/v3/account/webhook \
  -H "Authorization: Bearer $CORONIUM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"webhook_url":"https://your-host/api/coronium/webhook"}'

No ranking competitor shows runnable code like this — most reseller guides are strategy listicles with zero API examples. For the deepest in-editor integration, Coronium also ships an MCP server and machine-readable specs for AI agents.

Reseller economics: real numbers and markup math

Wholesale runs roughly $49–$69 per modem-month depending on country and carrier. Common retail markup is 1.3×–2.2×, with 1.3× as the floor (below that, support, churn and payment fees eat your margin). Each cell below shows retail price · gross profit per modem-month.

Wholesale	1.3×	1.5×	1.8×	2.2×
$49/mo	$64 · +$15	$74 · +$25	$88 · +$39	$108 · +$59
$59/mo	$77 · +$18	$89 · +$30	$106 · +$47	$130 · +$71
$69/mo	$90 · +$21	$104 · +$35	$124 · +$55	$152 · +$83

Paid trials beat free trials — a worked example

Free trials convert at ~5% and attract tire-kickers; a $1–$5 paid trial converts at 25–40% because the buyer self-selects. Model a $3 trial across 100 signups: ~32 convert to a $106/mo plan (a $59 modem at 1.8×). That’s $3,392 MRR against $1,888 wholesale = ~$1,504/mo recurring gross, plus $300 one-time trial revenue. Model your own mix in theproxy farm calculatorand see the volume-tier pricing once you scale.

7-step zero-to-first-revenue checklist

Sign up & top up

Create a Coronium account, verify email, fund your balance (USDC / crypto / Stripe). The balance is what you spend when you buy proxies on a customer’s behalf.

Grab your API key

Dashboard → Settings → API. Copy the Bearer JWT (365-day lifetime). This is your reseller identity for every call — keep it server-side only.

Fork the kit & paste the prompt

Fork coronium-reseller-kit, then paste PROMPT.md into Claude Code / Cursor / Windsurf / Aider. It reads AGENTS.md and scaffolds the dashboard from examples/nextjs-dashboard.

Add the key, run it

Drop CORONIUM_API_KEY into .env, npm run dev, open localhost:3000. The agent finishes by buying one test proxy to prove the loop.

Register your webhook

PUT your deployed /api/coronium/webhook URL into Coronium once. Without it you never hear about dead modems. (HTTPS only; ack 200 within 5s.)

Set your markup

Apply a 1.3×–2.2× retail markup over the wholesale tariff. Surface markup_pct in your dashboard for your own reference; customers see only their retail price.

Run a paid trial, go live

Sell a $1–$5 paid trial to qualify demand, then convert to monthly. Deploy to Vercel/Railway/Docker and you’re a live reseller.

Is reselling mobile proxies legal? AUP, KYC & liability

Reselling mobile proxies is a standard, legitimate B2B model — no special license in most jurisdictions. The chain of responsibility is simple: Coronium applies an Acceptable Use Policy and KYC to you, the reseller; you in turn apply your own AUP and KYC to your end-customers. Make your terms forbid the use cases you don’t want exposure on.

The per-modem metadata field doubles as your per-customer audit trail: when you need to identify and cut off an abuser (or answer a provider request), the mapping is already attached to the device. Once revenue crosses your local VAT/sales-tax threshold, collect and remit; an LLC or sole-proprietorship is fine to start.

Frequently asked questions

Get the kit — fork it and paste the prompt

The Coronium Reseller Kit is open-source and MIT-licensed. Fork it, paste PROMPT.md into your AI coding agent, add your API key, and you have a branded 4G/5G mobile-proxy reseller dashboard with self-healing auto-swap — in an afternoon, not a quarter.