How to Check If a Domain Name Is Available?

You have a name in mind, and the only question left is whether you can have it. Checking domain availability sounds trivial, and for a single name in a registrar's search box it usually is. But the answer is not always a simple yes or no: a name can be unregistered yet reserved, available only at a premium price, stuck in a redemption period, or registered without any website attached. And if you are evaluating dozens of candidates, typing them into a search box one by one gets old fast. This article covers every practical way to check availability, from registrar search to RDAP, WHOIS, and DNS, explains how to interpret each result, and gives you scripts to check a whole shortlist at once. If you are still brainstorming, start with how to choose the right domain name for your business.

What "Available" Actually Means

A domain is available when the registry for its TLD has no record of it and has not reserved it. The registry is the authoritative database, run by an operator like Verisign for .com or a national registry for a country-code TLD. Registrars, the companies you buy from, query the registry for you. If those roles are fuzzy, see what the difference between a registry and a registrar is.

That gives five realistic states for any name you check:

State	What it means	Can you register it?
Available	No registration, not reserved	Yes, at the standard price
Available (premium)	Unregistered, but the registry charges a premium price	Yes, at a higher and sometimes recurring price
Registered	Someone holds it	Only by buying it from the owner
Expired, not yet deleted	In grace, redemption, or pending delete	Not yet; it may drop later
Reserved or blocked	Held back by registry policy	Usually no

Only the registry knows the whole truth, so the most reliable checks ask the registry directly, either through a registrar's search or through RDAP.

Method 1: Use a Registrar's Search

The fastest way is to type the name into the search box of any reputable registrar. The registrar asks the registry in real time and tells you whether the name is available, whether it is premium, and what it costs.

Tips for using registrar search well:

• Compare the renewal price, not only the first-year price. Premium names and some new gTLDs renew at much higher rates.
• Ignore the upsell list of alternative extensions unless you are genuinely open to them.
• Use a registrar you trust. There is a long-standing concern about front-running, where searches are allegedly used to register names before the searcher does. ICANN has studied this and found little evidence of it at accredited registrars, but if a name is valuable to you, search where you intend to buy, and buy promptly.

You can also use ICANN Lookup at lookup.icann.org, which is not a store and queries registration data for gTLDs directly.

Method 2: Query RDAP

RDAP (Registration Data Access Protocol) is the structured, JSON-based successor to WHOIS. For gTLDs, it has been the definitive source of registration data since January 2025, when ICANN ended the requirement for registries and registrars to run the old WHOIS service. For background, see what RDAP is and how it is replacing WHOIS.

RDAP is ideal for availability checks because it uses ordinary HTTP status codes:

• 200 OK with a JSON body: the domain is registered.
• 404 Not Found: the registry has no record of the domain, so it is very likely available.

The rdap.org service redirects each query to the correct registry server, so you do not need to know which registry runs which TLD:

curl -s -o /dev/null -w "%{http_code}\n" -L https://rdap.org/domain/example.com

This prints 200, because example.com is registered. Try a random string and you should get 404:

curl -s -o /dev/null -w "%{http_code}\n" -L https://rdap.org/domain/thisnameisprobablyfree-7f3k9.com

To see more detail about a registered domain, such as its status codes and expiry date, use jq:

curl -sL https://rdap.org/domain/example.com \
  | jq '{status: .status, events: [.events[] | {(.eventAction): .eventDate}]}'

An expiration date that has passed, or statuses such as redemption period or pending delete, tell you the name may become available later. Those stages can last weeks before a name is released.

Finding the Registry's RDAP Server Yourself

If you prefer not to depend on a third-party redirector, IANA publishes the official RDAP bootstrap file listing the RDAP base URL for each TLD. That is what the scripts below use.

Method 3: Use WHOIS

The traditional whois command still works for many TLDs, especially country-code TLDs, many of which do not offer RDAP:

whois example.com

For an unregistered name, the response typically contains a phrase like No match for, NOT FOUND, No Data Found, or Status: free. The exact wording varies from registry to registry, which is the main reason WHOIS is awkward to automate:

whois somecandidate.de | grep -iE "no match|not found|no data found|status: *free|available"

For gTLDs, port 43 WHOIS is no longer guaranteed, so prefer RDAP.

Method 4: Check DNS (a Hint, Not an Answer)

A quick DNS lookup can tell you whether a domain is delegated, meaning it has name servers in the TLD zone:

dig +short NS example.com

If you get name servers back, the domain is definitely registered. If you get nothing, you cannot conclude it is available. Registered domains can have no name servers, can be on hold, or can be in redemption, and all of those look the same as "not registered" in DNS. Use DNS only as a fast pre-filter.

Comparing the Methods

Method	Authoritative?	Easy to automate?	Works for ccTLDs?	Shows premium price?
Registrar search	Yes (queries registry)	Only via registrar API	Usually	Yes
RDAP	Yes	Yes, JSON and status codes	Only where supported	No
WHOIS	Yes, where still offered	Awkward, free-text output	Often	No
DNS (dig)	No, a hint only	Yes	Yes	No

Bulk-Checking a Shortlist With Python

This Python script uses only the standard library. It downloads IANA's RDAP bootstrap file once, finds the right RDAP server for each TLD, and reports each domain as registered, not found, or unknown.

import json
import sys
import time
import urllib.error
import urllib.request

BOOTSTRAP_URL = "https://data.iana.org/rdap/dns.json"


