Skip to main content

How we check availability

Registration and purchasability are genuinely different facts.

Everything below is generated from the live configuration this site runs on, and every claim comes with the command to check it yourself.

The short version

A registry can tell you, definitively, whether a domain has a registration record. That is the question RDAP answers, and we ask the registry itself rather than a middleman.

It cannot tell you whether you can buy it. A domain with no registration record can still be priced as a premium name, reserved by the registry, or simply not carried by your registrar. Those are different facts from different systems, and anything that shows you one number for both is guessing about at least one of them.

Check our work
Build the example around

Typing a domain sets the extension from it, because that is how our checker resolves one — expert.dev is looked up under .dev.

Step 1 — find the registry. IANA publishes the map of every top-level domain to its RDAP server at data.iana.org/rdap/dns.json. We cache it and re-read it daily. For .dev it resolves to:

https://pubapi.registry.google/rdap/

Step 2 — ask it about a domain. The HTTP status code is the answer: 200 means a registration record exists, 404 means it does not. Nothing else is an answer. A 429 (slow down), a 5xx (server error) or no response at all tells you about the registry, not the domain, so we mark the name unknown or rate limited and ask again later. We never count any of those as taken or available.

# The domain you picked -- expected: HTTP 404
curl -sI -H 'Accept: application/rdap+json' \
  https://pubapi.registry.google/rdap/domain/gpglzqxwq04fh3.dev | head -1

# The control: nic.dev, which we expect to answer HTTP 200
curl -sI -H 'Accept: application/rdap+json' \
  https://pubapi.registry.google/rdap/domain/nic.dev | head -1

Both halves matter. A server that answered 200 to everything would report every domain as taken, and a check that only ever asks about one domain cannot tell that apart from a working one. We run the pair.

gpglzqxwq04fh3.dev was generated for this page load and will be different next time. Fourteen random characters is about 1020 possibilities against a DNS of well under a billion names — if it ever comes back 200, something far more interesting than a documentation bug has happened.

The same request in PHP, Python, Ruby, C# and JavaScript

No API key, no account, no registration. RDAP is an open standard and these are public endpoints. Every sample below queries gpglzqxwq04fh3.dev — change that one string to ask about anything else.

$ch = curl_init('https://pubapi.registry.google/rdap/domain/gpglzqxwq04fh3.dev');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => ['Accept: application/rdap+json'],
    CURLOPT_TIMEOUT        => 10,
]);
$body = curl_exec($ch);
$code = (int) curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

// Only 200 and 404 are answers. Anything else means "ask again later" --
// never read it as registered. A timeout is $body === false with $code 0.
echo match (true) {
    $body === false => 'unknown (no response)',
    $code === 200   => 'registered',
    $code === 404   => 'no registration record',
    $code === 429   => 'rate limited -- retry later',
    default         => "unknown (HTTP $code)",
};
import urllib.request, urllib.error

url = 'https://pubapi.registry.google/rdap/domain/gpglzqxwq04fh3.dev'
req = urllib.request.Request(url, headers={'Accept': 'application/rdap+json'})

# Only 200 and 404 are answers; anything else means "ask again later".
# urllib raises on any 4xx/5xx, so the 404 has to be caught rather than read.
try:
    with urllib.request.urlopen(req, timeout=10) as r:
        print('registered' if r.status == 200 else f'unknown (HTTP {r.status})')
except urllib.error.HTTPError as e:
    if e.code == 404:
        print('no registration record')
    elif e.code == 429:
        print('rate limited -- retry later')
    else:
        print(f'unknown (HTTP {e.code})')
except (urllib.error.URLError, TimeoutError):
    print('unknown (no response)')
require 'net/http'
require 'uri'

uri = URI('https://pubapi.registry.google/rdap/domain/gpglzqxwq04fh3.dev')
req = Net::HTTP::Get.new(uri, 'Accept' => 'application/rdap+json')

begin
  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true,
                        open_timeout: 10, read_timeout: 10) { |http| http.request(req) }

  # Net::HTTP returns the status as a STRING, not an integer -- '404', not 404.
  # Only 200 and 404 are answers; anything else means "ask again later".
  puts case res.code
       when '200' then 'registered'
       when '404' then 'no registration record'
       when '429' then 'rate limited -- retry later'
       else "unknown (HTTP #{res.code})"
       end
rescue Net::OpenTimeout, Net::ReadTimeout, SocketError
  puts 'unknown (no response)'
end
using System;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;

using var http = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
http.DefaultRequestHeaders.Add("Accept", "application/rdap+json");

