ResellerStack Developer API
    • Introduction
    • Quick start
    • API Reference
      • Customers
        • List customers
        • Create customer
        • Get customer
        • Update customer notes
        • Update customer status
        • Update billing details
      • Geo
        • List countries
        • List states
      • Pricing
        • List TLD pricing
        • Update TLD pricing
        • Set TLD featured
        • Apply bulk margin
        • Reorder TLD pricing
      • Domains
        • List domains
        • Check domain availability
        • Register a domain
        • Checkout domain cart (bulk)
        • Toggle WHOIS privacy
        • Update domain contacts
        • Get domain
        • Toggle transfer lock
        • Toggle auto-renew
        • Preview renewal price
        • Renew domain now
        • Register a domain with Google Workspace
        • List bundle offers for a name
        • Register a bundle
      • Contacts
        • List contacts
        • Create contact
        • Get contact
      • Orders
        • List orders
        • Get order
      • DNS
        • List DNS records
        • Add DNS records
        • Update DNS record
        • Delete DNS record
        • Update nameservers
        • Reset nameservers
        • List DNSSEC records
        • Add DNSSEC record
        • Delete DNSSEC record
      • Wallet
        • Get wallet balance
      • Webhooks
        • workspace.pastdue
        • workspace.expired
        • workspace.txt.failed
        • workspace.renewed
        • workspace.provisioned
        • workspace.txt.ready
        • workspace.txt.propagated
        • workspace.licenses.increased
        • workspace.deleted
        • workspace.failed
        • mailbox.ready
        • mailbox.deleted
        • workspace.dkim.ready
        • workspace.dkim.propagated
        • workspace.domain.swapped
        • Delivered when domain.order.success fires
        • Delivered when domain.order.failed fires
        • Delivered when domain.renewal.success fires
        • Delivered when domain.renewal.failed fires
      • GWS
        • Google Workspace ~ Creation Flow
        • Google Workspace ~ Sandbox Environment
        • Check Workspace Exists
        • Create Workspace
        • List Workspaces
        • Delete Workspace
        • Check DNS Propagation
        • Renew Workspace
        • Change Primary Domain (Beta)
      • Licenses & Mailboxes
        • Create Mailbox
        • List Mailboxes
        • Delete Mailboxes
        • Decrease Seats
    • Health check
      GET
    • Get current partner
      GET

    Introduction

    Welcome to ResellerStack#

    ResellerStack is a domain wholesale platform built for registrars, hosting providers, agencies, and anyone who manages domains at scale. This API gives you programmatic control over the same account you manage in the partner dashboard - pricing, customers, domains, orders and wallet - so you can build your own dashboard or storefront on top of it instead of using ours.
    Every endpoint below is relative to a base URL and authenticated with a partner API key. To start with a live request, jump to Your first request.

    What you can do with the API#

    CapabilityEndpoints
    Domain availability & pricingCheck a name across TLDs and get back your own retail and renewal price in one call - POST /domains/available.
    Domain registrationRegister one domain (POST /domain/register) or a bulk batch (POST /domain/register/bulk), for an existing customer or one you create inline, with four payment collection methods.
    Domain managementNameservers, transfer lock, auto-renew, renewal preview and renew-now, and per-domain history - /domains/{id}/*.
    DNSRecords on a domain's managed zone, and DNSSEC - /domains/{id}/dns-records, /domains/{id}/dnssec.
    CustomersYour end customers: create, list, billing details, notes and tags, suspend and reactivate - /customers.
    Pricing bookPer-TLD margins and overrides, promo pricing, display order, storefront-featured flag - /tld-pricing.
    OrdersList order batches and poll one batch's status while a registration settles - /orders.
    WalletRead your current wallet balance - GET /wallet.
    WebhooksGet pushed domain.order.* and domain.renewal.* events the moment a registrar call resolves, instead of polling.
    Reference dataCountries and states for filling in registrant contact fields - /geo/countries, /geo/states (no API key required).
    Deliberately not exposed here, and dashboard-only: team member management, API key management, webhook destination configuration, and anything that moves real money (wallet recharge, payment methods, payment gateway connections). Webhook delivery is unaffected - configure a destination once in the dashboard and you receive events normally.

    Base URLs#

    Every endpoint in this reference is relative to one of two base URLs, selected via the server dropdown on each request:
    ServerBase URLKey prefix
    Productionhttps://api.resellerstack.ai/api/v1rs_live_...
    Sandboxhttps://sandbox-api.resellerstack.ai/api/v1rs_test_...
    Both accept the same request/response shapes, but NOT the same API key - see Authentication and Sandbox below.

    Authentication#

    Every endpoint except GET /geo/countries and GET /geo/states (public reference data) requires a partner API key, sent as a header on every request:
    rs-x-api-key: rs_live_...
    Generate a key from the partner dashboard, under API Keys, and treat it like a password. A key is environment-scoped at creation - rs_live_... keys authenticate only against the Production base URL, rs_test_... keys only against Sandbox. Using either against the wrong base URL fails with 401 Unauthorized, the same as an unknown key - generate a separate key for Sandbox rather than reusing a live one.
    A key can be scoped to specific resources (e.g. domains:read, domains:write, pricing:read, pricing:write, customers:read, customers:write, orders:read, wallet:read, and for Google Workspace gws:read, gws:write, mailboxes:read, mailboxes:write) instead of carrying full access, so a partner can hand out narrower keys to internal tools or vendors. Write access to a resource always implies read access to it. A key with the full_access scope bypasses all per-resource checks, and so does a key generated before scopes existed (no scopes recorded at all) - every endpoint stays reachable for keys created before this system shipped.
    401 Unauthorized means the key is missing, invalid, or was issued for the other environment. 403 Forbidden means the key is valid but lacks the scope a given endpoint requires - the response message names the missing scope.

    Resource IDs#

    Every resource is identified by a plain UUID - customers, domains, orders. There is no prefixed identifier scheme, and IDs are neither sequential nor guessable, so store them as opaque strings. The userId, domainId and cartOrderId fields in webhook payloads are the same IDs that GET /customers/{id}, GET /domains/{id} and GET /orders/{cartOrderId} accept.

    Errors#

    Every error response, on every endpoint, is a JSON body shaped { status, message }, where status repeats the HTTP status code. The per-endpoint response tables below name the specific conditions that map to each status code.

    Rate limits#

    Every endpoint shares one quota per API key (or per IP for requests with no key at all, e.g. an invalid-key 401) - the limit is not per-endpoint, and it is not shared across partners. The current default is 300 requests per 60-second window. The window is fixed, not sliding: it opens on your first request after the previous one expired and resets fully - to 0 - 60 seconds later, regardless of how those requests were spaced within it.
    Every response carries two headers describing the policy and your current standing: RateLimit-Policy (e.g. 300;w=60) and RateLimit (e.g. limit=300, remaining=299, reset=42, where reset is seconds until the window clears). Exceeding the limit returns 429 with the same { status, message } shape as any other error, plus a Retry-After header giving the number of seconds to wait before your quota resets.

    Pagination#

    Every endpoint documented with page/limit query parameters (GET /domains, GET /orders, GET /customers) returns a data object shaped { data: [...], totalSearchedCount, currentPage, totalPages } - the paginated items are nested one level under data.data. totalSearchedCount is the full match count across all pages, and there are more pages to fetch while currentPage < totalPages. Omitting page/limit returns page 1 at the default limit shown on each endpoint. limit is fixed to the range 0-500 on every list endpoint - a value outside that range fails with 400, not a silent clamp.

    Idempotency#

    POST /domain/register and POST /domain/register/bulk accept an Idempotency-Key header - any unique string you generate per logical request, such as a UUID. It is strongly recommended on both: they mutate wallet and registrar state, and a network timeout without a key leaves you no safe way to retry without risking a duplicate registration or charge. Reusing the same key replays the original response instead of reprocessing; a concurrent request still in flight under the same key gets a 409.

    Webhooks#

    Domain registration and renewal involve a call to the registrar that can take anywhere from seconds to hours to settle. Rather than have a partner poll GET /orders/:id until something changes, ResellerStack pushes a webhook to the partner's own endpoint the moment a domain order or renewal resolves.

    Configuring destinations#

    Webhook destinations (the URL(s) that receive deliveries) and event subscriptions are managed from the partner dashboard, not through this API - create a destination there, subscribe it to the event types below, and copy the signing secret shown once at creation time. This section documents the deliveries themselves, since building a receiver for them is the partner-facing half of the integration regardless of where the destination was configured.

    Delivery format#

    Every delivery is an HTTP POST to the destination URL with this envelope:
    {
      "event": "domain.order.success",
      "eventId": "evt_9f8e7d6c5b4a",
      "data": { "...": "event-specific fields, see Event reference below" }
    }
    eventId is unique per delivery and safe to use for deduplication - retries of the same underlying event reuse it. Two headers accompany the request:
    HeaderDescription
    rs-x-signaturehex(HMAC-SHA256(signingSecret, rawRequestBody)) - recompute this over the exact raw bytes received (not a re-serialized copy) and compare to verify the request came from ResellerStack.
    rs-x-timestampUnix timestamp (seconds) the delivery attempt was made.

    Retries and sandbox isolation#

    A delivery that times out (10s) or doesn't return 200 is retried up to 3 times with backoff; every attempt - success or failure - is logged and visible (with a manual resend option) from the partner dashboard.
    Destinations and events are both flagged sandbox or live, and a delivery only ever matches a destination in the same environment - a sandbox test order never reaches a live webhook URL, and vice versa.

    Correlating deliveries with orders#

    Two things to know when building a receiver:
    A bulk checkout fires one event per domain, not one per batch. To know a batch is complete, count incoming events against the domain count from the checkout response, or from GET /orders/{cartOrderId} - there is no single "batch done" event.
    domain.order.success and domain.order.failed carry both orderId and cartOrderId. cartOrderId is the id GET /orders/{cartOrderId} accepts, so you can join a delivery to its order directly. orderId is currently the same value as cartOrderId on every domain.order.* webhook - it does not yet distinguish one domain's order from another inside a multi-domain batch.

    Event reference#

    Each event's data field has the shape shown below.
    domain.order.success - a domain registration completes.
    {
      "userId": "b2a1c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d",
      "userEmail": "customer@example.com",
      "orderId": "9c8b7a6d-5e4f-4a3b-9c8d-1e2f3a4b5c6d",
      "cartOrderId": "a4e2f6c8-3b1d-4f9a-8e7c-6d5a4b3c2f1e",
      "domainId": "7b1d4e6f-2a3b-4c5d-8e9f-1a2b3c4d5e6f",
      "domainName": "example-order.com",
      "expiryDate": "2027-08-27T00:00:00.000Z",
      "creationTime": "2026-08-27T09:00:00.000Z",
      "price": 12.99
    }
    domain.order.failed - a domain registration fails (registrar error, domain already taken, etc).
    {
      "userId": "b2a1c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d",
      "message": "Domain name not available - already registered",
      "userEmail": "customer@example.com",
      "domainName": "example-order.com",
      "orderId": "9c8b7a6d-5e4f-4a3b-9c8d-1e2f3a4b5c6d",
      "cartOrderId": "a4e2f6c8-3b1d-4f9a-8e7c-6d5a4b3c2f1e",
      "price": 12.99
    }
    domain.renewal.success - a domain renewal completes.
    {
      "userId": "b2a1c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d",
      "userEmail": "customer@example.com",
      "domainName": "example-order.com",
      "domainId": "7b1d4e6f-2a3b-4c5d-8e9f-1a2b3c4d5e6f",
      "years": 1,
      "expireOn": "2028-08-27T00:00:00.000Z",
      "price": 12.99
    }
    domain.renewal.failed - a domain renewal fails at the registrar.
    {
      "userId": "b2a1c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d",
      "userEmail": "customer@example.com",
      "domainName": "example-order.com",
      "domainId": "7b1d4e6f-2a3b-4c5d-8e9f-1a2b3c4d5e6f",
      "years": 1,
      "error": "Registrar renewal failed with an unknown error."
    }

    Sandbox#

    A sandbox environment of this same API is available for integration testing, using a separate rs_test_... API key generated the same way as a production key. Select the "Sandbox" server below instead of "Production" - everything else about a request is identical, and there is no separate sandbox account. Sandbox activity never appears in a live view, or vice versa.
    The sandbox is completely free. Wallet balance is never checked and no debit occurs, so no operation costs anything - including registrations and renewals - and checkout never fails for balance reasons. Domain registration/renewal is fully mocked in-process: no registrar is ever called and no real DNS zone is provisioned. Prices are still resolved through the real pricing logic, so the amounts you see are realistic.
    To deliberately exercise a failure path, register a domain whose name starts with one of these magic prefixes (matched against the label before the first dot, case-insensitive) - for POST /domain/register/bulk this does NOT change the checkout response's HTTP status, which stays 201; that domain's entry comes back with status: "FAILED" and error set to the message shown below, and a domain.order.failed webhook fires with the same message. For POST /domain/register the response itself is 200 with orderStatus: "FAILED" and the same error:
    PrefixSimulated error message
    already-registered-Domain name not available - already registered
    registrar-timeout-Registrar request timed out
    invalid-tld-Invalid or unsupported TLD
    rate-limited-Registrar rate limit exceeded
    Any other domain name succeeds.

    SDKs and tools#

    There are no language SDKs yet. The full OpenAPI 3.1 spec is served live at GET /openapi.json on either base URL, so you can generate a typed client for your language with the generator of your choice, or import the URL directly into Apidog, Postman or Insomnia. An MCP server wrapping a subset of this API is also available, for driving your account from an AI agent.
    Modified at 2026-10-22 09:07:31
    Next
    Quick start
    Built with