Domain Name Availability API: Registered Is Not the Same as Live

Copy this line to your agent to check a name across domains and social handles.

set up https://monid.ai/SKILL.md and use api.strale.io /x402/startup-domain-check with a company name

On 2026-09-15 we ran our own company name through a domain availability check. Five extensions came back. One was unregistered, two were registered with nothing behind them, two were live sites. A yes-or-no answer would have called four of the five "taken" and hidden the two that might be for sale. Then we asked two different WHOIS providers about the one we own, and they agreed on every date to the second while disagreeing about which extra fields to include. This guide runs through Monid, the OpenRouter for agent tools.

What does a domain availability API actually return?

Three different things depending on the endpoint, and the useful design puts them in this order: a sweep across extensions and handles, then a WHOIS record for one domain, then DNS.

The sweep

api.strale.io/x402/startup-domain-check for monid:

{
  "keyword": "monid",
  "domains": [
    { "domain": "monid.com", "extension": ".com", "available": true,  "current_owner": null },
    { "domain": "monid.io",  "extension": ".io",  "available": false, "current_owner": "Domain registered but no active website" },
    { "domain": "monid.ai",  "extension": ".ai",  "available": false, "current_owner": "Active website (HTTP 200)" },
    { "domain": "monid.co",  "extension": ".co",  "available": false, "current_owner": "Active website (HTTP 200)" },
    { "domain": "monid.dev", "extension": ".dev", "available": false, "current_owner": "Domain registered but no active website" }
  ],
  "social": [
    { "platform": "Twitter/X", "handle": "@monid", "available": null, "note": "Not checked, X's Terms of Service prohibit automated access." },
    { "platform": "GitHub", "handle": "monid", "available": false },
    { "platform": "npm", "package": "monid", "available": true }
  ],
  "available_count": 1, "taken_count": 4, "best_available_domain": "monid.com"
}

One call, five extensions, a handful of platform handles, and a best_available_domain field that picks for you. The current_owner string is the part most availability checkers do not give you, and the next section is about why it matters.

The WHOIS record

api.strale.io/x402/whois-lookup for monid.ai returned the parsed fields, registrar, created, updated, expires, status codes, registrant, registrant country and nameservers, plus a raw_whois block of about 3,000 characters and a _meta.provenance object naming the registry it queried and the fetch time.

The DNS view

api.kadec0.xyz/v1/domain-info for the same domain returned the same WHOIS core plus a dns block: four A records, six AAAA records, MX, NS, TXT and CNAME. That is the difference between knowing a domain is registered and knowing where it points.

The honest null

The X handle came back available: null with a note explaining why: the platform's terms prohibit automated checks, so the provider did not make one. That is a field saying "we did not look" rather than guessing, and it is worth more than a confident wrong answer. The same distinction between a measured field and an inferred one runs through the salary data guide.

📖 See also Best API to Search a Company's Homepage From Its Name

Why is "available" not a yes or no?

Because there are three states a domain can be in, and the middle one is the interesting one.

The three states, from our five results

Unregistered. monid.com, available: true, current_owner: null. Nobody holds it. You can register it at a registrar for the standard fee.

Registered, no site. monid.io and monid.dev, available: false, owner note "Domain registered but no active website". Somebody holds it and is not using it. This is where domains for sale live: parked, held by an investor, or forgotten. A boolean calls it "taken" and it may be the one you can actually acquire.

Registered, live. monid.ai and monid.co, owner note "Active website (HTTP 200)". Somebody holds it and runs a business on it. This is the only state that truly means "not for you".

Why the boolean loses information

A checker that returns true or false merges the second and third states. Both say false. But the second is a negotiation and the third is a wall, and the string in current_owner is what separates them. If you are naming a company, the domains in the middle state are the shortlist, and a tool that hides them has hidden your options.

What the middle state does not tell you

Whether it is for sale, at what price, or whether the holder will answer. That is a WHOIS lookup and then a human conversation. The availability call finds the door; it does not open it.

On our own result

Our .com was unregistered on the day we checked. We are publishing that because it is what the API returned, and because the point of this article is that a founder should learn this from a call, on purpose, before a squatter learns it from a launch announcement. It is also a reminder that "we own the brand" and "we own the domain" are different facts, and the check that separates them costs a few cents.

How do you check a name across domains and handles by API?

Three steps, and the first one does most of the work.

For agents

Grab an API key at app.monid.ai, then paste this to your agent and hand it the key:

set up https://monid.ai/SKILL.md

It learns the whole discover, inspect, run workflow itself. More in the agent quickstart.

For humans

npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main

Step 1. Sweep the name

What it does. Checks the common extensions and the main platform handles in one call.

The endpoints. api.strale.io/x402/startup-domain-check, billed per call, requires company_name.

