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. Details with Deep.
Try it
One domain. One request.
Registration.
Ready for your app.
Start with the availability check. Add Deep when your app needs the registrar and registration dates. 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?deep=true" \
-H "X-API-Key: YOUR_API_KEY"Example response
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. Add Deep to read the published details.
- null
Check unavailable
The service could not confirm the answer. Keep this separate from an available domain.
Domain → DNS · MX
One domain. Three useful questions.
Keep the same domain name as you move from registration to website records and mail routing. Each API answers a different part of your domain setup.
Check its registration
/domain/example.com
Fields from the response
{
"domain": "example.com"
}Domain returns the domain name and whether a registration was found. Unknown registration status stays null.
Use
domainRead its DNS records
/dns/example.com
Reuse the domain with DNS to inspect its published records. A registration alone does not confirm that a website is configured.
Use
domainInspect its mail routing
/mx/example.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 this in your app
// 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, 'Parse-Version': '2.0.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('example.com'));
const [dns, mx] = await Promise.all([
domain.domain ? lookup('/dns/' + segment(domain.domain)) : null,
domain.domain ? lookup('/mx/' + segment(domain.domain)) : null,
]);
console.log({ domain, dns, mx });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 Domain and its optional Deep argument.
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 does Deep include?
On paid plans, ?deep=true adds registration details to the same response: registrar, creation, update and expiry dates, status, and DNSSEC registration information. Missing dates and registrar names stay null. Unregistered domains return registered: false. Free requests and unavailable registration checks return deep: {}.
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