What Is a Domain Reseller API?

You've built a hosting company. Your customers want to buy domains from you.

But becoming an ICANN-accredited registrar means hundreds of thousands of dollars in infrastructure, legal processes, registry agreements, 24/7 abuse management, and years of compliance overhead.

Here's the good news: you don't need any of that.

A Domain Reseller API lets you tap into a fully accredited registrar's technical infrastructure via REST calls — while keeping your pricing, branding, and customer relationships entirely your own. Whether you're running a hosting company, a SaaS platform, a web agency, or a developer team building custom tooling, this guide covers everything you need to get from zero to live domain sales.

What this guide covers:

• ✔ The Registry → Registrar → Reseller hierarchy — who owns what
• ✔ REST API authentication: UUID username, API token, and OT&E access
• ✔ Not just WHMCS: WiseCP, HostBill, Blesta, ClientExec integrations
• ✔ OT&E sandbox to production: real URLs, credentials, and first API calls
• ✔ DNS, DNSSEC, Glue Records, Transfer, Restore, WHOIS — all via API
• ✔ Rate limits, error codes, exponential backoff, and performance patterns

The Domain Ecosystem: Registry, Registrar, Reseller, and ICANN

The domain name industry runs on a three-layer structure tied together by contracts and technical standards. You can use a reseller API without understanding this hierarchy, but you can't understand what the API is actually doing without it.

What Is ICANN?

ICANN (Internet Corporation for Assigned Names and Numbers) is the global coordination body for the domain name system. It defines who can manage TLDs, what technical and policy standards apply, and which organizations get accredited as registrars. ICANN doesn't sell domains itself — it delegates that authority to accredited registrars.

What Is a Registry?

A registry manages the database and infrastructure for a specific TLD. Verisign runs .com and .net; PIR runs .org. Registries only work with registrars — they don't deal with end users directly. The wholesale price of a .com domain is set by the registry (Verisign) through a negotiated agreement with ICANN.

What Is a Registrar?

A registrar is an ICANN-accredited organization with a direct technical integration to registry systems. Registrars can sell domains, process transfers, write to the WHOIS database, and communicate with registries over the EPP protocol. Getting accredited requires significant upfront investment, technical infrastructure, and ongoing compliance work.

What Is a Reseller?

A reseller uses a registrar's infrastructure and ICANN accreditation to sell domains under their own brand, without needing their own accreditation. You set your pricing, your customer experience, and your margins. The registrar handles the technical layer beneath you.

What Is a Domain Reseller API?

Domain Reseller API — Quick Answer

In practice: when a customer searches for a domain on your site, a background API call goes to the registrar's infrastructure and returns availability in milliseconds. When the customer pays, the API registers the domain, sets DNS, and sends a confirmation email — all automatically. You can process hundreds of domains without touching a single one manually.

Registrar vs. Reseller: What's the Real Difference?

What a Domain Reseller API Should Be Able to Do

• ✔ CheckAvailability — query single or bulk domain availability
• ✔ Register — create a new domain registration
• ✔ Transfer — move a domain from another registrar
• ✔ Renew — extend a registration
• ✔ Restore — recover a recently deleted domain
• ✔ Delete — cancel a registration
• ✔ ModifyNameServer — update DNS nameservers
• ✔ GetDetails / GetList — retrieve domain information
• ✔ WHOIS / RDAP query
• ✔ Lock / Unlock — transfer protection
• ✔ GetAuthCode — retrieve the EPP transfer key

Why REST Replaced SOAP

Older domain integrations were largely built on SOAP (Simple Object Access Protocol) — XML envelopes, WSDL files, namespace declarations. Writing even a simple request was a significant effort.

REST (Representational State Transfer) is built on standard HTTP, uses JSON, and requires far less boilerplate. The practical benefits are real:

Criteria

SOAP

REST API documentation and Swagger: domainnameapi.com/api-integration.

Domain Name API: Real Numbers

For context: ResellerClub supports 300+ TLDs, GoDaddy reseller supports 200+, ENOM around 500+. Domain Name API's 800+ TLD range is broader than most competitors. More notably, it's the only platform in its class with official modules for Blesta, WiseCP, and ClientExec — platforms that competitors don't cover.

API Authentication: UUID Username and API Token

The REST API does not use a traditional username/password combination in the way you might expect. Authentication works like this:

