Skip to content
Domain Lookup
API key
Free service · free API key for the API & MCP

Check any domain, straight from the registry

Availability, WHOIS / RDAP, DNS records and SSL certificates in one lookup. Search right here, or use the JSON API and the MCP server for AI assistants with a free, instant API key. No account, no password.

Try , , . A bare name checks it across 10 popular TLDs.

  • Registry RDAP
  • WHOIS fallback
  • DNS cross-check
  • Certificate Transparency

MCP & Agents

Remote MCP server for AI agents

Domain Lookup is a remote MCP server. Connect it once with your free API key and ask your assistant things like “Is netflix.dev free?” or “When does example.com expire?”.

Seven tools

  • check_domain_availability

    Is a domain free to register? Answered by the registry.

  • bulk_check_availability

    Up to 10 domains in one call.

  • suggest_domains

    One name across many TLDs: acme.com, acme.io, acme.dev…

  • whois_lookup

    Registrar, dates, EPP status, nameservers, DNSSEC.

  • domain_age

    Registration date, age and days until expiry.

  • dns_lookup

    A, AAAA, CNAME, MX, NS, TXT, SOA and CAA records.

  • ssl_certificates

    Certificates and subdomains from CT logs.

Replace dlk_your_key with your key.Get a free key

Run once in your terminal. The server is added for your user and works in every project.

Terminal
claude mcp add --transport http domainlookup https://domainlookup.dev/mcp \
  --header "Authorization: Bearer dlk_your_key"

Replace dlk_your_key with your key.Get a free key

In Claude Desktop or claude.ai, open Settings → Connectors → Add custom connector, name it Domain Lookup and paste this URL. Connectors cannot send headers, so the key goes in the URL.

Connector URL
https://domainlookup.dev/mcp?key=dlk_your_key

Replace dlk_your_key with your key.Get a free key

In ChatGPT, add a custom MCP connector (available with developer mode) using this URL and no authentication. The key goes in the URL.

Connector URL
https://domainlookup.dev/mcp?key=dlk_your_key

Replace dlk_your_key with your key.Get a free key

Add the server to your global Cursor config (or .cursor/mcp.json in a project).

~/.cursor/mcp.json
{
  "mcpServers": {
    "domainlookup": {
      "url": "https://domainlookup.dev/mcp",
      "headers": {
        "Authorization": "Bearer dlk_your_key"
      }
    }
  }
}

Replace dlk_your_key with your key.Get a free key

Codex reads the key from an environment variable. Export it in your shell profile, then add the server to your Codex config.

Shell profile
export DOMAINLOOKUP_API_KEY="dlk_your_key"
~/.codex/config.toml
[mcp_servers.domainlookup]
url = "https://domainlookup.dev/mcp"
bearer_token_env_var = "DOMAINLOOKUP_API_KEY"

Replace dlk_your_key with your key.Get a free key

Add the server to your workspace, then start it from the MCP view or Copilot chat.

.vscode/mcp.json
{
  "servers": {
    "domainlookup": {
      "type": "http",
      "url": "https://domainlookup.dev/mcp",
      "headers": {
        "Authorization": "Bearer dlk_your_key"
      }
    }
  }
}

Replace dlk_your_key with your key.Get a free key

Any MCP client that speaks Streamable HTTP can connect to https://domainlookup.dev/mcp. Send the key as a header, or use https://domainlookup.dev/mcp?key=… when the client cannot set headers. It is stateless JSON-RPC over POST, so you can also call it directly:

Terminal
curl -s https://domainlookup.dev/mcp \
  -H "Authorization: Bearer dlk_your_key" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

initialize and tools/list work without a key so clients can connect; tool calls need one. 300 requests per minute per key.

HTTP API

A plain JSON API

Every route answers JSON with an ok field and allows CORS from any origin. Send your free API key as Authorization: Bearer <key>, X-Api-Key or ?key=.