// Do NOT call EnsureSuccessStatusCode() here. HttpClient throws only when
// there is no response at all, so the 404 arrives as an ordinary response --
// and that 404 IS the answer you came for. Only 200 and 404 are answers.
try
{
    var res = await http.GetAsync("https://pubapi.registry.google/rdap/domain/gpglzqxwq04fh3.dev");
    Console.WriteLine(res.StatusCode switch
    {
        HttpStatusCode.OK              => "registered",
        HttpStatusCode.NotFound        => "no registration record",
        HttpStatusCode.TooManyRequests => "rate limited -- retry later",
        _                              => $"unknown (HTTP {(int) res.StatusCode})",
    });
}
catch (Exception e) when (e is HttpRequestException or TaskCanceledException)
{
    Console.WriteLine("unknown (no response)");
}
// fetch() does not reject on 4xx/5xx, only when there is no response at
// all. Note that from a BROWSER this is a cross-origin request and most
// registry RDAP servers do not send CORS headers. Run it server-side
// (Node, Deno, Bun). Only 200 and 404 are answers.
let answer;
try {
  const res = await fetch('https://pubapi.registry.google/rdap/domain/gpglzqxwq04fh3.dev', {
    headers: { Accept: 'application/rdap+json' },
    signal: AbortSignal.timeout(10000),
  });
  answer = res.status === 200 ? 'registered'
         : res.status === 404 ? 'no registration record'
         : res.status === 429 ? 'rate limited -- retry later'
         : `unknown (HTTP ${res.status})`;
} catch {
  answer = 'unknown (no response)';
}
console.log(answer);

One courtesy if you build on this: registries publish these endpoints as a compliance obligation, not as a high-throughput API, and several attach terms asking you not to hit them with high-volume automated processes. Honour Retry-After on a 429, keep concurrency per registry in the low single digits, and cache what you get.

Where WHOIS fits, and why it goes last

There are three ways to ask, and we use them in a fixed order.

Tier The question it actually answers
DNS Is this name pointed at nameservers? One UDP packet, fast enough to run across hundreds of thousands of candidates — and blind in one specific way, below.
RDAP Does the registry hold a registration record? Structured JSON, defined status codes, no parsing guesswork. Used whenever the extension has one.
WHOIS The same question as RDAP, asked the way we asked it in 1982. Last resort, and confirm-only.

WHOIS runs only when RDAP structurally cannot answer — that is, when the extension has no RDAP server in the IANA bootstrap file at all. It is not a fallback for RDAP having a bad day. If a registry's RDAP server is slow or throwing errors we back off and retry it; we do not quietly switch to a weaker source and keep the same confidence badge.

It is also confirm-only. WHOIS never produces a verdict here on its own — it confirms or contradicts a DNS “available”, which is why you will not find it in the list of check methods further down. That list is what you can choose; WHOIS is something the checker reaches for on your behalf.

Why it is last: RDAP answers with a status code. WHOIS answers with free text and no schema — RFC 3912 defines the transport (open TCP port 43, send a line, read until the server hangs up) and says nothing whatsoever about what comes back. So “is this domain free?” degrades into matching phrases like No match, NOT FOUND or Status: free, which differ per registry and can change without notice. That is a fine last resort and a terrible primary source: a parser that guesses wrong reports a registered domain as available, which is the one error that costs you money.

Second-level extensions use their parent's RDAP server. IANA lists .uk, not .co.uk, and the lookup takes the longest match from the right (RFC 9224). So a .co.uk name is asked of the .uk registry, and a .com.au name of the .au one. WHOIS comes in only when neither the extension nor its parent has an RDAP server.

For .dev — the extension in the example above — RDAP answers, so WHOIS is never consulted.
What the confidence badge means

Shown next to every Available result. These descriptions are read from the same code that assigns the grade, so they cannot drift.

Grade What it means
High High confidence — the registry itself was asked and reported no registration for this domain. Note this says nothing about PRICE: a domain can be unregistered and still be sold as a premium name for far above the base rate.
Medium Medium confidence — DNS says available and a second opinion was requested, but the registry errored, rate-limited, or answered unclearly. The DNS result stands unverified.
Low Low confidence — this rests on DNS alone, and no registry check was ever attempted. DNS cannot tell an unregistered domain from a registered-but-parked one, so treat this as a lead, not a fact. Re-check with RDAP before acting on it.
What we cannot tell you
  • Price. A domain with no registration record can still be a premium name. We have measured one at $500.20 that RDAP correctly reported as unregistered.
  • Registry reservations. Some names are held back and never released. They have no registration record either, so they look identical to a free domain over RDAP.
  • Your registrar's inventory. Registrars choose what to sell. One declining to sell you a name is not evidence that it is registered — we have seen a registrar report "registered already" for a domain the registry itself says has no record.

This is the boundary of what a registration lookup can establish, not a gap in our checking. The definitive answer on price and purchasability is the checkout page of a registrar that carries the extension.

What DNS cannot see

A DNS check is one UDP packet and it is fast enough to run across hundreds of thousands of candidates. It answers a different question: is this name delegated to nameservers?

A domain someone registered this morning and never pointed anywhere is absent from DNS and looks free. That blind spot is the one that costs money — it is the failure where you go to buy a domain and find it taken. Only a registry lookup sees registration itself, which is why DNS-only answers are graded Low and expire quickly.