UUID-format username: your account identifier in UUID format (e.g., fd2bea54-99ea-16b6-c195-3a1b9079df00)

API token (password): your API token used alongside the UUID username

Both Production and OT&E environments use the same credentials — only the base URL changes. The library detects which mode to use based on your username format: a UUID triggers REST mode; a regular username triggers legacy SOAP mode.

SOAP vs. REST Mode Detection (PHP Library)

// SOAP mode (legacy) — regular username

$dna = new \DomainNameApi\DomainNameAPI_PHPLibrary('myreseller', 'mypassword');

// REST mode (new) — UUID-format username

$dna = new \DomainNameApi\DomainNameAPI_PHPLibrary(

    'fd2bea54-99ea-16b6-c195-3a1b9079df00',

    'your-api-token'

);

// Both modes use identical method calls

$details = $dna->GetResellerDetails();

$domains = $dna->GetList([]);

Never put your API token in client-side code (browser JavaScript, mobile app bundles, etc.). All API calls must happen server-side; the token stays in your backend only.

The OT&E Test Environment

OT&E (Operational Test & Evaluation) is an isolated environment where you can run your full API integration without creating real registrations or incurring any charges. It's a standard part of ICANN registrar accreditation — and it's why Domain Name API makes it available to every reseller.

Why You Shouldn't Skip OT&E

A misconfigured Register call in production creates a real domain registration and a real charge.

A broken transfer flow can leave a customer's domain stuck in a lock state.

Hitting the rate limit in production halts your entire integration instantly.

A DNS record typo in a nameserver update can take a customer's site offline for hours.

OT&E and Production Access

Note the URLs:

Production Swagger: https://api.domainresellerapi.com/swagger/index.html

OT&E Swagger: https://ote.domainresellerapi.com/swagger/index.html

Production and OT&E share the same credentials. Only the base URL is different. The library auto-selects REST mode when it sees a UUID-format username.

What can you do in 10 minutes right now?

Create a free reseller account, open the OT&E Swagger, authenticate with your UUID credentials, and run your first CheckAvailability call — no real registration, no charges, no risk. Once your integration is validated, switching to production is a one-line URL change.

• → Create Your Free Account and Run Your First API Call

Core API Operations: Register, Transfer, Renew, Restore

1. Domain Availability Check

The starting point of every domain sales flow. Domain names and TLDs are passed as separate arrays — the API returns availability, pricing, and premium status for every combination.

// $dna->CheckAvailability(domain_names[], tlds[], period, command)

$result = $dna->CheckAvailability(

    ['hello', 'world123x0', 'myshop'],  // domain names (no extension)

    ['com', 'net', 'org'],              // TLD list

    1,                                  // registration period (years)

    'create'                            // command

);

// Sample response:

// [TLD]        => com

// [DomainName] => hello

// [Status]     => notavailable

// [Price]      => 10.8100

// [Currency]   => USD

//

// [TLD]        => com

// [DomainName] => world123x0

// [Status]     => available

// [Price]      => 10.8100

2. Domain Registration

Registration requires the domain name, period (years), full contact details for all four contact roles, and nameservers. Every contact field matters — missing fields return error code 330.

$contact = [

    "FirstName"        => 'John',

    "LastName"         => 'Doe',

    "Company"          => 'Example Corp',

    "EMail"            => 'john.doe@example.com',

    "AddressLine1"     => '123 Main Street',

    "AddressLine2"     => '',

    "AddressLine3"     => '',

    "City"             => 'Springfield',

    "Country"          => 'US',

    "Fax"              => '5559876543',

    "FaxCountryCode"   => '1',

    "Phone"            => '5551234567',

    "PhoneCountryCode" => 1,

    "Type"             => 'Contact',

    "ZipCode"          => '62701',

    "State"            => 'IL'

];

$dna->RegisterWithContactInfo(

    'example.com',   // domain name

    1,               // period in years

    [

        'Administrative' => $contact,

        'Billing'        => $contact,

        'Technical'      => $contact,

        'Registrant'     => $contact

    ],

    ["ns1.example.com", "ns2.example.com"],

    true,   // WHOIS privacy

    false   // transfer lock

);

// Successful response:

// [result]           => OK

// [data][DomainName] => example.com

// [data][Status]     => clientTransferProhibited

