Tutorial7 min readUpdated · Published

How to Search for Domains With an AI Agent (Cross-Registrar Workflow)

An AI agent can brainstorm names, check availability, and compare prices across three registrars in a single conversation — if you connect the right MCPs. This is the five-step workflow: pick registrars, connect the servers (Cloudflare's is hosted; Name.com and Porkbun run locally), brainstorm candidates, fan out the availability checks, pick the cheapest source. Works best in Claude Desktop or Claude Code; ChatGPT supports a subset of the same flow.

Goal

Compare domain availability + price across registrars

Time

~15 min one-time setup, ~2 min per search

Prereq

Accounts at Cloudflare (with a payment method), Name.com, Porkbun

Steps

1

Pick the registrars the agent will search

Domain availability differs by registrar — not by which one "owns" the domain (a name is either taken globally or not), but by which TLDs each registrar carries and what they charge. The minimum useful set: Cloudflare (at-cost, a curated TLD subset through the Registrar API beta on its hosted MCP), Name.com (broad inventory, official server, sandbox by default), Porkbun (at-cost, broad TLDs, community server). If the team deploys on Vercel, its MCP is a fourth headless source with per-TLD pricing. GoDaddy and Namecheap add nothing outside ChatGPT.

2

Install the three MCPs in your client

For Claude Desktop, add all three to claude_desktop_config.json. Cloudflare's server is hosted at mcp.cloudflare.com/mcp: add it as a custom connector under Settings → Connectors, or bridge it with mcp-remote as below and sign in with OAuth when the browser opens. Do not use the npm package @cloudflare/mcp-server-cloudflare — it is an older Workers-only server with no Registrar access. Name.com takes a username + token pair (and hits its test environment until NAME_API_URL points at production), Porkbun an API key + secret. Keep credentials in env blocks, never in args.

{
  "mcpServers": {
    "cloudflare": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.cloudflare.com/mcp"]
    },
    "name-com": {
      "command": "npx",
      "args": ["-y", "namecom-mcp@latest"],
      "env": {
        "NAME_USERNAME": "your_user",
        "NAME_TOKEN": "your_token",
        "NAME_API_URL": "https://mcp.name.com"
      }
    },
    "porkbun": {
      "command": "uvx",
      "args": ["porkbun-mcp"],
      "env": {
        "PORKBUN_API_KEY": "pk1_...",
        "PORKBUN_SECRET_KEY": "sk1_..."
      }
    }
  }
}
3

Prompt the agent to brainstorm names first

Most domain searches start with a vague idea, not a known name. Ask the agent to brainstorm a list of candidates before any availability check — that turns a single registrar call into a structured workflow with five or ten parallel checks.

Brainstorm 10 domain name candidates for a new project
called "an AI agent that reviews pull requests". Mix
short, brandable names (.ai, .dev) with descriptive ones
(.so, .build). Return the list, then ask me to confirm
which ones to check.
4

Check availability across all three registrars

The agent should call each registrar's availability operation for every candidate — Cloudflare's domain-check endpoint through its execute tool, Name.com's ManageDomains with operation check, Porkbun's domains_check_bulk — then compose the results into a single table. The killer feature is the price spread: the same .com name typically costs about the same everywhere, but a .dev or .ai can vary by 30% or more.

For each candidate from step 3, use the Cloudflare, Name.com,
and Porkbun MCPs to check availability. Return a table with:
domain, available (yes/no), and price at each registrar
(USD, first year). Sort by price ascending.
5

Pick the winner and register it

Once the comparison table is in the conversation, pick the domain you want and the registrar to buy it from (usually the cheapest one that carries the TLD). Switch back to a single-registrar flow for the actual registration — the buy step is covered in the dedicated tutorial linked below.

I want to register codereview.dev from the cheapest source
in the table. Before calling register, restate the exact
domain, the cost, and which registrar you will use. Wait
for me to reply "yes" before proceeding.

Use read-only tokens for the search step

