What API integration solves
The residential proxy API answers: how programs complete auth, balance and product reads, creating rotating or static orders, status queries, and extracting or reading instance credentials. It fits scripts, backend services, and automation pipelines—not only clicking through a GUI.
If you only need to plug an existing proxy into curl, a crawler library, or a browser—that is how the client connects. Read HTTP / SOCKS5 setup first. If you have not chosen rotating vs static yet, read Rotating vs static residential first.
Below: a “when to use API / console / client” table, a checkable first-steps list, and auth safety boundaries. Step commands, request bodies, and field dictionaries live in Docs—open Docs EN quickstart, Authentication, and OpenAPI. Lawful, authorized commercial and technical use only.
When to use API vs console / client
| What you need to do | Prefer | Notes |
|---|---|---|
| Small opens, check balance, edit notes | Console | Fastest onboarding; good for smoke checks |
| Put a proxy into a script / browser / tool | Client config (HTTP / SOCKS5) | Fill protocol / host / port / auth; values from console |
| Batch orders, auto renew/release, reconciliation, embed in your backend | API | Authenticate, then call order / query / extract per Docs |
| Auto-provision and send business traffic through the proxy | API + client | API owns resource lifecycle; client uses returned credentials for business traffic |
| Still undecided rotating vs static | Selection guide first (zt-01) | API does not replace product selection |
The three often work together: open resources via API (or console), then send business requests with console-returned protocol and credentials in the client. Product entries: Rotating, Static, Pricing.
First-steps checklist: account → auth → read-only → then write
Advance in order (everything console- and Docs-sourced; this page provides no abuse-ready sample tokens and does not paste a curl family):
- Account ready: register and activate email; confirm console login works.
- Understand auth: open Authentication—login gets a token → later requests carry Bearer.
- Read-only smoke: follow Docs EN quickstart—check balance, products / region codes; confirm environment, permissions, and pricing readout.
- Then write orders: rotating by traffic (GB), static by IP × term—fields in Docs; static standard create may be async—confirm final status and instance info via order list.
- Extract or connect: rotating extract notes in Docs; after host / port / auth appear, fill the client per HTTP / SOCKS5 setup.
- Errors and nesting: business errors and HTTP semantics → Errors; habits and rate-limit awareness → Best practices; keep credentials server-side → Backend integration.
- Price and tiers: published list (e.g. rotating about $0.40/GB) is console source of truth; static per IP/month. Bill units: Billing GB vs IP. Payment context: USDT/USDC available; Visa/Mastercard applying / pending (not live).
Step map
| Step | What you are confirming | Read deeper |
|---|---|---|
| Account ready | Activated; can open console | Console; auth-page common errors |
| Auth | Login → token; requests carry Bearer | /docs/en/authentication |
| Read-only smoke | Balance, products, region codes | /docs/en/quickstart, OpenAPI |
| Order | Rotating traffic or static IP order | quickstart, openapi; prices from console |
| Status / instance | Async accept, list and search | quickstart, openapi |
| Extract / connect | Rotating extract or static instance credentials → client | Docs extract notes + HTTP / SOCKS5 |
| Troubleshoot | 401 / business errors, retry awareness | /docs/en/errors, Best practices |
| Backend nesting | Credentials stay server-side, not in the frontend | /docs/en/backend-integration |
No long path dumps or sample secrets in this table; for field dictionaries open OpenAPI.
Auth and safety boundaries
ZTProxy public API uses JWT Bearer Token: call the login endpoint with account credentials to obtain a token, then carry it on authenticated request headers. Full examples, response fields, and 401 / 403 notes live in Authentication.
Safety boundaries (marketing pages must follow them too):
- Do not put tokens or passwords in frontend code, public repos, screenshot tutorials, or chat groups.
- Do not log full Authorization headers.
- When a token expires or is invalid, re-login (or refresh per Docs)—do not hammer failed requests.
- If the account is not activated, finish email activation before calling the API.
This page will not provide copy-paste fake tokens and will not move the OpenAPI path table into marketing body copy. It also invents no example hostname, port, or token strings.
Boundaries vs HTTP/SOCKS5 setup and Docs
| Doc | Answers | Does not answer |
|---|---|---|
| This page (API integration) | When to use API, first-step order, auth safety principles, which Docs to open | Full request bodies, path dictionary, copy-paste secrets |
| HTTP / SOCKS5 setup | How to choose HTTP / SOCKS5; how to fill client fields | Order / extract API |
| Docs EN quickstart | Typical call flow and command-level examples | Product-selection marketing |
| Authentication | Login, Bearer, common auth errors | Scene marketing |
| OpenAPI | Fields and endpoint notes | “Should I use API the first time?” decision table |
Keep full request samples in Docs; treat this page as a map and Docs as the manual.
Common pitfalls and next steps
Common misses (qualitative; no invented error-code encyclopedia):
- Calling the API before email activation → read auth-page 403 notes first.
- Batch-ordering before read-only (balance / products) works → finish the first half of quickstart.
- Treating this page or the FAQ as OpenAPI → fields come from the OpenAPI reference.
- Merging “API order” and “client protocol config” into one step → resources via API / console; connect via HTTP/SOCKS5 setup.
- Credentials in the frontend or logs → keep them server-side; see backend integration and best practices.
Next steps
- Use the two tables: decide API, console, or client for your task.
- Open Authentication and Docs EN quickstart—read-only before write.
- Fields and errors → OpenAPI, Errors.
- Not selected yet → Rotating vs static; estimate bills → Billing GB vs IP + Pricing; products → Rotating / Static.
- More guides: Guides. Scene pages that often follow connect: SEO monitoring, Price monitoring.
Unsure? On-site support or [email protected] (no fixed SLA promised here). Remember: API owns resource lifecycle; client owns how you connect; deep steps live in Docs.
FAQ
How does the API differ from the console?
Console fits small manual opens and checks; API fits programmatic order, query, extract, and reconciliation, and can embed in your backend. They often combine: after API or console opens a resource, still send business traffic with console-returned credentials in the client.
When should I use the API instead of only configuring a client?
When you need batch, scheduled, auto renew/release, or to write provisioning into your own system—prefer API. If the goal is only “make a script or browser use a proxy,” fill the client per HTTP / SOCKS5 setup first.
What is the first integration step?
Account activation → read Authentication → read-only via Docs EN quickstart (balance, products) → then create orders or extract. Full checklist above under “First-steps checklist.”
How does auth work? Can tokens go in the frontend?
JWT Bearer: obtain a token via login, then carry it on request headers. Do not put tokens or passwords in the frontend, public repos, or logs; keep them server-side or in a secrets manager. Detail and common 401 / 403: Authentication.
How does this page differ from OpenAPI / quickstart?
This page is the marketing-site indexable integration map (when to use, first steps, safety). Step commands, paths, and fields live in Docs EN quickstart and OpenAPI. Do not look for a full endpoint table here.
How does this relate to the HTTP / SOCKS5 setup guide?
HTTP / SOCKS5 setup covers client protocol and fields; this page covers API-side resources and auth. After API order returns an instance or extract result, connect the proxy with that guide and console-returned values.
Can both rotating and static be ordered via API?
Yes. Fields, pricing, and (for static) async accept details are Docs- and console-sourced. If not selected yet, read Rotating vs static; bill units: Billing GB vs IP. Product entries: Rotating, Static.
Where do prices come from? Can I use this in mainland China?
Plans and list prices: Pricing; console is source of truth (rotating about $0.40/GB is published list and may change; static per IP/month). All proxy services on this site are not supported for use in mainland China.