SMM Panel API Documentation: API v1 vs API v2, and Which One to Integrate
Orbismm's SMM panel API documentation covers two APIs: v2, the standard API for panel scripts, and v1, REST with scopes, idempotency, batch orders and webhooks.

Orbismm's SMM panel API documentation covers two APIs. API v2 is the standard SMM panel API: one URL, form fields key and action, and it works with any panel script that supports providers. API v1 is REST and JSON with scoped bearer keys, idempotency keys, batch orders and signed webhooks. Use v2 for scripts, v1 for code you write.
Both APIs run on the same account, the same balance and the same orders, so choosing one doesn't lock you out of the other. This guide compares them point by point, based on how the endpoints actually behave, and explains the three v1 features that matter most in production: idempotency, batch orders and signed webhooks.
What is in the Orbismm API documentation?
| Section | What it covers |
|---|---|
| API overview | Getting a key, choosing an API, live and sandbox keys |
| API v2 reference | The actions services, add, status, refill, refill_status, cancel and balance, with requests, answers and error messages |
| API v1 reference | Authentication, scopes, errors, rate limits, idempotency, pagination and every endpoint |
| Webhooks | Events, payloads, signatures, retries and the endpoint API |
| Sandbox | Test keys, play money, the simulated order lifecycle and going live |
| OpenAPI | A machine-readable description of v1 at /api/v1/openapi.json |
How do API v1 and API v2 compare?
| API v2 | API v1 | |
|---|---|---|
| Style | The standard SMM panel format: one endpoint, form fields | REST, JSON bodies and answers |
| Base URL | https://orbismm.com/api/v2 | https://orbismm.com/api/v1 |
| Authentication | key form field | Authorization: Bearer header |
| Scopes | read for services, status and balance; orders for add, refill and cancel | read, orders and webhooks |
| Errors | {"error": "…"} with HTTP 200, as panel scripts expect | HTTP status plus an error object with a stable code |
| Placing an order | action=add | POST /v1/orders |
| Retry safety | None: the same add sent twice places two orders | Idempotency-Key header returns the original order on retry |
| Many orders at once | Status, refill and cancel accept comma-separated IDs; add is one order per call | POST /v1/orders/batch, each item with its own result |
| Status updates | Polling status | Polling or signed webhooks |
| Listing orders | Not available | Filters and cursor pagination on GET /v1/orders |
| Service details | Rate, min, max and refill, cancel and drip-feed flags | Also the refill window and measured start times |
| Sandbox | Yes, with a test key | Yes, with a test key, plus a sandbox balance reset |
| Rate limit | 60 requests per second per key by default | 60 requests per second per key by default, counted separately from v2 |
When should you use API v2?
- You run a panel script and want to add Orbismm as a provider. v2 is the format those scripts already speak, so setup is a URL and a key.
- You have existing code written for another provider's standard API and want to reuse it unchanged.
- Your needs are simple: list services, place orders, check status, request refills and cancel.
The main thing to watch is retries. Because v2 has no duplicate protection, a script that resends add after a timeout can place two orders. Check your script's retry behaviour before going live.
When should you use API v1?
- You are writing your own integration, such as a storefront, a bot or an internal tool, and want clear HTTP status codes and stable error codes to branch on.
- Orders are created by automated jobs where a network timeout must never produce a duplicate.
- You place many orders at once and want one request instead of many.
- You want order and refill changes pushed to your server instead of polling.
- You want keys limited to what a tool needs, such as a reporting dashboard that can read but never order.
How do scopes and key settings protect you?
Every key carries one or more scopes, and both APIs check them. In v2, services, status, refill_status and balance need read, while add, refill and cancel need orders; a key without it gets This API key is not allowed to do that. In v1, a request outside the key's scopes returns 403 missing_scope, and everything under /v1/webhooks needs the webhooks scope. A key can also be limited to an IP allowlist, so a leaked key is useless from any other server.
How does idempotency work in API v1?
A request can time out after the order was already placed. With an Idempotency-Key header on POST /v1/orders, a retry can't create a second order:
- First request: the order is placed and the answer is
201. - Same key, same request: you get the original order back with
200and the headerIdempotent-Replayed: true. Nothing is charged again. - Same key, different request (another service, link or quantity, for example):
409 idempotency_conflict. - Use a new key, such as a UUID, for every new order. In a batch, each item carries its own
idempotency_key.
How do batch orders and webhooks work?
POST /v1/orders/batch takes a list of orders in one request. Each item succeeds or fails on its own, and the answer lists a result per item with its index, so one bad link doesn't block the rest. Batch size limits are in the reference.
Webhooks push events to an HTTPS endpoint you register: order.status_changed, order.started, order.completed, order.partial, order.canceled, refill.completed, refill.rejected, service.changed and balance.low. Price increases are announced at least 48 hours ahead in the panel and by webhook, so an integration can adjust its own prices in time.
- Each request carries an
Orbismm-Signatureheader in the formt=<unix time>,v1=<signature>, where the signature is a hex HMAC-SHA256 of the timestamp, a dot and the raw body, keyed with your endpoint secret. - Recompute it over the raw body before parsing, compare in constant time, and reject stale timestamps.
- Endpoints can be tested with a test event and their secret can be rotated through the API.
- Sandbox endpoints receive sandbox events, signed the same way and marked
livemode: false.
Answer a webhook with a 2xx quickly and do the work afterwards. A slow handler looks like a failed delivery.
Can you use both APIs at once?
Yes. They share the account, balance and orders, so a common setup is a panel script placing orders through v2 while a small service subscribes to v1 webhooks for alerts on partial orders, rejected refills and low balance. Give each part its own key with only the scopes it needs, and test both with sandbox keys first. SMM panel API testing with a sandbox has a full test plan.
From Orbismm order data
From Orbismm order data: both APIs serve the same 0 services, and across still being measured orders in the last 30 days the median start time was still being measured.
Start with the [API docs](/docs) and pick the API that fits your integration.
Frequently asked questions
- What's the difference between the REST API and the classic key and action API?
- The classic API, v2, is the standard SMM panel format that panel scripts use: one URL, a key and an action. The REST API, v1, uses JSON, bearer keys with scopes, idempotency keys, batch orders and signed webhooks.
- How do I authenticate API requests?
- In API v2, send your key as the key form field. In API v1, send it as a bearer token in the Authorization header.
- Which API should my panel script use?
- API v2. It works with any panel script that supports providers, so you only need the URL and your key.
- Does API v2 protect against duplicate orders?
- No. Sending the same add twice places two orders. If retries are a risk, use API v1 with an Idempotency-Key.
- Is there an OpenAPI file?
- Yes, for API v1, at https://orbismm.com/api/v1/openapi.json.