// [data][AuthCode]   => Xy9#mK2$pL5@vN8

// [data][LockStatus] => true

3. Domain Transfer

Transfer requires a valid EPP/auth code from the current registrar. Before initiating: the domain's transfer lock must be removed, the domain must not have been registered or transferred within the last 60 days, and the admin contact email address must be reachable (for generic TLD transfer confirmation emails).

$dna->Transfer('example.com', 'EPP_AUTH_CODE', 1);

// Successful response:

// [result] => OK

4. Domain Renewal

Renewal should happen before the expiration date. Many TLDs provide a short grace period (typically 30 days) after expiry; check GetTldList() for TLD-specific rules.

$dna->Renew('example.com', 1);

// Successful response:

// [result]               => OK

// [data][ExpirationDate] => 2027-03-15T10:00:00

5. Domain Restore

A deleted domain can be recovered during the Redemption Grace Period (typically 30 days post-deletion) for an additional registry fee. Once this window closes, the domain can be registered by anyone. Monitor expiration dates carefully.

WHOIS, RDAP, and DNS Management

WHOIS vs. RDAP — Quick Answer

DNS Record Management via API

Domain Name API lets you manage DNS records for registered domains programmatically. Supported record types:

DNSSEC, Glue Records, and Child Nameservers

DNSSEC — Quick Answer

What Is a Glue Record?

If you're hosting nameservers on your own domain (e.g., ns1.yourdomain.com) and the nameserver's IP lives under the same domain, you have a circular dependency — you can't resolve the nameserver without the nameserver. A glue record solves this by registering the nameserver's IP directly with the registry.

// Add a glue record for ns1.yourdomain.com

$dna->AddChildNameServer('yourdomain.com', 'ns1.yourdomain.com', '192.0.2.10');

// Successful response:

// [data][NameServer]    => ns1.yourdomain.com

// [data][IPAdresses][0] => 192.0.2.10

// [result]              => OK

Child Nameserver (Host Object)

A child nameserver record registers a subdomain of your domain as an independent nameserver object in the registry system. This is commonly required when building custom DNS infrastructure or setting up WHMCS with private nameservers.

Bulk Domain Operations and Rate Limits

Rate Limit — Quick Answer

For resellers managing large volumes, individual API calls per domain become both inefficient and risky. The CheckAvailability method accepts arrays for this reason: you can check dozens of domain/TLD combinations in a single request instead of firing off one call per domain.

When you do hit a rate limit, the correct response is exponential backoff: wait 1 second before the first retry, 2 seconds before the second, 4 seconds before the third. Retrying immediately just keeps you throttled. See the error handling section for the full code pattern.

Full rate limit policy: Domain API Rate Limit, Throttling & Bulk Usage Policy.

Premium Domains and Pricing Tiers

Premium Domain — Quick Answer

Pricing tiers: Domain Name API offers four wholesale pricing tiers — Reseller, Premium, Platinum, and VIP. Higher sales volumes unlock lower per-domain costs. At the VIP/Platinum tier, .com wholesale starts at $10.81/year. Your retail margin is yours to set.

Current wholesale pricing: Domain Prices.

White Label and Sub-Reseller Systems

White Label Domain Reseller — Quick Answer

Sub-Reseller System

The sub-reseller feature lets you build your own reseller network on top of your account. You can create child accounts for other companies or independent agents, set their wholesale pricing independently, and manage their domain portfolios from a central view. This is particularly valuable for IT distributors, hosting aggregators, and large agencies managing partner channels.

What the sub-reseller system gives you:

• • Build your own reseller network — set each reseller's pricing independently
• • Monitor each sub-reseller's portfolio from a central dashboard
• • Enable or disable API access per sub-reseller independently
• • Build a multi-tier revenue model on a single platform

Integration Paths: WHMCS, WiseCP, HostBill, Blesta, ClientExec

Rather than building custom billing infrastructure from scratch, most resellers connect Domain Name API to an existing hosting billing platform. All modules are free and available on GitHub.

WHMCS

Web Host Manager Complete Solution (WHMCS) is the world's most widely used hosting billing and client management platform. Domain Name API's free WHMCS module connects directly: once installed, WHMCS automatically handles domain availability, registration, transfer, renewal, and DNS management through the API — no manual domain processing.

Module installation: github.com/domainreseller

In WHMCS: Setup > Products/Services > Domain Registrars