The call.

monid run -p api.strale.io -e /x402/startup-domain-check --query '{"company_name": "monid"}'

What comes back. Five domain rows with available and current_owner, a social array, counts and a best_available_domain.

What it costs. A few cents per call, and one call covers every extension. Current figures at monid.ai/tools.

Step 2. Look up the ones in the middle state

What it does. Tells you who holds a registered-but-parked domain and when it expires.

The endpoints. api.strale.io/x402/whois-lookup, per call, requires domain.

The call.

monid run -p api.strale.io -e /x402/whois-lookup --query '{"domain": "monid.io"}'

What comes back. Registrar, dates, status, a registrant block that is usually redacted, nameservers, the raw text and a provenance stamp. The expires date is the one to note: a parked domain near expiry may simply lapse.

What it costs. A few cents per call.

Step 3. Confirm what a live one points at

What it does. Adds the DNS picture, which tells you whether a "live" site is a real business or a placeholder.

The endpoints. api.kadec0.xyz/v1/domain-info, per call, requires domain.

The call.

monid run -p api.kadec0.xyz -e /v1/domain-info --query '{"domain": "monid.ai"}'

What comes back. The WHOIS core again plus A, AAAA, MX, NS, TXT and CNAME. MX records present means the domain sends mail, which is a stronger sign of a real operation than an HTTP 200. Once a domain is confirmed live, the same string is the key into full company firmographics, which is where a naming check turns into account research.

📖 See also Find All URLs on a Domain: Why the Sitemap Route Usually Stops

Do two WHOIS providers give the same answer?

On the facts, yes, to the second. On what surrounds the facts, no, and the differences are the reason to know both.

The measurement

Same domain, same minute, 2026-09-15:

What agrees

Every date, the registrar, the status code and both nameservers. Two providers reading the same registry will agree on registry facts, and they did.

What differs, and why it matters

Registrant country. One returned US, the other returned null. Same registry, and the redacted registrant block evidently still carries a country field that one parser reads and the other does not. If country matters to your workflow, pick the provider that returns it, and do not treat the null as "unknown country".

Raw text versus DNS. One provider gives you the source document so you can parse anything it missed. The other gives you DNS, which the registry does not hold at all. They are complementary and neither is complete.

Provenance. One response names the registry it queried and when. For anything you might later have to defend, a compliance check, a dispute, that stamp is the difference between a fact and a claim.

The rule

Registry facts you can take from either. Everything else is a per-provider envelope, and the way to know which envelope you need is to run both once and read them, which is the same advice measured on two contact-data providers in the Apollo email finder guide.

Which endpoint should I use for which job?

Every row was verified with monid inspect on 2026-09-15. The table gives billing shape rather than figures, because shape drives design and current numbers live on monid.ai/tools.

All five bill per call, so checking a hundred candidate names is a hundred sweeps and the bill does not depend on how many extensions each sweep covers.

When is an availability API the wrong tool?

Four cases.

You want to register the domain. These endpoints read; none of them buys. Registration is a registrar's job, with its own account, payment and ICANN obligations. The API tells you what to register and where to look; it does not complete the transaction.

You need the registrant's identity. WHOIS registrant data is redacted for privacy on most domains, and both providers returned "Redacted for Privacy Purposes". The country survived on one of them. A name and email did not survive on either, and no API restores them; that is a registrar contact form or a legal process.

You need trademark clearance. A domain being unregistered says nothing about whether the name is a registered mark, and a trademark search is a separate database with separate endpoints. Naming a company on domain availability alone is how a rename happens six months later.

You are checking a handle on a platform that forbids it. The response told us plainly that X was not checked because its terms prohibit automated access. A tool that returned an answer there would be either guessing or violating terms, and the honest null is the right result.

And the disclosure: this is Monid's blog and we resell all three endpoints. The most useful thing this article reports is that our own .com was sitting unregistered, which is not a flattering thing to measure, and the recommendation is one sweep per name rather than one call per extension.

Conclusion

A domain name availability API is more useful than a registrar's search box for one reason: it returns the state a domain is in rather than a yes or no. On our own name, one extension was unregistered, two were registered with nothing behind them, and two were live. The two in the middle are the ones a boolean hides and the ones a founder can sometimes buy.

What matters more than the endpoint is reading current_owner and then following up with WHOIS on the parked ones, because that is where the expiry date lives. And when two WHOIS providers are both on the shelf, run both once: they agreed on every registry fact and disagreed on every extra, and which extra you need is a property of your workflow, not of the domain.

Free next step: run monid inspect -p api.strale.io -e /x402/startup-domain-check to read the response shape, then sweep your own company name and look at the middle state. Start at monid.ai.

FAQ

Last updated September 2026.