Domain registration · Availability · Details

Domain API

Is the domain registered?

Build a domain search or check names in your app. Send one domain and get its registration status as JSON, with an explicit unknown when the check cannot complete.

Registration checks on every plan. Registration details included on paid plans.

Try it

Run example (Command+Enter or Ctrl+Enter)
Example response/domain/gmail.com
{
  "domain": "gmail.com",
  "available": false,
  
    "created": "1995-08-13T04:00:00.000Z",
    "updated": "2026-07-11T10:11:23.000Z",
    "expires": "2027-08-12T04:00:00.000Z",
    "registrar": "MarkMonitor Inc.",
    
      "client delete prohibited",
      "client transfer prohibited",
      "client update prohibited",
      "server delete prohibited",
      "server transfer prohibited",
      "server update prohibited"
    ],
    "dnssec": false
  }
}

Highlighted fields: Included on paid plans.

One domain. One request.

Registration.
Ready for your app.

Start with the availability check. Paid plans include the available registrar and registration dates automatically. See the request and complete JSON together.

Check whether a domain is registered.

This complete response says gmail.com is registered. Core works on every plan and uses one API request.

Request

curl "https://api.parseapi.com/domain/gmail.com" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "X-API-Version: 2.2.0"

Example response

JSON200 OK
{
  "domain": "gmail.com",
  "available": false,
  "registration": {
    "created": "1995-08-13T04:00:00.000Z",
    "updated": "2026-07-11T10:11:23.000Z",
    "expires": "2027-08-12T04:00:00.000Z",
    "registrar": "MarkMonitor Inc.",
    "status": [
      "client delete prohibited",
      "client transfer prohibited",
      "client update prohibited",
      "server delete prohibited",
      "server transfer prohibited",
      "server update prohibited"
    ],
    "dnssec": false
  }
}

Highlighted fields: Included on paid plans.

Domain API referenceOpen the domain checker

An answer your app can act on

Three outcomes.
No guessing.

Keep registration checks predictable in a search box or onboarding flow. A missing answer stays unknown, so your app can ask the user to try again.

true

No registration found

The registration service reports the domain as unregistered. Confirm sale availability with a registrar.

false

Already registered

The domain has a registration. Paid plans include the published registration details automatically.

null

Check unavailable

The service could not confirm the answer. Keep this separate from an available domain.

Domain → DNS · MX · Company · Stack

Put the domain in context.

Reuse the domain for DNS, mail routing, company matches and website technologies. Each follow-up is a separate lookup you can make when your app needs it.

Domain · Core on every plan

Check its registration

/domain/apple.com

Domain returns the domain name and whether a registration was found. Unknown registration status stays null.

Core fields you can reuse

{
  "domain": "apple.com"
}

Continue with the fields you need. Each follow-up is a separate call.

  • Use domain

    Read its DNS records

    /dns/apple.com

    Reuse the domain with DNS to inspect its published records. A registration alone does not confirm that a website is configured.

  • Use domain

    Inspect its mail routing

    /mx/apple.com

    Use the same domain with MX when you need its mail-routing answer. Mail routing does not prove that an individual mailbox exists.

  • Use domain

    Find matching companies

    /company?domain=apple.com

    Look for the domain in our selected public-company directory. An empty company list means no directory match, not that no business exists. Keep multiple matches as separate companies.

  • Use domain

    See what the website uses

    /stack/apple.com

    Find supported technologies visible in the homepage’s HTML and headers. A null checked_at means the page could not be checked; empty lists after a completed check mean no supported matches.

Each lookup uses its own pooled request. These examples use Core responses, with no Deep request.

Use this in your app
JavaScript
// Run on your server with PARSEAPI_KEY in the environment.
const key = process.env.PARSEAPI_KEY;
if (!key) throw new Error('Set PARSEAPI_KEY on your server.');
const segment = value => encodeURIComponent(value);
const timezonePath = zone => zone.split('/').map(segment).join('/');

async function lookup(path, query = {}) {
  const url = new URL(path, 'https://api.parseapi.com');
  url.search = new URLSearchParams(query).toString();
  const response = await fetch(url, {
    headers: { 'X-API-Key': key, 'X-API-Version': '2.2.0' },
    signal: AbortSignal.timeout(10000),
  });
  if (!response.ok) {
    const error = await response.json().catch(() => null);
    throw new Error(error?.message ?? 'ParseAPI returned HTTP ' + response.status);
  }
  return response.json();
}

const domain = await lookup('/domain/' + segment('apple.com'));
const host = typeof domain.domain === 'string' && domain.domain.length > 0
  ? domain.domain
  : null;
// Independent requests: one failure does not discard the other answers.
const [dns, mx, company, stack] = await Promise.allSettled([
  host ? lookup('/dns/' + segment(host)) : null,
  host ? lookup('/mx/' + segment(host)) : null,
  host ? lookup('/company', { domain: host }) : null,
  host ? lookup('/stack/' + segment(host)) : null,
]);
// A fulfilled Company response with companies: [] means no directory match.
// Keep all returned matches; do not assume the first one owns the domain.
// A rejected result is a failed request, not an empty match.
// For Stack, checked_at: null means the page could not be checked.
// Empty technology lists after a completed check mean no supported matches.
console.log({ domain, dns, mx, company, stack });

Registration coverage & freshness

A changing fact.
Checked again.

Domain registrations change. Checks use supported public registration services and reuse recent answers within a bounded window. An expired answer needs a new check.

Read the registration contract
Up to one hour for registered domains
Unregistered answers have a shorter window of up to five minutes. A failed refresh returns unknown.
Coverage follows the registration service
Support depends on the domain ending. Unavailable services return null. Missing registration dates and registrar names stay null.
Registration, DNS and mail are distinct
Use the same key for DNS records and mail routing. For the registration-detail workflow, explore WHOIS.

From a search box to your app

One key.
Your way to build.

Copy the HTTP request, use an SDK in your language, or connect Domain to an agent through MCP. The same API key works across ParseAPI.

HTTP, SDKs and MCP

Follow the reference for input, authentication, complete responses and errors. Eight supported SDKs expose the same Domain lookup and included plan data.

Before you build.

What does available mean?

true means the registration service reported no registration. false means the domain is registered. null means the check could not be completed. An unknown result is never treated as an available domain.

Can I buy every domain marked available?

Confirm with a registrar before checkout. An unregistered name can be reserved, restricted or otherwise unavailable for sale. This API checks registration status and does not reserve or register a domain.

How fresh is a registration check?

Registered answers can be reused for up to one hour; unregistered answers for up to five minutes. Once an answer expires, the next lookup checks again. If that check cannot complete, available is null.

Which domains can I check?

Public domain names served by a supported registration service. Send a hostname, without a URL or email address. Registration-service coverage and availability depend on the domain ending. An unsupported or unavailable service returns available: null.

What do paid plans include?

Paid plans automatically include registration details in the same response: registrar, creation, update and expiry dates, status, and DNSSEC registration information. Missing dates and registrar names stay null. Unregistered domains return available: true. Free requests and unavailable registration checks omit registration detail.

Does registration tell me whether a website or email works?

Registration, DNS and mail routing answer different questions. Use /dns for published DNS records and /mx for mail servers. A registered domain does not establish that either service is working.

Domain API pricing

Start with a clear answer.

One lookup uses one API request from your shared ParseAPI allowance. Registration checks work on every plan. Paid plans include registration details.

Free

Start free

Domain registration checks

Room to grow

See plans

Checks and registration details