Check module version compatibility in the Knowledge Base before installing

WHMCS integration details: domainnameapi.com/whmcs.

WiseCP

WiseCP is a modern billing panel with strong multi-language support, popular particularly in Turkey and the surrounding region. Domain Name API's WiseCP module provides full domain lifecycle integration.

WiseCP integration guide: domainnameapi.com/wisecp.

HostBill

HostBill is a feature-rich hosting automation platform with 150+ modules. Domain Name API's HostBill integration covers full domain and SSL management within the HostBill environment.

HostBill integration: domainnameapi.com/hostbill.

Blesta

Blesta's open-source approach and flexible licensing make it a strong choice for teams that want more control over their billing environment. Domain Name API's Blesta module covers the full domain lifecycle.

Blesta integration: domainnameapi.com/blesta.

ClientExec

ClientExec is a billing, client management, and support platform built specifically for web hosting companies. Full domain integration is available.

ClientExec integration: domainnameapi.com/clientexec.

Other Platforms

FOSSBilling, HostFact, and Upmind also work with Domain Name API via the REST API. For fully custom integrations, the REST API can be called directly from any language or framework that can make HTTPS requests.

Language SDKs: PHP, Python, Node.js, .NET

PHP (Official Library)

// Install: composer require domainreseller/php-dna

require_once __DIR__.'/vendor/autoload.php';

use DomainNameApi\DomainNameAPI_PHPLibrary;

// UUID-format username → REST mode is auto-selected

// Same credentials for OT&E and Production

$dna = new DomainNameAPI_PHPLibrary(

    'fd2bea54-99ea-16b6-c195-3a1b9079df00',  // UUID username

    'your-api-token'                          // API token

);

// Domain availability check

// CheckAvailability(domain_names[], tlds[], period, command)

$result = $dna->CheckAvailability(['hello', 'myshop'], ['com', 'net'], 1, 'create');

// Account balance

$reseller = $dna->GetResellerDetails();

echo 'Balance: ' . $reseller['balance'] . ' ' . $reseller['currency'];

Python

import requests

# OT&E: ote.domainresellerapi.com  |  Production: api.domainresellerapi.com

BASE_URL = "https://ote.domainresellerapi.com"

# HTTP Basic Auth — UUID username + API token

UUID_USERNAME = "fd2bea54-99ea-16b6-c195-3a1b9079df00"

API_TOKEN = "your-api-token"

auth = (UUID_USERNAME, API_TOKEN)

# Domain availability check

# Domain names and TLDs are passed as separate comma-separated params

response = requests.get(

    f"{BASE_URL}/api/domain/check",

    params={

        "domainNames": "hello,myshop",

        "tlds": "com,net",

        "period": 1,

        "command": "create"

    },

    auth=auth

)

print(response.json())

Node.js

const fetch = require('node-fetch');

// OT&E: ote.domainresellerapi.com  |  Production: api.domainresellerapi.com

const BASE_URL = 'https://ote.domainresellerapi.com';

const UUID_USERNAME = 'fd2bea54-99ea-16b6-c195-3a1b9079df00';

const API_TOKEN = 'your-api-token';

const basicAuth = 'Basic ' + Buffer.from(UUID_USERNAME + ':' + API_TOKEN).toString('base64');

async function checkAvailability(domains, tlds) {

  const params = new URLSearchParams({

    domainNames: domains.join(','),

    tlds: tlds.join(','),

    period: 1,

    command: 'create'

  });

  const response = await fetch(BASE_URL + '/api/domain/check?' + params, {

    headers: { 'Authorization': basicAuth }

  });

  return response.json();

}

checkAvailability(['hello', 'myshop'], ['com', 'net']).then(console.log);

