Whois API Documentation

Our Hosted Whois API Web Service provides registration details, also known as WHOIS Records, of a domain names.

Whoisjsonapi.com provides a RESTful API to get access to the whois data. It is designed for server-to-server communication between your system and the whoisjsonapi.com network using HTTPs protocol. Query responses are delivered in JSON format based on your requests which are made via GET method.

The following data is included:

• Important Dates (i.e. Expiration, Creation)
• Owner and contact information if available
• Nameservers
• Registrar information

Single domain request

By making a single domain request, you can obtain only the whois information for the specific domain you are querying. This request operates swiftly as it doesn't necessitate additional resources.

API endpoint

Input parameters: required

Example

curl --location 'https://whoisjsonapi.com/v1/twitter.com' \
--header 'Authorization: Bearer {your-api-token}'

Bulk request

Bulk WHOIS API gives you parsed domain WHOIS ownership information for a list of domains

API endpoint

Input parameters: required

Example

curl --location 'https://whoisjsonapi.com/v1/domains?d=facebook.com,twitter.com,bbc.com' \
--header 'Authorization: Bearer {your-api-token}'

Domain availability

The domain availability method checks the availability status of a single domain name. It accepts one argument: domain

The response will contain a JSON array of status objects with keys: domain and status*. The status key contains the status for the given domain.

There are two statuses provided by the API: active and inactive. INACTIVE domains indicate that they are available for purchase.

API endpoint

Input parameters: required

Example

curl --location 'https://whoisjsonapi.com/v1/status/whois.com' \
--header 'Authorization: Bearer {your-api-token}'

Response

{
    "domain": "whois.com",
    "status": "active"
}

DNS records

The DNS records endpoint returns grouped DNS records for a hostname. It is available to Premium and Enterprise plans and uses the same shared request allowance as WHOIS: each accepted DNS lookup consumes one request, regardless of the number of requested record types.

Send your API token in the Authorization header using the bearer token scheme. Successful responses include X-Requests-Remaining when the shared allowance value is available.

API endpoint

Input parameters

Default lookup example

curl --location 'https://whoisjsonapi.com/v1/dns/example.com' \
--header 'Authorization: Bearer {your-api-token}'

Type-filtered lookup example

curl --location 'https://whoisjsonapi.com/v1/dns/example.com?types=A,MX,TXT' \
--header 'Authorization: Bearer {your-api-token}'

Response fields

Success response example

{
    "domain": "example.com",
    "domain_ascii": "example.com",
    "status": "success",
    "resolver_policy": "default",
    "requested_types": [
        "A",
        "AAAA",
        "MX",
        "NS",
        "TXT",
        "CNAME",
        "SOA",
        "CAA"
    ],
    "fetched_at": "2026-07-01T12:00:00+00:00",
    "expires_at": "2026-07-01T12:05:00+00:00",
    "records": {
        "A": [
            {
                "name": "example.com.",
                "type": "A",
                "ttl": 120,
                "value": "93.184.216.34"
            }
        ],
        "AAAA": [
            {
                "name": "example.com.",
                "type": "AAAA",
                "ttl": 120,
                "value": "2606:2800:220:1:248:1893:25c8:1946"
            }
        ],
        "MX": [
            {
                "name": "example.com.",
                "type": "MX",
                "ttl": 300,
                "priority": 10,
                "exchange": "mail.example.com."
            }
        ],
        "NS": [
            {
                "name": "example.com.",
                "type": "NS",
                "ttl": 86400,
                "target": "a.iana-servers.net."
            }
        ],
        "TXT": [],
        "CNAME": [],
        "SOA": [
            {
                "name": "example.com.",
                "type": "SOA",
                "ttl": 3600,
                "mname": "ns.icann.org.",
                "rname": "noc.dns.icann.org.",
                "serial": 2026070101,
                "refresh": 7200,
                "retry": 3600,
                "expire": 1209600,
                "minimum": 3600
            }
        ],
        "CAA": []
    },
    "warnings": []
}

Status and error behavior

Authentication, subscription access, feature access, and quota failures use the standard API error behavior for authenticated endpoints.

Authorization

When making a request to our REST API, send your API token in the Authorization header using the bearer token scheme. Keep API tokens out of URLs, browser code, public repositories, and logs.

Example: API key in headers

curl --location 'https://whoisjsonapi.com/v1/whois.com' \
--header 'Authorization: Bearer {your-api-token}'

