# Domain Search MCP: Registry-Checked Names for AI Agents

Canonical HTML: https://domainsearchking.com/mcp

Availability: this text is an editorial snapshot, not a current registration guarantee. Use the [live domain checker](https://domainsearchking.com/verify) or [MCP](https://domainsearchking.com/mcp) before treating a name as available. Registry errors mean unknown, not available.

Remote MCP · Streamable HTTP

[Home](https://domainsearchking.com/) / MCP

Updated October 14, 2026

Add one URL with no API key, and your agent gets .com/.net names that the registry's RDAP server reported available when the tool ran.

`https://domainsearchking.com/api/mcp` 

[Add to Cursor](https://cursor.com/en/install-mcp?name=domain-search-king&config=eyJ1cmwiOiJodHRwczovL2RvbWFpbnNlYXJjaGtpbmcuY29tL2FwaS9tY3AifQ==) Add to VS Code [Try in browser](https://domainsearchking.com/mcp#demo)

No API key Streamable HTTP 10 calls/day per IP, free Registry RDAP first

Domain Search King is a remote MCP server for agents that need domain suggestions with registry checks. Endpoint: `https://domainsearchking.com/api/mcp`. Use `find_available_domains` for a business idea, `find_available_domains_by_pattern` for keyword patterns, or `check_domain` for one domain. Public search tools need no API key. Availability is time-sensitive; an inconclusive check is not an available result. Registrar price and trademark clearance are separate checks. Each returned name comes with register links of the form `domainsearchking.com/go/<domain>` and `domainsearchking.com/go/spaceship/<domain>`; they redirect through our Namecheap and Spaceship affiliate links, and the tool response says so.

In our [Hallucination Index](https://domainsearchking.com/ai-hallucination-index) run of 2026-09-01 (2,449 suggestions from 10 models, each checked against registry RDAP), 69.5% of the .coms the models called available were already registered. By model, the taken share ranged from 49.5% (claude-sonnet-5, n=287) to 91.8% (claude-haiku-4.5, n=282); per-model rows are in the [CSV](https://domainsearchking.com/ai-hallucination-index.csv). In a separate June 2026 test, a small sample of 76 names this MCP returned was rechecked by RDAP: 75 were still available and 1 had been registered (98.7%).

Compare

## How it compares to registrar MCP servers

Competitor cells summarize each vendor's own documentation or engineering blog as read on October 15, 2026; sources are linked under the table.

|  | Domain Search King | GoDaddy Domains MCP | Dynadot MCP | Unstoppable Domains MCP |
| --- | --- | --- | --- | --- |
| Endpoint | `domainsearchking.com/api/mcp` | `api.godaddy.com/v1/domains/mcp` | `mcp.dynadot.com/mcp` | `api.unstoppabledomains.com/mcp/v1` |
| Account or key needed | No; 10 tool calls/day per IP, resetting at 00:00 UTC | No key or account for its two read-only tools | Yes: account sign-in, API key and MCP enabled in settings | Yes: OAuth sign-in with an Unstoppable Domains account; its docs also list an API key as an advanced option |
| Generates name ideas | Yes, from a keyword or description, or by pattern | Yes (`domains_suggest`) | Yes (alternative-name suggestions) | No suggestion tool listed in its docs on 2026-10-15; search and availability tools are listed |
| Availability check | Registry RDAP check on each request before a name is returned (details below) | GoDaddy's search and availability APIs, with pricing where available | Availability check through your Dynadot account | Through the Unstoppable Domains User API |
| Buys, renews or edits DNS | No (returns a registration link) | No; the post says search and availability only | Yes: registers, renews and reviews DNS; the page says sensitive actions ask for confirmation | Yes: checkout and DNS record management, per its OAuth scopes |

Sources, read 2026-10-15: GoDaddy engineering blog, [“Inside the GoDaddy Domains MCP Server”](https://www.godaddy.com/resources/news/inside-the-godaddy-domains-mcp-server); [Dynadot MCP page](https://www.dynadot.com/domain/mcp); [Unstoppable Domains MCP Server docs](https://docs.unstoppabledomains.com/user-api/mcp-server). Choose a registrar MCP if you want the agent to manage domains you own; choose this one for name ideas checked against the registry without an account.

Connect

## Install by client

The endpoint is the same everywhere; the config shape differs by client.

```
claude mcp add --transport http domain-search-king https://domainsearchking.com/api/mcp

# add it for every project on this machine:
claude mcp add --transport http --scope user domain-search-king https://domainsearchking.com/api/mcp
```

To share it with a team, commit this as `.mcp.json` at the repo root:

```
{
  "mcpServers": {
    "domain-search-king": {
      "type": "http",
      "url": "https://domainsearchking.com/api/mcp"
    }
  }
}
```

Run `claude mcp list` to confirm it connected, then try: “Find 8 available .coms for a late-night coffee roaster.” No OAuth or environment variables are needed.

[One-click Cursor install](https://cursor.com/en/install-mcp?name=domain-search-king&config=eyJ1cmwiOiJodHRwczovL2RvbWFpbnNlYXJjaGtpbmcuY29tL2FwaS9tY3AifQ==) · or paste into `~/.cursor/mcp.json`

```
{
  "mcpServers": {
    "domain-search-king": {
      "url": "https://domainsearchking.com/api/mcp"
    }
  }
}
```

Command Palette → `MCP: Add Server` → HTTP, or this deeplink if Copilot Agent is on.

```
{
  "servers": {
    "domain-search-king": {
      "type": "http",
      "url": "https://domainsearchking.com/api/mcp"
    }
  }
}
```

Claude Desktop / claude.ai: **Settings → Connectors → Add custom connector**. Name it Domain Search King. URL:

```
https://domainsearchking.com/api/mcp
```

If your Desktop build has no custom connectors, `claude_desktop_config.json` only launches local processes, so bridge the remote URL with the `mcp-remote` npm package (needs Node.js):

```
{
  "mcpServers": {
    "domain-search-king": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://domainsearchking.com/api/mcp"]
    }
  }
}
```

ChatGPT Developer Mode / connectors: add a remote MCP server with this URL. It uses the same MCP Streamable HTTP endpoint.

```
https://domainsearchking.com/api/mcp
```

Grok chat: open [grok.com/connectors](https://grok.com/connectors) (the page loaded when we checked on 2026-10-15; menu labels can change), add a custom connector and paste the URL. Grok Build CLI:

```
grok mcp add --transport http domain-search-king https://domainsearchking.com/api/mcp

# xAI SDK / Responses API:
# tools=[mcp(server_url="https://domainsearchking.com/api/mcp")]
```

This is a remote HTTP server, and it needs no API key. Grok rejects localhost URLs, so use this public URL.

DeepSeek, Llama, Qwen, etc. are models, not MCP clients. Wire the **host**: Open WebUI (Admin → Integrations → MCP Streamable HTTP), Continue, Cline, LibreChat. Same URL. OpenClaw: [ClawHub listing](https://clawhub.ai/johnsmalls22-rgb/skills/dsk-available-domains).

```
npx add-mcp https://domainsearchking.com/api/mcp --name domain-search-king

# OpenClaw / ClawHub (live):
clawhub install dsk-available-domains

# Any HTTP MCP client:
POST https://domainsearchking.com/api/mcp
Content-Type: application/json
```

Skill file: [/skill.md](https://domainsearchking.com/skill.md) · server card: [/.well-known/mcp/server-card.json](https://domainsearchking.com/.well-known/mcp/server-card.json)

Tools

## Three tools

Paste a prompt into the agent after install. A name can be registered by someone else after the check, so an agent should call a name free only if one of these tools just returned it.

### find\_available\_domains

Brandable .coms from a keyword plus an optional description of the business. Each candidate is checked against Verisign's RDAP server before it is returned.

“Find 8 available .coms for a late-night coffee roaster.”

### find\_available\_domains\_by\_pattern

Available names that start with, end with or contain a keyword, across up to six TLDs (default .com + .net). One call checks about 360 generated candidates and returns up to 60 available names by default, 200 at most, so it is a sample of the pattern, not a full list of every possible name.

“Available .com and .net names starting with bear.”

### check\_domain

One hostname: RDAP age/expiry, backlinks from our Common Crawl link graph, linking domains that spam heuristics flag for manual review, Wayback history, trademark search links. Raw signals only, with no combined score, so you or your agent can weigh age, links and trademark risk yourselves.

“Run check\_domain on oakbear.net before I buy it.”

### Parameters and limits

These are the input schemas the server returns from `tools/list`. All three tools carry the read-only, non-destructive annotation, so clients that honor MCP tool annotations can skip the confirmation prompt they show before a tool that writes.

| Tool | Arguments | Limits and defaults | Returns |
| --- | --- | --- | --- |
| `find_available_domains` | `keyword` (required), `description`, `count` | `count` 1–24, default 12. .com only. | Names with a register link each, plus `checked_at` and `source` fields |
| `find_available_domains_by_pattern` | `keyword` (required; up to 5, comma-separated), `position`, `tlds`, `limit` | `position`: starts, ends, contains or all (default all). `tlds`: up to 6, default com + net. `limit` 1–200, default 60. About 360 registry lookups per call, so more TLDs means fewer stems per TLD. | Available names grouped by TLD, how many names were checked, `checked_at` |
| `check_domain` | `domain` (required) | Registrable domains only: `www.example.com` is rejected, pass `example.com` | A text summary plus the full report as structured content |

Worked example

## One real call, recorded 2026-10-15

The request an MCP client sends when you ask for names that start with “bear”, and what came back.

```
curl -s -X POST https://domainsearchking.com/api/mcp \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{
        "name":"find_available_domains_by_pattern",
        "arguments":{"keyword":"bear","position":"starts","tlds":["com","net"],"limit":10}}}'
```

The response took 1.5 seconds. The server checked 98 names (bear-first stems, each as a .com and a .net) and returned the first 10 available ones, which were all .net: bearbase.net, bearspot.net, bearcentral.net, bearhero.net, bearflow.net, bearloop.net, bearlist.net, bearbay.net, bearpad.net and bearstore.net. The matching .coms were already registered, which is typical for a short dictionary word.

We rechecked three of them through the public rdap.org redirector a minute later. `bearbase.com` and `bearspot.com` returned HTTP 200, meaning a registration record exists, and `bearbase.net` returned 404, meaning the registry has no record. You can run the same check on any name with `curl -sL https://rdap.org/domain/bearbase.net`, or follow our [guide to checking whether a domain is taken](https://domainsearchking.com/how-to-check-if-a-domain-name-is-taken). Those results describe that minute only; any of the names may have been registered since.

The structured part of the response carried `"checked":98`, `"available":10`, a `checked_at` timestamp of 2026-10-15T23:23:45Z, and a `source` string naming the registry RDAP path, so an agent can show the user when the lookup happened. Each name had its `/go/` register link. The text part also ended with a link to a planned catalog of aged domains. That catalog is not open to buyers yet (the homepage takes waitlist sign-ups for it), and this tool does not check any name in it.

If the .com you wanted is gone and only the .net is left, our [.net vs .com comparison](https://domainsearchking.com/net-vs-com) covers when the .net is worth taking and what to do about the owner of the .com.

How the check works

## How fresh an “available” answer is

Each tool call sends its candidate names to our RDAP proxy server. The proxy keeps an “available” answer for up to 10 minutes and a “registered” answer for up to 24 hours, so a name that was looked up recently can come back from that cache, not from a fresh registry query. If the proxy is down, the server queries the registry directly. The search box on the website keeps a separate cache of popular keywords that can be up to about 30 hours old; the MCP tools do not read from it.

For .com and .net the lookup goes to Verisign, which runs both registries. For other TLDs the server finds the registry's RDAP server through IANA's bootstrap file, and the few country-code registries that run no RDAP server are asked over their own WHOIS server. On premium-prone TLDs such as .io and .ai, an RDAP 404 can also cover names the registry has reserved, so each hit there is confirmed over the registry's WHOIS before it is returned. A name whose premium price cannot be ruled out is marked “premium price not verifiable — check at registrar”. Our [.io vs .com guide](https://domainsearchking.com/io-vs-com) covers why those prices vary so much.

A lookup that times out or gets rate-limited counts as unknown, and unknown names are left out, which is why a pattern search can return fewer names than its limit. An agent that gets zero names back should say so and not fill the gap with names of its own.

The tools do not clear trademarks or quote registrar prices. A name with no registration record can still conflict with a registered mark; our [domain trademark check guide](https://domainsearchking.com/domain-trademark-check) walks through the USPTO search. To look up one name by hand, the browser [domain availability checker](https://domainsearchking.com/verify) uses the same registry path.

Inspector

## Call it from this page.

Same JSON-RPC your agent posts. No signup. RDAP takes a few seconds.

Limits

## What this is not.

### Not a WHOIS mirror

Answers come from the registry's own RDAP or WHOIS server, never a third-party WHOIS cache, which can lag. Whether a website loads says nothing either way: a parked page answers while the name is registered, and a registered name can have no site at all.

### Not a registrar

It cannot buy, renew or edit DNS. A person registers the name at a registrar through the returned link. For first-year and renewal prices across registrars, see our [cheapest .com registrar comparison](https://domainsearchking.com/cheapest-com-domain-registrar).

### Not unlimited

Public tier: 10 tool calls a day per IP with no key, counted per UTC day, so it resets at 00:00 UTC. Only `tools/call` counts; `initialize`, `tools/list` and `ping` are free, and a call rejected for a missing keyword or a subdomain does not use a slot. A JSON-RPC batch can hold up to 10 messages. For higher volume, write to hello@domainsearchking.com.

### Remote only

There is no package to run locally. The server speaks Streamable HTTP at `/api/mcp`: a GET returns server info and the tool names, a POST takes JSON-RPC. `npx add-mcp` and `mcp-remote` only point your client at that URL.

FAQ

## Questions about the MCP

### How do I add this?

Cursor or VS Code: the install buttons at the top of this page. Claude Code: `claude mcp add --transport http domain-search-king https://domainsearchking.com/api/mcp`. Claude Desktop or claude.ai: Settings, Connectors, add a custom connector with that URL. Grok, ChatGPT and other clients: the tabs in the Install section.

### Why not just ask Claude if the name is free?

Without a lookup tool, a chat model does not query the registry, so its "available" is a guess. The [Hallucination Index](https://domainsearchking.com/ai-hallucination-index) run of 2026-09-01 found 69.5% of 2,449 model suggestions already taken. In a separate June 2026 test with a small sample (n=76), 75 of the names this MCP returned (98.7%) were still available on an RDAP recheck.

### Which TLDs does it cover?

`find_available_domains` returns .coms only. `find_available_domains_by_pattern` defaults to .com and .net and accepts up to 6 TLDs per call, such as .org, .io, .ai, .co, .dev or .app. Any TLD whose registry runs an RDAP or WHOIS server can be checked; an unknown TLD returns no names.

### Can a name be taken after the tool returns it?

Yes. A lookup describes one moment, and an "available" answer can be up to 10 minutes old when it comes from our RDAP proxy. Every response carries a `checked_at` timestamp. Register soon after the check, and treat the registrar checkout as the final word.

### What happens when I reach the daily limit?

The tool returns an error result that says "Free daily limit reached (10 tool calls/day)" and points to the search on domainsearchking.com instead. The count is per IP and resets at 00:00 UTC.

### MCP or REST?

MCP for agents. If you write the HTTP calls yourself, `/api/names?q=` returns name ideas and `/api/check?domain=` returns the due-diligence report; both have their own daily limits for anonymous callers. Single and batch availability lookups are documented on the [domain availability API page](https://domainsearchking.com/domain-availability-api).
