Domain Name Availability API: Check Names, WHOIS and DNS

Check a list of company or product names across domain extensions, then look up the taken ones. Paste this into your agent:

Set up https://monid.ai/SKILL.md, and then use Monid to check whether these names are available as .com, .io, .ai, .co and .dev domains, and for every taken domain give me the registrar, creation date, expiry date, nameservers and MX records.

One prompt sweeps the names and reads the records. 1 min setup · 7-16 hrs saved.

You have a name for a company or a product, or a shortlist of fifty, and you want to know which domains are free, which are taken, who holds the taken ones and how old they are. A registrar's search box answers that one name at a time. This guide shows the API route: one call per name for availability, one call per domain for the registration record, what comes back (we ran the lookup live on 2026-10-16), and what to watch for in the output. It runs through Monid, the OpenRouter for agent tools: one key, one balance, every tool priced per call.

What is the easiest way to check domain name availability through an API?

Monid. Install it once, add a key, and your agent calls a domain endpoint with a name and gets structured JSON back, with no vendor account to open and no plan to pick.

• Pay per call. Every lookup is billed on its own. The availability sweep is $0.0594 per name and the WHOIS and DNS lookup is $0.022 per domain (Verified 2026-10-16 on the company enrichment tools page). Buy calls as you need them: no monthly plan and no minimum top-up. Discovery and inspection are free; only a run bills.
• One install, every API. The same key and the same balance call the domain endpoints and every other tool on Monid. When a taken domain turns out to belong to a company you want to research, the next step is another call on the same balance, such as finding that company's website from its name, not another vendor.
• Lives inside your agent. Install the CLI, add your key, run the prompt above, and the tool is there whenever your agent needs it, on demand, with nothing to keep running. Your agent reads SKILL.md and learns the rest, so setup is about a minute.

At those prices, sweeping 100 candidate names costs about $5.94 and reading the registration record of 100 domains costs about $2.20 (Verified 2026-10-16).

How do you check domain availability for a list of names?

Run one sweep call per name and loop it over your list. The availability endpoint is /x402/startup-domain-check from the provider api.strale.io. It takes a company_name and, according to its listing, checks the .com, .io, .ai, .co and .dev domains plus the Twitter, GitHub, npm and PyPI handles for that name, so one call covers a whole row of extensions.

Monid fits a list because the work is the same call repeated, and you pay for the names you check and nothing between runs.

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

Sweep one name

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

Loop it over your list

Put one name per line in names.txt and write one file per name:

mkdir -p out
while read -r n; do
  monid run -p api.strale.io -e /x402/startup-domain-check --query "{\"company_name\": \"$n\"}" > "out/$n.json"
done < names.txt

Each name bills one call, whatever the number of extensions inside it. Filter the files for the domains marked available, then spend the lookups below only on the taken ones you care about.

Or hand the whole job to an agent

Can you check domains yourself with Python?

Yes, and for a handful of names it is an afternoon. A WHOIS client or the whois package gives you the registration record of a domain that exists, and the dnspython package gives you the DNS records. For the common extensions that is a few lines per domain.

The cost is everything around those lines. Registries format their WHOIS answers differently, so the parser you write for .com needs another branch for each new extension. Some registries rate-limit or refuse automated queries, which means retries and spacing. Date formats vary, nameserver fields come back in different cases, and an unregistered name looks different from a registered one in each registry's text. Handles on GitHub, npm or PyPI add another set of lookups with their own rules. The first working version takes hours and the upkeep is steady.

Here is the part you would write for the age of a domain, once you have a creation date:

from datetime import datetime, timezone

def age_in_days(creation_date: str) -> int:
    created = datetime.fromisoformat(creation_date)
    return (datetime.now(timezone.utc) - created).days

The Monid route is the choice for anything you will run more than once. The registry parsing is maintained behind the endpoint, the output is typed JSON instead of text you parse, and a registration and DNS lookup is $0.022 a domain (Verified 2026-10-16). A registrar search box or a bulk checker website is quicker for one pasted list, but it is made for a person reading a screen, not for a pipeline or an agent.

How do you check the age of a domain, and who holds it?

Read the registration record. A domain's creation date, expiry date, registrar and nameservers are all in it, and age is the creation date subtracted from today. We ran /v1/domain-info from the provider api.kadec0.xyz on 2026-10-16 against monid.ai and example.com, so the fields below are what came back.

The response

{ "type": "domain_info",
  "domain": "monid.ai",
  "whois": {
    "registrar": "Spaceship, Inc.",
    "creationDate": "2026-03-13 05:23:08+00:00",
    "expirationDate": "2035-03-13 05:23:08+00:00",
    "updatedDate": "2026-08-30 01:06:44+00:00",
    "nameServers": ["launch1.spaceship.net", "launch2.spaceship.net"],
    "status": ["clientTransferProhibited https://icann.org/epp#clientTransferProhibited"],
    "country": null },
  "dns": {
    "A": ["3.169.173.114", "3.169.173.73", "3.169.173.127", "3.169.173.47"],
    "AAAA": ["2600:9000:2858:6a00:a:452:9200:93a1", "... 7 more"],
    "MX": ["1 smtp.google.com"],
    "NS": ["launch2.spaceship.net", "launch1.spaceship.net"],
    "TXT": ["v=spf1 include:_spf.google.com include:spf.mtasv.net ~all", "... 3 more"],
    "CNAME": [] } }