Response

Query responses are delivered in JSON format.

Domain

Registrar

Registrant

Administrative

Technical

Response example

{
    "domain": {
        "id": "2320948_DOMAIN_COM-VRSN",
        "domain": "facebook.com",
        "punycode": "facebook.com",
        "name": "facebook.com",
        "extension": "com",
        "whois_server": "whois.registrarsafe.com",
        "status": [
            "clientdeleteprohibited",
            "clienttransferprohibited",
            "clientupdateprohibited",
            "serverdeleteprohibited",
            "servertransferprohibited",
            "serverupdateprohibited"
        ],
        "name_servers": [
            "d.ns.facebook.com",
            "a.ns.facebook.com",
            "b.ns.facebook.com",
            "c.ns.facebook.com"
        ],
        "created_date": "1997-03-29T05:00:00Z",
        "created_date_in_time": "1997-03-29T05:00:00Z",
        "updated_date": "2023-04-26T19:04:19Z",
        "updated_date_in_time": "2023-04-26T19:04:19Z",
        "expiration_date": "2032-03-30T04:00:00Z",
        "expiration_date_in_time": "2032-03-30T04:00:00Z"
    },
    "registrar": {
        "name": "RegistrarSafe, LLC",
        "phone": "+1.6503087004",
        "email": "[email protected]",
        "referral_url": "https://www.registrarsafe.com"
    },
    "registrant": {
        "name": "Domain Admin",
        "organization": "Meta Platforms, Inc.",
        "street": "1601 Willow Rd",
        "city": "Menlo Park",
        "province": "CA",
        "postal_code": "94025",
        "country": "US",
        "phone": "+1.6505434800",
        "email": "[email protected]"
    }
}

Domain monitoring

Domain Monitoring watches configured domains for WHOIS/RDAP and/or DNS changes over time. It is a signed-in, owner-scoped Dashboard feature, not a bearer-token REST API endpoint or a whoisphp feature. Available monitoring capacity, imports, and webhooks depend on your plan and permissions.

Quick start

1. Open Dashboard → Monitoring and select Add monitor.
2. Enter a valid domain and, if useful, an optional recognizable monitor name.
3. Choose WHOIS/RDAP, DNS, or both, then configure whether email alerts are enabled.
4. Save the monitor. Its first check establishes or loads a baseline asynchronously, so current data and change history may not be available immediately.
5. Open the monitor detail page to review its health, current data, and detected changes.

Manage monitors

Use the monitor list to search by domain or name and filter by status, source, change state, tag, or severity. Each monitor has Overview, Changes, Current data, and Settings tabs.

A monitor can be active, initializing, paused, have a problem, or be removed. Run now requests a refresh for the enabled sources; it does not promise an immediately completed result. You can pause, resume, or remove a monitor. Removed monitors leave the normal list and stop normal monitoring, while their history remains available to the owner. We do not make a retention-duration promise.

One account can have one monitor for each normalized domain. Duplicate active monitors for the same normalized domain are not created; a monitor that was previously removed can be reactivated.

Alerts and change history

The change timeline records customer-facing events for enabled sources. Events show the source, severity, summary, detected time, and, when available, a previous/current delta. Disabling email alerts does not disable detection or timeline entries.

Your account email is the default alert recipient. A custom recipient must be verified before it can receive alerts; an unverified address receives no alert. Eligible alerts are sent immediately—there is no daily or weekly digest setting. Choose Critical and important changes to limit notifications or All changes to receive every eligible alert. Notifications contain a concise summary and Dashboard link, not raw WHOIS/RDAP or DNS source data.

Bulk import

Bulk import is available only when your plan enables it. On the Import page, paste comma-separated rows or upload a .csv file. CSV-file uploads may include the optional header below; pasted rows must omit the header and use the five columns in this order:

domain,monitor_name,tags,alert_level,email_mode
example.com,Primary domain,"production, customer",important_only,immediate
example.net,,security,all,immediate

Omitted optional values use the Dashboard defaults. Notification recipients follow the account or monitor email settings; there is no per-row recipient field. Rows are processed independently, so review the results for created, reactivated, duplicate, invalid, over-limit, or other error rows.

Webhooks

An entitled account can configure one account-level endpoint for events from its monitored domains in Dashboard → Monitoring → Webhook. Webhooks are outbound-only and are not a public configuration API. Use an HTTPS endpoint, save and enable it, store its generated signing secret securely, send a test delivery, and review delivery history from the Dashboard.