Replace dlk_your_key with your key.Get a free key

  • GET

    /api/availability?domain=

    Is a domain available?
    curl "https://domainlookup.dev/api/availability?domain=facebook.com" \
  -H "Authorization: Bearer dlk_your_key"
  • POST

    /api/availability/bulk

    Up to 10 domains in one call
    curl -X POST "https://domainlookup.dev/api/availability/bulk" \
  -H "Authorization: Bearer dlk_your_key" \
  -H "Content-Type: application/json" \
  -d '{"domains": ["facebook.com", "netflix.io"]}'
  • GET

    /api/suggest?name=&tlds=

    One name across TLDs
    curl "https://domainlookup.dev/api/suggest?name=netflix&tlds=com,io,dev,ai" \
  -H "Authorization: Bearer dlk_your_key"
  • GET

    /api/whois?domain=

    Registration data (RDAP / WHOIS)
    curl "https://domainlookup.dev/api/whois?domain=example.com" \
  -H "Authorization: Bearer dlk_your_key"
  • GET

    /api/dns?domain=&type=

    DNS records, one type or all
    curl "https://domainlookup.dev/api/dns?domain=example.com&type=MX" \
  -H "Authorization: Bearer dlk_your_key"
  • GET

    /api/certificates?domain=&limit=

    SSL certificates and hostnames
    curl "https://domainlookup.dev/api/certificates?domain=example.com&limit=10" \
  -H "Authorization: Bearer dlk_your_key"
  • POST

    /api/keys

    Create a free API key (no key needed)
    curl -X POST "https://domainlookup.dev/api/keys" \
  -H "Content-Type: application/json" \
  -d '{}'
  • POST

    /mcp

    MCP (JSON-RPC over HTTP)
    curl -s "https://domainlookup.dev/mcp" \
  -H "Authorization: Bearer dlk_your_key" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"check_domain_availability","arguments":{"domain":"facebook.com"}}}'
Response · GET /api/availability
{
  "ok": true,
  "domain": "facebook.com",
  "status": "registered",
  "available": false,
  "source": "rdap"
}

source is rdap, whois or dns; status is available, registered or unknown. Errors come back as {"ok": false, "error": "..."}: HTTP 401 without a valid key, 429 over the limit. Full reference in llms-full.txt.

Get a free API key

Needed for the HTTP API and MCP tools. Free and instant: no account, no password. 300 requests per minute.

Only used to reach you about the service.

The key is saved in this browser and shown here on return visits. Up to 5 keys per IP address per day.

What you get

Everything about a domain, in one lookup

One query gives you the registry verdict, registration data, DNS and certificates. The same data is available to people, scripts and AI assistants.

  • Availability you can trust

    Asked of the registry that runs the TLD. A name is only called available when the registry itself has no record.

  • Name ideas across TLDs

    Type a bare name like “acme” and see .com, .io, .dev, .ai and more side by side, 10 at a time.

  • WHOIS / RDAP data

    Registrar, creation, expiry and last-changed dates, EPP status codes, nameservers and DNSSEC.

  • Domain age and expiry

    How old a domain is and how many days are left before it expires, computed from registry dates.

  • DNS records

    A, AAAA, CNAME, MX, NS, TXT, SOA and CAA, resolved live over DNS-over-HTTPS.

  • SSL certificates and subdomains

    Certificates from Certificate Transparency logs and every hostname on them: a quick subdomain inventory.

How it works

Answers from the source, fetched live

Every lookup goes to the authoritative source at the moment you ask. Nothing is guessed from a stale database, and every availability answer tells you where it came from.

  1. 01

    Normalize the name

    Input is reduced to its registrable domain with the Public Suffix List (shop.example.co.uk → example.co.uk). Names under TLDs that do not exist are rejected.

  2. 02

    Ask the registry over RDAP

    The registry’s RDAP server is looked up in the IANA RDAP bootstrap file and asked directly. No registration record means the name is not registered.

  3. 03

    Fall back to registry WHOIS

    Some TLDs have no RDAP server yet. For those, the registry’s own WHOIS server on port 43 is asked instead.

  4. 04

    Cross-check with DNS

    A DNS delegation proves a name is registered. DNS alone never marks a name as available: without an authoritative registry answer the result is “couldn’t verify”.