.NET (C#)

using System.Net.Http;

using System.Net.Http.Headers;

using System.Text;

// OT&E: ote.domainresellerapi.com  |  Production: api.domainresellerapi.com

const string BASE_URL = "https://ote.domainresellerapi.com";

const string UUID_USERNAME = "fd2bea54-99ea-16b6-c195-3a1b9079df00";

const string API_TOKEN = "your-api-token";

var client = new HttpClient();

var credentials = Convert.ToBase64String(

    Encoding.ASCII.GetBytes(UUID_USERNAME + ":" + API_TOKEN));

client.DefaultRequestHeaders.Authorization =

    new AuthenticationHeaderValue("Basic", credentials);

var url = BASE_URL + "/api/domain/check?domainNames=hello,myshop&tlds=com,net&period=1&command=create";

var response = await client.GetAsync(url);

Console.WriteLine(await response.Content.ReadAsStringAsync());

All examples target the OT&E environment. To go live, change the base URL to api.domainresellerapi.com — credentials are identical. For exact endpoint paths, refer to the official Swagger documentation at api.domainresellerapi.com/swagger.

Security: IP Whitelist, API Token Management, HTTPS

Three Non-Negotiable Security Rules

Rule 1: Your API token belongs in your backend only — embedding it in frontend code is a critical vulnerability.

Rule 2: Enable IP whitelisting in your reseller panel — requests from unlisted IPs return error code 301 and are blocked immediately.

Rule 3: HTTPS only — never make API calls over plain HTTP.

IP Whitelisting

Your reseller panel lets you whitelist specific IP addresses (your backend servers) from which API requests are accepted. Even if your API token is somehow exposed, an attacker can't use it without matching your whitelisted IPs.

API Token Rotation

Rotate your API token at regular intervals and immediately after any team departure or suspected breach. Disabling the old token and issuing a new one is the fastest way to close unauthorized access.

Backend-Only API Calls

Every API call must come from your server. Your frontend application should call your own backend, which then calls the Domain Name API. No token should ever appear in browser-executed JavaScript, mobile app source code, or any client-facing bundle.

Migration: Moving an Existing Domain Portfolio

If you're currently using another registrar or reseller platform and want to migrate to Domain Name API, the process is manageable — but it needs coordination to avoid customer downtime.

Migration Flow

• 1.Export your current domain portfolio (CSV or via API list endpoint).
• 2.Request EPP/auth codes for each domain from your current registrar.
• 3.Remove transfer locks on the domains being moved.
• 4.Verify that admin contact email addresses are active and accessible (transfer confirmation emails go here for generic TLDs like .com, .net, .org).
• 5.Initiate bulk transfers in coordination with the Domain Name API support team.
• 6.Monitor transfer status via GetDetails() for each domain.
• 7.Verify DNS records once transfer completes.

Domain Name API offers free migration support.

Share your domain list with the support team and they'll coordinate the transfer process with you. For large portfolios, reaching out before you start the process significantly reduces the chance of issues.

Error Handling: DNA Error Codes and What to Do

Exponential Backoff — Quick Answer

Domain Name API uses its own error code system — not standard HTTP status codes. A complete list is available in the SDK documentation; the most common ones to build handling for:

Real-World Use Cases

Domain Reseller API isn't just for hosting companies and web agencies. Anywhere that customers need a domain — as part of an onboarding flow, a SaaS product, or a managed service — is a potential integration point:

The Full Customer Journey: Zero Manual Touchpoints

Customer searches for example.com

• ↓ CheckAvailability API → Available, $10.81/year
• ↓ Customer completes payment
• ↓ RegisterWithContactInfo API → Domain registered
• ↓ ModifyNameServer API → DNS pointed to hosting server
• ↓ WHMCS automatically opens an SSL activation request
• ↓ Hosting account provisioned automatically
• ↓ Email hosting activated via API
• ↓ Customer is live on example.com in under 10 minutes

Total manual operations: ZERO

Scenario: Hosting Company Automation

When a customer purchases a hosting package, the system simultaneously triggers a domain registration. In a WHMCS integration, this is fully automatic: the customer pays, WHMCS calls Domain Name API, the domain is registered, and nameservers are set to the hosting server — no manual step anywhere in the flow.

Scenario: SaaS Platform with Custom Domain Support

A SaaS platform offers a 'use your own domain' feature. The customer enters their domain name; the platform calls CheckAvailability, the customer confirms, the API registers it, and DNS is pointed to the SaaS infrastructure. The entire flow — from search to live — completes in under a minute without any human intervention.

Scenario: AI Startup — Bulk Domain Reservation

An AI product needs to secure its name across 50 TLDs: example.com, example.ai, example.io, example.co, and so on. A single CheckAvailability call checks all combinations at once. Available domains are registered immediately; unavailable ones trigger an automatic alternative suggestion flow.

Scenario: Web Agency — White Label Reseller

A web agency opens a Domain Name API account to sell domains to their own clients. In the agency's client portal, customers see only the agency's branding — Domain Name API is invisible. The agency sets its own retail margin; Domain Name API bills at wholesale. Every renewal is passive recurring revenue for the agency.

Scenario: MSP — Centralized Portfolio Management

An MSP managing hundreds of client domains replaces manual expiration tracking with an automated system: GetList() pulls all domains, a scheduled job flags anything expiring within 60 days, and those domains are queued for auto-renewal. A balance threshold triggers an automatic alert when the reseller account drops below a defined amount.

Common Mistakes

Skipping OT&E: assuming production will behave the same as local testing — it will, but broken flows create real charges and real domain registrations.

Mixing OT&E and production credentials: a production token pointed at the OT&E URL returns a 300 error; the reverse creates real transactions. Keep a clear .env separation.

Looping individual CheckAvailability calls: sending one request per domain instead of batching into a single array call burns your rate limit allowance quickly.

Putting the API token in frontend code: this is a critical security vulnerability. The token must stay server-side only.

Not checking transfer lock status before initiating a transfer: if the lock is still on, the transfer request fails and the customer experience breaks.

Assuming the admin contact email is reachable: transfer confirmation emails go to the admin contact. If that address is unreachable, the transfer sits pending for 5 business days then auto-cancels.

Missing the Redemption Grace Period: once this window closes after a domain deletion, the domain can be registered by anyone. Track expiration dates proactively.

Testing DNS changes without accounting for TTL: DNS changes are not instant. Depending on TTL settings, propagation takes 24–48 hours. Don't test assuming immediate effect.

Performance Recommendations

Cache availability results: store CheckAvailability responses for 60–120 seconds to avoid redundant queries for the same domain from the same session.

Use bulk CheckAvailability: pass domain names and TLDs as arrays — one request covers all combinations instead of N x M individual calls.

Move heavy operations to async queues: large transfer batches, bulk registrations, and high-volume renewals belong in a background queue. Give the user immediate feedback; process in the background.

Use callbacks rather than polling: where API callbacks are available, use them instead of polling for status updates — less server load, faster responses.

Keep your IP whitelist current: if your server IP changes, update the whitelist immediately — otherwise all API calls start returning 301.

Monitor error logs in real time: alert on spikes in 360/361 errors (rate limiting) and 507/2200 errors (auth issues) — these often indicate problems that will affect multiple customers simultaneously.

Frequently Asked Questions

What is a Domain Reseller API?

A Domain Reseller API is a programmatic interface that lets you register, transfer, renew, and manage domains using code — without needing ICANN accreditation, registry agreements, or your own registrar infrastructure.

Do I need ICANN accreditation to sell domains?

No. As a reseller, you use an ICANN-accredited platform like Domain Name API. You sell domains under your own brand without any accreditation of your own.

What's the difference between a Registry, Registrar, and Reseller?

A Registry manages the TLD database (e.g., Verisign for .com). A Registrar is ICANN-accredited and works directly with registries. A Reseller uses a registrar's infrastructure to sell domains without holding their own accreditation.

Should I use REST or SOAP?

Use REST. SOAP is the legacy protocol — verbose, harder to debug, and declining in ecosystem support. Domain Name API's REST API uses JSON and is available in Swagger for interactive testing.

What is the OT&E environment?

OT&E (Operational Test & Evaluation) is an isolated test environment where you can run your full API integration without creating real registrations or incurring any charges.

Are production and OT&E credentials the same?

Yes. Production and OT&E use the same UUID username and API token. Only the base URL is different.

Is there a fee to sign up?

No. Domain Name API is free to join with no setup fee, no upfront payment, and no minimum balance requirement.

How many TLDs are supported?

800+ as of 2026.

What payment methods are accepted?

Credit card, wire transfer, PayPal, Stripe, and Alipay.

Is the WHMCS module free?

Yes. The WHMCS module is free and available on GitHub at github.com/domainreseller.

Are modules available for WiseCP, HostBill, Blesta, and ClientExec?

Yes — official modules exist for all four. This breadth of platform support is rare among domain reseller APIs.

Where do I find my API credentials?

Log in to your reseller panel at dm.apiname.com, then go to the integration section to find your UUID username and API token.

How does REST API authentication work?

The REST API uses HTTP Basic Auth with a UUID-format username and your API token. The PHP library auto-detects REST mode when it sees a UUID-format username.

What is rate limiting and how do I handle it?

Rate limiting caps how many requests you can make in a given period. When exceeded, error code 360 or 361 is returned. Use bulk CheckAvailability calls and apply exponential backoff when retrying after a rate limit error.

Can I check multiple domains in one call?

Yes. CheckAvailability accepts separate arrays for domain names and TLDs, covering all combinations in a single request.

How are premium domains handled?

The CheckAvailability response includes isPremium and premiumPrice fields. Always surface the premium price to the customer before completing the transaction.

What are the prerequisites for a domain transfer?

The domain's transfer lock must be removed, the domain must not have been registered or transferred in the last 60 days, and a valid EPP auth code must be provided.

What is domain restoration?

Restoration recovers a deleted domain during the Redemption Grace Period (typically 30 days after deletion) for an additional registry fee. Once this window closes, the domain is available for anyone to register.

What's the difference between WHOIS and RDAP?

WHOIS is the legacy protocol for querying domain ownership data (port 43). RDAP is the modern replacement: HTTPS-based, JSON-formatted, and ICANN-backed. Use RDAP for new integrations.

Can I manage DNS records via the API?

Yes. A, AAAA, CNAME, MX, TXT, NS, SRV, and CAA records can all be created and updated via API.

Can I activate DNSSEC through the API?

Yes. DNSSEC activation requires submitting a DS record to the registry via the API.

What is a glue record and when is it needed?

A glue record registers a nameserver's IP address directly with the registry. It's required when you're running nameservers on your own domain (e.g., ns1.yourdomain.com) to break the circular dependency.

What is white label domain reselling?

White label means your customers see only your brand while Domain Name API infrastructure runs underneath. No Domain Name API branding appears in any customer-facing surface.

How does the sub-reseller system work?

You can create child reseller accounts under your main account, set their pricing independently, and manage their portfolios centrally. This is useful for IT distributors, aggregators, and partner channel programs.

How do I integrate with PHP?

Use the official PHP library: composer require domainreseller/php-dna. Initialize with your UUID username and API token; the library auto-selects REST mode.

Can I use Python?

Yes. Use the requests library with HTTP Basic Auth (UUID username + API token) to make GET/POST calls to the REST API.

Can I use Node.js?

Yes. Use fetch or axios with a Base64-encoded Authorization header (Basic Auth with UUID username and API token).

Can I use .NET?

Yes. Use HttpClient with AuthenticationHeaderValue('Basic', Base64-encoded credentials).

How do I keep my API token secure?

Keep it in your backend environment only (e.g., .env file or secrets manager). Never embed it in browser JavaScript, mobile app code, or any client-facing bundle. Enable IP whitelisting for an additional layer of protection.

How do I migrate an existing domain portfolio?

Export your domain list, collect EPP auth codes, remove transfer locks, and initiate bulk transfers in coordination with the Domain Name API support team, who offer free migration assistance.

Is Domain Name API ICANN-accredited?

Yes.

How do pricing tiers work?

Four tiers: Reseller, Premium, Platinum, and VIP. Higher sales volume unlocks lower wholesale pricing. .com at VIP/Platinum starts at $10.81/year.

What error code should I watch for if my IP isn't whitelisted?

Error code 301 (IP not authorized). Add your server's IP to the whitelist in the reseller panel.

What's the DNA error code for an insufficient balance?

Error code 350. Add funds to your reseller account and verify your balance with GetResellerDetails().

Does Domain Name API provide technical support?

Yes — 24/7 via phone (+90 262 325 07 76), live chat, and ticket system. Free migration support is also included.

Can I test the integration for free before going live?

Yes. The OT&E environment is free, requires no real money, and creates no real domain registrations. Everything you need to validate your integration is available there before you spend a cent.

Why a Reseller API — Not a Registrar

Domain sales capability doesn't require a registrar license. It requires the right infrastructure partner.

DV SSL secures the connection; OV/EV SSL verifies your organization's identity — the same logic applies to registrars. Most companies don't need to be one; they need access to what one can do.

40,000+ active resellers in 200+ countries have reached that conclusion. They chose a reseller API, not accreditation.

The technical overhead you avoid — registry integrations, abuse pipelines, ICANN compliance cycles — is real work that doesn't directly serve your customers.