The whois block has the registrar, three dates, the nameservers, the EPP status codes and a country. The dns block has the A, AAAA, MX, NS, TXT and CNAME records at the time of the call. The query takes one parameter, domain, and it is required.

The age falls out of creationDate. monid.ai was created on 2026-03-13, so on the day of the run it was a little over seven months old. example.com came back with a creation date of 1995-08-14. That subtraction is the number people mean when they search for a domain age checker, and the same record also gives you the expiry date, which for monid.ai is 2035-03-13.

The endpoint takes about 3.4 seconds at the median and 5.7 seconds at the 95th percentile according to monid inspect; our two calls completed in about 2.6 and 2.0 seconds.

What you can build with it

• A new-domain filter for signups. Compute the age from creationDate and route very young domains to a closer look before an account gets access. Threshold the number yourself rather than leaning on a label.
• A shortlist of parked names. Once the sweep says a name is taken, the lookup shows the registrar, the dates and the nameservers, which tells you whether a domain is about to lapse and which registrar holds it.
• A sender check. The MX and TXT records show whether a domain handles mail and which services it has verified.

What goes wrong when you look up domains in bulk?

Four things show up when you read the output of more than one domain. All four are from the 2026-10-16 runs.

Why is a null country not a missing country?

Because the field was null on both domains we ran, monid.ai and example.com, and a registrant country is the kind of field a rule might filter on. A null here means the record carries no value for it, so treat it as "not provided" and never as a country you can infer. If country matters to your workflow, take it from a different signal.

Why does a reserved domain show an odd registrar?

example.com came back with the registrar RESERVED-Internet Assigned Numbers Authority. That is the real string for a domain held for documentation, and it will not match any registrar list you maintain. Normalise the registrar field before you group or count by it, and expect a few strings that are not companies.

What does an empty mail record look like?

The MX value for example.com was ["0 "]: a priority of zero and an empty mail host. A parser that splits the string and reads the second part gets an empty string, and a rule that treats "has an MX record" as "receives mail" gets it wrong. Check that the host after the priority is not empty before you decide.

Why do TXT records give away more than you asked for?

The four TXT values on monid.ai included an SPF record and domain-verification strings for Atlassian, Apple and Rippling. Those strings show which services the domain owner signed up for, which is useful for a sender check or for sales research such as reading the tech stack a company runs, and also means you should not log raw DNS output into a place that others can read.

What does a list cost, and how long does it take?

Each lookup is one billed unit. Our two calls billed $0.022 each, $0.044 in total (Verified 2026-10-16). A hundred domains is about $2.20 and, run one after another at roughly three seconds each, a few minutes. Run several at once if you need the list faster.

Which endpoint should I use for which job?

Prices Verified 2026-10-16 with monid inspect. For "is this name free", start with the first row. For "who holds this domain and how old is it", the last row returns the registration record and the DNS records in one call at the lowest price in the table. The age-only endpoint returns less and costs more per call than the last row, so reach for it only when you want the age as a ready number. Inspect any of them for free before you spend a call.

All five bill per call, so a list of a hundred names is a hundred calls per endpoint you use and the bill does not depend on how many extensions or records sit inside each answer.

When is another route a better fit?

You want to register the name. These endpoints read. Registration is a transaction with a registrar, with its own account, payment and contact details. The API tells you what to look at; it does not buy anything.

You need to know who owns a domain. Registrant details are often withheld from public records, and the country came back null on both domains we ran. A name and email are a registrar contact form or a legal request, not an API call.

You need trademark clearance. A free domain says nothing about whether the name is a registered mark. A trademark search is a separate database, and naming a company on domain availability alone is how a rename happens months later.

You check one name once. A registrar's search box answers that in seconds and costs nothing. An API earns its place when you have a list, a repeat check or an agent doing the looking.

And the disclosure: we resell these endpoints. The most useful thing in this post is the habit it describes, which costs nothing: read the null fields and the odd strings in the output before you build a rule on them, whoever you buy the data from.

Conclusion

The quickest way to check domain name availability for a list of names is one sweep call per name through Monid: $0.0594 a call (Verified 2026-10-16), one key for this and every other tool, about a minute to set up and ready inside your agent whenever you need it. For the taken names, the registration and DNS lookup is $0.022 a domain. Building the checker yourself works for a few names and costs hours of parsing and upkeep; Monid keeps the lookups maintained.

Two things matter more than the endpoint you pick. A null is not an answer: the country was null on both domains we ran, so a rule built on it decides nothing. And parse strings before you trust them, because a reserved registrar and an empty mail record both arrived as ordinary-looking values.

How we estimated the time saved: building and running your own checker is roughly 4 to 8 hours for the WHOIS and DNS handling across a few extensions, plus 3 to 8 hours in the first month for the formats and refusals that show up. That is 7 to 16 hours. The 1 minute is the install, key and first call once you already have a Monid key.

Free next step: run monid inspect -p api.kadec0.xyz -e /v1/domain-info, then make one call on a domain you already know and compare the dates with your registrar's dashboard. Start at monid.ai or browse the utilities endpoints.

FAQ

Published September 2026.