Data sources

IANA RDAP bootstrap
Which registry answers for each TLD
Registry RDAP and WHOIS
Availability and registration data
Cloudflare DNS-over-HTTPS
DNS records and delegation checks
crt.sh
Certificate Transparency logs

Our accuracy rule

We never say “available” without an authoritative answer from the registry. Premium or reserved names can have no registration record and still not be for sale at the usual price, so your registrar has the final word.

Free · API key required

Free to use, with a free key and fair rate limits

There is no paid plan, no trial and no credit card. The API and MCP tools need a free API key: instant, no account, no password. The search box on this site works without one. Each lookup queries registries, DNS and Certificate Transparency live, so rate limits keep the service fast for everyone and polite to the registries.

requests / minuteper free API key, for the API and MCP
300
searches / minutein this web app without a key, per IP
30
domains per callfor bulk checks and suggestions
10
API keys / dayper IP address
5

FAQ

Questions and answers

Is Domain Lookup really free?

Yes. There is no paid plan, no trial and no credit card. The HTTP API and MCP tools need a free API key, which you get instantly with no account and no password. Each key allows 300 requests per minute. The search box on domainlookup.dev works without a key (30 searches per minute per IP address).

How accurate is the availability check?

Availability comes from the registry that runs the TLD: its RDAP server (found through the IANA bootstrap file) or, for TLDs without RDAP, its port-43 WHOIS server. DNS is used as a cross-check. DNS can prove a name is registered, but Domain Lookup never reports a name as available without an authoritative answer from the registry. Every answer says which source it came from.

Why does a domain show as available but my registrar will not sell it?

Registries can hold premium or reserved names that have no registration record yet still cannot be registered at the normal price, or at all. The registry has no record of the name, but the final word on price and eligibility belongs to the registrar.

What is RDAP and how is it different from WHOIS?

RDAP (Registration Data Access Protocol) is the structured JSON successor to WHOIS, run by the same registries. Domain Lookup reads RDAP first and falls back to classic WHOIS on port 43 for TLDs that do not offer RDAP yet. Most registries redact registrant details, so expect registrar-level data.

Do I need an API key?

For the HTTP API and MCP tool calls, yes. The key is free and instant: no account, no password, and an email address is optional. Send it as "Authorization: Bearer <key>", as "X-Api-Key: <key>", or as ?key=<key> in the URL for MCP connectors that cannot send headers. Searching on domainlookup.dev itself does not need a key.

What if I lose my API key?

The key is saved in the browser where you created it and shown there on return visits. We only store a hash of it, so a lost key cannot be recovered: keep a copy in your password manager, or simply create a new one.

How do I use Domain Lookup from an AI assistant?

Create a free API key, then add the remote MCP server https://domainlookup.dev/mcp to Claude Code, Claude Desktop, ChatGPT, Cursor, Codex, VS Code or any client that speaks MCP over Streamable HTTP. Clients that cannot send headers, such as Claude and ChatGPT custom connectors, use https://domainlookup.dev/mcp?key=<your key>. Your assistant then gets seven tools for availability, name suggestions, WHOIS, domain age, DNS and SSL certificates.

What happens when I hit the rate limit?

The API answers HTTP 429 with a Retry-After header; wait a minute and try again. Each key allows 300 requests per minute, and bulk and suggest calls check at most 10 domains each. Requests without a valid key get HTTP 401.

Who runs Domain Lookup?

Domain Lookup is built and run by Beta Limited as a free service for developers, domain hunters and AI agents. Questions, bugs or a need for higher limits: write to support@beta.limited.