The Dashboard normally masks the signing secret. Explicitly reveal or copy it only when needed, never put it in a URL or logs, and rotate the secret in your receiver at the same time as you rotate it in the Dashboard. You can enable or disable the endpoint and use test delivery without creating a real monitoring event.

Outbound request

POST https://customer.example/monitoring-webhook
Content-Type: application/json
User-Agent: WhoisJsonAPI/Monitoring-Webhooks/1.0
X-WhoisJsonAPI-Event-Id: <event UUID or test>
X-WhoisJsonAPI-Delivery-Id: <delivery ID>
X-WhoisJsonAPI-Signature-SHA256: <base64 HMAC-SHA256>

Values in this example are placeholders. A representative payload contains only customer-safe event details; test distinguishes a test delivery from a monitoring event.

{
  "event_id": "<event UUID>",
  "event_type": "record_changed",
  "source": "dns",
  "severity": "important",
  "domain": "example.com",
  "detected_at": "<ISO 8601 timestamp>",
  "monitor": {
    "id": "<monitor ID>",
    "name": "Primary domain",
    "tags": ["production"]
  },
  "change": {
    "summary": "A monitored value changed.",
    "previous": "<previous customer-facing value>",
    "current": "<current customer-facing value>"
  },
  "links": {
    "dashboard": "https://whoisjsonapi.com/dashboard/monitoring/<monitor ID>"
  },
  "test": false
}

Verify signatures and process deliveries

Verify every request before processing it. Calculate HMAC-SHA256 over the exact received request-body bytes with your stored signing secret, Base64-encode the binary digest, and compare it with X-WhoisJsonAPI-Signature-SHA256 using a timing-safe comparison. Do not parse and re-serialize the body before verifying it.

$expected = base64_encode(hash_hmac(
    'sha256',
    $rawRequestBody,
    '<stored webhook signing secret>',
    true
));

if (!hash_equals($expected, $requestSignature)) {
    // Reject the request.
}

Delivery is at least once. Deduplicate with both X-WhoisJsonAPI-Event-Id and X-WhoisJsonAPI-Delivery-Id, or with an equivalent idempotency policy. Automatic retries retain the delivery identity and body. A manual resend creates a separate manual delivery.

Current retry policy

Transport errors, timeouts, and HTTP 408, 409, 425, 429, 500, 502, 503, and 504 are retryable. The current backoff is 1 minute, 5 minutes, 30 minutes, and 2 hours, with terminal failure after attempt five. Successful responses, redirects, and HTTP 400, 401, 403, 404, 410, and 422 are not retried. This is the current delivery policy, not a delivery-time guarantee.

Rate limits

A rate limit is the number of API calls an app or user can make within a given time period. If this limit is exceeded or if CPU or total time limits are exceeded, the app or user may be throttled. API requests made by a throttled user or app will fail.

Platform rate limits

Errors

When you request information about a domain, you may receive a message that the domain was not found. This means that the domain has not yet been registered and might be available for purchase.

Code Examples

curl --location \
--request GET 'https://whoisjsonapi.com/v1/youtube.com' \
--header 'Authorization: Bearer {your token}'

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://whoisjsonapi.com/v1',
    'timeout'  => 2.0,
]);
$response = $client->request('GET', '/youtube.com', [
    'headers' => [
        'Accept'        => 'application/json',
        'Authorization' => 'Bearer {your token}'
    ]
]);

$response->getStatusCode();
$response->getBody();

const axios = require('axios');

const config = {
    headers: {
        "Content-type": "application/json",
        "Authorization": `Bearer {your token}`,
    },
};

axios
  .get('https://whoisjsonapi.com/v1/youtube.com', null, config)
  .then(res => {
    console.log(`statusCode: ${res.status}`);
    console.log(res);
  })
  .catch(error => {
    console.error(error);
  });

import (
    "fmt"
    "net/http"
    "time"
)

func main() {
    client := &http.Client{
        Timeout: time.Second * 5,
    }

    req, err := http.NewRequest("GET", "https://whoisjsonapi.com/v1/youtube.com", nil)
    if err != nil {
        return fmt.Errorf("Got error %s", err.Error())
    }

    req.Header.Set("Authorization", "Bearer {your token}")

    response, err := client.Do(req)
    if err != nil {
        return fmt.Errorf("Got error %s", err.Error())
    }
    defer response.Body.Close()
}