Availability checks are read-only operations at every registrar. Issue read-only API tokens for the search workflow and keep your write-scoped tokens locked in a password manager. When you decide to register a specific domain, swap to the write token, complete the purchase, swap back. The minor friction is worth the smaller blast radius.

Sample comparison table the agent should produce

This is what the output of step 4 should look like once the agent has fanned out across the three MCPs.

Agent output
Domain             Available   Cloudflare   Name.com   Porkbun
codereview.dev     yes         $12.18       $14.99     $11.98
codereview.ai      yes         —            $69.99     $54.99
codereview.io      yes         —            $39.99     $32.99
codereview.app     yes         $13.98       $14.99     $13.98
codereview.so      no          —            —          —

Cheapest available pick: codereview.dev at Porkbun ($11.98).

When it does not work

Agent only uses one MCP, ignores the others

Default behaviour when the prompt is ambiguous. Be explicit: "Use the Cloudflare, Name.com, and Porkbun MCPs in parallel" or list each tool by name in the request. The agent fans out reliably once it sees the explicit list.

Cloudflare returns "not supported" for a TLD

The Registrar API beta scopes search results to API-supported extensions — a curated subset of what Cloudflare Registrar sells, with no .io and few country-code TLDs. The "—" in the comparison table is the right behaviour: the agent should still report availability and price from the other registrars.

Name.com MCP hits the test environment

NAME_API_URL defaults to mcp.dev.name.com (safe). For real searches you need NAME_API_URL=https://mcp.name.com — the test env returns synthetic data that does not match reality. Verify the env var is set to production before trusting the prices.

Porkbun rate-limits the search

Porkbun's availability endpoint has a stricter rate limit than the others. For batches over 20 candidates, ask the agent to throttle — "check no more than 5 names at a time, pause briefly between batches."

FAQ

Why search across multiple registrars instead of one?

TLD pricing varies. A .ai domain can cost $50 at one registrar and $90 at another for the same first-year registration. Searching across three lets the agent surface the price spread before you commit — and for portfolios of 5+ domains a year, the difference compounds.

Can I do this in ChatGPT instead of Claude?

Partially. ChatGPT reaches the hosted Cloudflare server as a custom connector (Developer mode) and Vercel's MCP as a reviewed connector, and the GoDaddy and Namecheap ChatGPT Apps are first-party. Name.com and Porkbun run locally over stdio with no hosted endpoint, so they need Claude Desktop, Claude Code, Cursor or another local client. Claude is the lower-friction setup for a multi-registrar workflow.

Does the agent need write access just to search?

Mostly not. Porkbun's server starts read-only and needs two flags before it can register; Name.com defaults to its sandbox, so a search there cannot spend anything; Namecheap's community server cannot register at all. Cloudflare is the exception: the same credential serves domain-check and registrations, so keep the human confirmation on the registration call itself, and prefer OAuth where you can leave Registrar write unticked until you are ready to buy.

How accurate are availability checks?

Availability is authoritative per-TLD via the registry, not cached. All three registrars hit the same upstream registries, so the answers agree. Pricing is a different story — each registrar sets its own retail price, so the agent has to query each one.

What if I want to add GoDaddy or Namecheap to the search?

Namecheap, yes: the community namecheap-api-mcp checks availability and premium pricing for up to 50 names per call from any client, though it cannot register. GoDaddy remains ChatGPT-only. Vercel's MCP is another headless source if the team is on Vercel — get_domain_availability, get_domain_price and list_supported_tlds — and it can complete the purchase with a quote-then-confirm flow.

Does the agent get confused with three MCPs that all do the same thing?

Sometimes. The mitigation is in the system prompt: name each MCP explicitly when you want a specific one, and use "all three" or "each registrar" when you want the agent to fan out. Agents default to whichever tool was registered first if the prompt is ambiguous.

Once you picked a domain

The dedicated "buy a domain from Claude" tutorial walks through the registration step end-to-end, including the confirmation pattern that prevents accidental purchases.

Related guides

Browse all 64 guides