How long we trust an answer

Live values from this site's configuration.

Answer forRe-checked after
.com 24 hours
.io 12 hours
.dev 48 hours
DNS-only "available" 1 hours

Instant results for names we've already checked. Inside the window above, a saved answer is reused, so a name we have already looked up comes back at once with no new lookup. If you would rather not trust saved answers, tick Re-check everything (ignore saved answers) on a search and every name is looked up again from scratch.

Separately, an Available result older than 7 days is downgraded a confidence grade. That is a different question from the cache lifetime above — one asks "is it worth spending a lookup to re-check this?", the other asks "should you trust this enough to go spend money?"

Coverage

We track 589 extensions. 532 of them can be routed to a registry RDAP server via the IANA bootstrap file; the remaining 57 are answered by DNS alone, backed up by WHOIS where one is reachable, and carry the lower confidence grade that implies.

Check methods you can choose:

  • dns — DNS Check
  • rdap — RDAP (recommended)

Frequently asked questions

RDAP & WHOIS

RDAP, or Registration Data Access Protocol, is the modern standard for retrieving domain registration data. It sends a structured request to the registry responsible for a domain extension and returns details such as registration status, registrar, dates, nameservers, and available public contact data. DNS Lister uses RDAP to check domain availability against authoritative registry records.

WHOIS is an older, plain-text lookup system with inconsistent formats across registries. RDAP is its structured successor, returning standardized data that software can interpret more reliably. RDAP also supports clearer privacy controls, referral links between registries and registrars, and more consistent handling of international domain extensions.

RDAP replaced WHOIS because WHOIS was not designed for modern privacy requirements, global domain systems, or reliable machine-readable data. RDAP provides standardized responses, stronger privacy support, and better access controls. ICANN moved gTLD registration-data services from WHOIS to RDAP in 2025, making RDAP the current authoritative protocol for domain registration lookups.

Yes. RDAP queries the authoritative service for the relevant registry or follows a referral to the appropriate registry or registrar endpoint. That makes it more dependable than inferring availability from DNS records alone. A missing DNS record does not always mean a domain is available, but a registry-backed RDAP response provides a much stronger answer.

How we check

Both, in a fixed order. RDAP is the primary check: it asks the registry for that extension directly. WHOIS is used only when an extension has no RDAP server at all, which is common among country-code domains, and only to confirm a result. A quick DNS lookup runs first, as a pre-filter.

Each name is checked against every TLD you selected. A fast DNS lookup first screens out names that are clearly registered. The remaining candidates are confirmed with RDAP from the extension's own registry, or with WHOIS where no RDAP server exists. Results are saved as they resolve, so you see early answers while the rest of a large batch finishes.

Both. Every result is stored with the time it was checked. If you search a name again soon after, the saved result is reused rather than asking the registry again — typically within 12 to 48 hours depending on the extension, and 1 hour for unconfirmed "available" answers (the current values are in the table above). Recheck any domain to force a fresh registry lookup, and always recheck before buying.

Accuracy

RDAP is one of the most reliable ways to verify domain registration status because it uses registry-backed data. However, no availability result is a guarantee of successful registration. Registry updates, reserved names, redemption periods, premium pricing, or another buyer registering the name between lookup and checkout can affect the final outcome.

A domain can appear available but fail at checkout if its status changes after the lookup, if the registry reserves it, or if it is subject to a premium or policy restriction. Some domains may also be in a brief transition state after expiration or deletion. Rechecking immediately before registration reduces this risk.

RDAP reads the registry's current status, so it reflects new registrations and expirations quickly. But expired domains often pass through grace, redemption and pending-delete periods before anyone can register them. And a saved result can be hours old. Recheck a recently expired name right before you try to buy it.

How we check

No. Nearly all generic extensions (.com, .net, .app and so on) do, because ICANN requires it. Many country-code extensions don't: each country sets its own rules. For those we use the registry's WHOIS server where one exists. If an extension has neither, we say the result is unknown rather than guess.

Results

Available: the registry has no record of the name. Taken: it is registered. Unknown: we got an answer but it didn't settle the question, or the extension can't be checked. Error: the lookup itself failed, usually a timeout or network problem. Unknown and error are never counted as available; recheck them later.

Registries limit how fast anyone can query them. When one tells us to slow down, the affected names are marked rate limited instead of being guessed at. Nothing is wrong with the name; recheck it a little later and it will normally resolve.

Every name is checked once per extension you selected, so 500 words across 10 extensions is 5,000 lookups. We spread them out so that no registry is flooded, and save each answer as it arrives. You see results straight away while the rest of the batch finishes in the background, even if you leave the page.

Privacy

No. A lookup has to name the domain being checked; there is no way to check availability without asking. What we don't send is who asked: your account isn't attached to the lookup, and we don't pass your searches to registrars, brokers or advertisers. See Privacy.