def load_bootstrap() -> dict:
    with urllib.request.urlopen(BOOTSTRAP_URL, timeout=20) as resp:
        data = json.load(resp)
    mapping = {}
    for tlds, urls in data["services"]:
        for tld in tlds:
            mapping[tld.lower()] = urls[0].rstrip("/") + "/"
    return mapping


def check(domain: str, servers: dict) -> str:
    tld = domain.rsplit(".", 1)[-1].lower()
    base = servers.get(tld)
    if not base:
        return "no RDAP server for this TLD (use WHOIS or a registrar)"
    req = urllib.request.Request(
        f"{base}domain/{domain}",
        headers={"Accept": "application/rdap+json", "User-Agent": "availability-check/1.0"},
    )
    try:
        with urllib.request.urlopen(req, timeout=15) as resp:
            info = json.load(resp)
            statuses = ", ".join(info.get("status", [])) or "no status"
            return f"registered ({statuses})"
    except urllib.error.HTTPError as err:
        if err.code == 404:
            return "not found (likely available)"
        if err.code == 429:
            return "rate limited, try again later"
        return f"unknown (HTTP {err.code})"
    except urllib.error.URLError as err:
        return f"lookup failed ({err.reason})"


if __name__ == "__main__":
    names = sys.argv[1:] or ["example.com", "example.org", "acmeplumbing.dev"]
    servers = load_bootstrap()
    for name in names:
        print(f"{name:35} {check(name.strip().lower(), servers)}")
        time.sleep(1)  # be polite to registry servers

Run it with your candidates as arguments:

python3 check_domains.py acmeplumbing.com acmeplumbing.net acmeplumbing.co.uk

Note that for a name like acmeplumbing.co.uk, the script looks up the uk TLD, which is correct, because the .uk registry handles .co.uk names too, if it publishes RDAP.

Bulk-Checking With Node.js

The same idea in Node.js 18 or later, which has fetch built in. Save it as check-domains.mjs:

const BOOTSTRAP_URL = "https://data.iana.org/rdap/dns.json";

async function loadBootstrap() {
  const res = await fetch(BOOTSTRAP_URL);
  const data = await res.json();
  const map = new Map();
  for (const [tlds, urls] of data.services) {
    for (const tld of tlds)
      map.set(tld.toLowerCase(), urls[0].replace(/\/?$/, "/"));
  }
  return map;
}

async function check(domain, servers) {
  const tld = domain.split(".").pop().toLowerCase();
  const base = servers.get(tld);
  if (!base) return "no RDAP server for this TLD";
  const res = await fetch(`${base}domain/${domain}`, {
    headers: { Accept: "application/rdap+json" },
  });
  if (res.status === 404) return "not found (likely available)";
  if (res.ok) {
    const info = await res.json();
    return `registered (${(info.status || []).join(", ")})`;
  }
  return `unknown (HTTP ${res.status})`;
}

const names = process.argv.slice(2);
const servers = await loadBootstrap();
for (const name of names) {
  console.log(name.padEnd(35), await check(name.toLowerCase(), servers));
  await new Promise((r) => setTimeout(r, 1000));
}

Run it with node check-domains.mjs acmeplumbing.com acmeplumbing.io.

Rate Limits and Etiquette

Registry RDAP servers apply rate limits, and they vary. Keep requests slow (one per second is a safe habit), cache results, and do not hammer servers with thousands of queries. For large-scale checks, use a registrar's official availability API, which is designed for that volume and also reports pricing.

Reading the Results Correctly

A "not found" from RDAP is a strong signal, but there are cases where the name still cannot be registered at the standard price:

• Registry-reserved names. Registries reserve some strings, such as certain geographic names or names held back for future release. RDAP may return 404 for them.
• Premium names. Many registries price short or dictionary names at a premium. RDAP will not tell you that; a registrar search will. See what a premium domain is.
• Names in a launch phase. New TLDs go through sunrise and early-access periods before general availability.
• Recently deleted names. A name that has just dropped may appear free and be registered by drop-catching services within seconds.

And when the name is registered, you have options:

1. Check if it is expiring. Look at the expiry date and statuses. If it is in redemption or pending delete, a backorder may help.
2. Approach the owner. Many registered names are for sale. See how to buy a domain name that's already taken.
3. Try a variation with a different extension or a natural modifier.

Once you find an available name you like, register it promptly. Our step-by-step guide on how to register a domain name walks through the process.

---

Domain Availability FAQ

Conclusion

Checking domain availability is easy for one name and only slightly harder for many. A registrar search gives you the most complete answer, including premium pricing. RDAP gives you an authoritative, scriptable answer through simple HTTP status codes. WHOIS still fills the gaps for country-code TLDs without RDAP, and DNS is only a quick hint that a name is taken.

Whatever method you use, read the result in context: a "not found" might still be reserved or premium, and a "registered" name might be expiring or for sale. Run your shortlist through a script, confirm the winners at a registrar, and register your choice before someone else does.

Here are some useful references for going deeper on domain availability and registration data:

1. ICANN: Registration Data Access Protocol (RDAP) — ICANN's overview of RDAP and its role in gTLD registration data.
2. ICANN: ICANN Lookup — look up registration data for any gTLD domain.
3. IANA: RDAP Bootstrap Registry for DNS — the official mapping of TLDs to RDAP servers.
4. RFC 9082: RDAP Query Format — defines how RDAP lookups such as domain queries are structured.
5. RFC 9224: Finding the Authoritative RDAP Service — describes the bootstrap process used by the scripts above.