domain-whois-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@domain-whois-mcp whois lookup for example.com"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
domain-whois-mcp
Give your AI agent real-time domain intelligence. WHOIS, RDAP, availability checking, bulk lookups — all via native protocols, zero API keys.
An MCP server that lets Claude (and any MCP-compatible AI) look up domain registration data, check availability, and explore TLD infrastructure using the native WHOIS (RFC 3912) and RDAP (RFC 7482) protocols directly — no third-party APIs, no rate-limited web scrapers, no API keys.
Install
Claude Code — Marketplace (single command, auto-install)
This repo is its own Claude Code plugin marketplace. Add it in one step:
/plugin marketplace add kemalabuteliyte/domain-whois-mcp
/plugin install domain-whois-mcp@domain-whois-marketplaceOr in the Claude Code UI: /plugin > Browse marketplaces > Add marketplace > paste kemalabuteliyte/domain-whois-mcp > install domain-whois-mcp.
Claude Code — CLI (one command)
claude mcp add domain-whois -- npx -y github:kemalabuteliyte/domain-whois-mcpClaude Code — UI
Open Claude Code
Go to Settings (gear icon or
/settings)Navigate to MCP Servers
Click "Add MCP Server" (or "Add Custom Server")
Fill in:
Name:
domain-whoisCommand:
npxArguments:
-y github:kemalabuteliyte/domain-whois-mcp
Click Save
The server starts automatically — all 8 tools become available immediately.
Claude Code — JSON config
You can also add it directly to your project's .mcp.json:
{
"mcpServers": {
"domain-whois": {
"command": "npx",
"args": ["-y", "github:kemalabuteliyte/domain-whois-mcp"]
}
}
}Or to your user config at ~/.claude.json:
{
"mcpServers": {
"domain-whois": {
"command": "npx",
"args": ["-y", "github:kemalabuteliyte/domain-whois-mcp"]
}
}
}Claude Desktop
Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"domain-whois": {
"command": "npx",
"args": ["-y", "github:kemalabuteliyte/domain-whois-mcp"]
}
}
}Restart Claude Desktop after saving.
npm (after npm publish)
npm login
npm publish
# then anyone can install with:
claude mcp add domain-whois -- npx -y domain-whois-mcpThe npm package name domain-whois-mcp is available and reserved for this project.
Related MCP server: Domain Checker MCP Server
What's Inside
This is a full Claude Code plugin — not just an MCP connector. Installing it adds five surfaces:
Surface | What you get |
8 MCP tools |
|
4 skills |
|
4 slash commands |
|
1 agent |
|
2 hooks |
|
Finding a name for your next project
The headline workflow. Type:
/find-name ai invoicingThe project-name-finder skill (or the domain-strategist agent) will:
Brainstorm 15–30 candidates inspired by your concept.
Fan out across
.com .io .dev .ai .app .co— usually 100+ lookups.Run
bulk_domain_checkwith concurrency 5.Rank by
.comavailability, length, and multi-TLD coverage.Return a top-5 table:
Rank | Name | Available on | Why it works |
1 |
| .com, .io, .dev | 5 chars, memorable, available on all three |
2 |
| .io, .dev, .ai | short, pronounceable |
... | ... | ... | ... |
You can also just ask naturally — "I'm starting an AI invoicing SaaS, help me find a name" — and the skill triggers automatically.
What It Does
This MCP server gives your AI agent 8 tools for complete domain name intelligence:
Tool | What it does |
| Full WHOIS lookup via native TCP protocol. Returns parsed structured data (registrar, dates, nameservers, contacts) + raw text. Automatically follows referrals for complete data. |
| Modern RDAP lookup returning structured JSON. RDAP is the successor to WHOIS with better data quality. |
| Check if a domain is available for registration. Tries RDAP first (faster), falls back to WHOIS. |
| Check up to 50 domains at once with configurable parallelism (1-10 concurrent). Perfect for finding available names across TLDs. |
| Get information about any TLD from IANA — which WHOIS/RDAP servers handle it, registry details. |
| Send raw WHOIS queries to any server. Works for IP addresses, ASN lookups, and debugging. |
| Discover which WHOIS and RDAP servers handle a domain or TLD. |
| Browse the IANA RDAP bootstrap — see which TLDs support RDAP and their endpoints. |
How It Works Under the Hood
You ask Claude: "Is cool-startup.com available?"
│
┌─────▼──────┐
│ MCP Server │
└─────┬──────┘
│
┌───────────┼───────────┐
▼ ▼ ▼
┌──────────┐ ┌────────┐ ┌─────────┐
│ WHOIS │ │ RDAP │ │ IANA │
│ TCP:43 │ │ HTTPS │ │Registry │
└────┬─────┘ └───┬────┘ └────┬────┘
│ │ │
Raw socket to HTTP GET to Discovers
whois server rdap server servers for
on port 43 with JSON unknown TLDs
│ │ │
▼ ▼ ▼
┌──────────────────────────────┐
│ Parsed, structured result │
│ back to Claude │
└──────────────────────────────┘Built-in DB of 80+ known WHOIS servers is checked first (zero latency)
IANA discovery kicks in for unknown TLDs — queries
whois.iana.orgvia TCPRDAP bootstrap fetched from IANA and cached 24h for modern protocol lookups
Referral following — thin WHOIS (Verisign) automatically follows to thick registrar WHOIS
Smart parsing — 15+ "not found" patterns recognized across registries worldwide
Why It's Useful
For developers and startups
Find available domains — "Check if these 20 brand name variations are available across .com, .io, .dev, .ai"
Due diligence — "When does competitor.com expire? Who's their registrar?"
DNS debugging — "What nameservers does our domain point to? Is DNSSEC enabled?"
For domain investors
Bulk availability scanning — Check 50 domains in one shot with concurrent lookups
Expiry monitoring — Find expiration dates for domains you're watching
TLD research — Explore which TLDs support RDAP, find WHOIS servers for exotic ccTLDs
For security researchers
OSINT — Look up registration details, registrar info, domain status flags
Infrastructure mapping — Raw WHOIS queries for IP blocks, ASN lookups
Abuse investigation — Check domain registration patterns and history
For AI coding agents
Domain validation — Agents building web apps can verify domain configuration
Automated checks — CI/CD pipelines can verify domain status before deployments
Research automation — Agents doing competitive analysis can pull domain intel
Usage Examples with Claude
Once installed, just talk to Claude naturally:
Check availability:
"Is my-cool-app.com available? Also check .io and .dev"
Get WHOIS info:
"Look up the WHOIS for github.com — who's the registrar and when does it expire?"
Bulk check:
"I'm naming my startup 'Nexora'. Check nexora.com, nexora.io, nexora.dev, nexora.ai, nexora.co, getnexora.com, nexorahq.com"
TLD research:
"Which WHOIS server handles .tr domains? Does .ai support RDAP?"
Raw queries:
"Send a raw WHOIS query for 8.8.8.8 to whois.arin.net"
RDAP lookup:
"Get the RDAP data for cloudflare.com"
AI Coding Agent Integration
This MCP is designed to be used by autonomous coding agents (Claude Code, Cursor, Windsurf, or any MCP-compatible agent). Here's how agents can leverage it:
Agent Workflow: New Project Setup
Agent task: "Set up the domain and hosting for our new SaaS product"
1. Agent uses bulk_domain_check to find available domains
2. Agent uses whois_lookup to verify the chosen domain's status
3. Agent uses tld_info to check which protocols the TLD supports
4. Agent proceeds with DNS configuration knowing the domain landscapeAgent Workflow: Competitive Research
Agent task: "Research our top 5 competitors' web infrastructure"
1. Agent uses whois_lookup on each competitor domain
2. Extracts registrar, nameservers, creation dates
3. Uses rdap_lookup for structured data where available
4. Compiles infrastructure comparison reportAgent Workflow: Domain Portfolio Audit
Agent task: "Audit all our company domains and flag any expiring within 90 days"
1. Agent uses bulk_domain_check with all company domains
2. Parses expiration dates from results
3. Flags domains expiring soon
4. Generates renewal priority listProgrammatic Tool Usage (for agent developers)
Each tool accepts structured JSON parameters:
// whois_lookup
{ "domain": "example.com", "follow_referrals": true, "timeout": 15000 }
// bulk_domain_check
{ "domains": ["a.com", "b.io", "c.dev"], "concurrency": 5, "method": "auto" }
// whois_raw (for IP/ASN lookups)
{ "query": "AS13335", "server": "whois.radb.net" }Tool Reference
whois_lookup
Parameter | Type | Default | Description |
| string | required | Domain to look up (e.g., |
| string | auto | Override WHOIS server |
| boolean |
| Follow thin WHOIS referrals |
| number |
| Timeout in ms |
rdap_lookup
Parameter | Type | Default | Description |
| string | required | Domain to look up |
| string | auto | Override RDAP server URL |
| number |
| Timeout in ms |
domain_check
Parameter | Type | Default | Description |
| string | required | Domain to check |
|
|
| Lookup method |
| number |
| Timeout in ms |
bulk_domain_check
Parameter | Type | Default | Description |
| string[] | required | Domains to check (max 50) |
| number |
| Parallel lookups (1-10) |
|
|
| Lookup method |
| number |
| Per-domain timeout |
tld_info
Parameter | Type | Description |
| string | TLD without dot (e.g., |
whois_raw
Parameter | Type | Default | Description |
| string | required | Query string (domain, IP, ASN) |
| string | required | WHOIS server hostname |
| number |
| Server port |
| number |
| Timeout in ms |
find_whois_server
Parameter | Type | Description |
| string | Domain or TLD to find servers for |
rdap_bootstrap_info
Parameter | Type | Description |
| string | Optional: filter TLDs by substring |
Architecture
src/
├── index.ts # MCP server — 8 tools, stdio transport
├── whois-client.ts # Native WHOIS TCP client (RFC 3912)
│ # Referral following, TLD-specific query formats
├── whois-parser.ts # Parses WHOIS text → structured data
│ # 15+ not-found patterns, contact extraction
├── rdap-client.ts # RDAP HTTP client (RFC 7482/7483)
│ # IANA bootstrap, JSON response parsing
├── iana.ts # IANA TLD registry integration
│ # 80+ built-in servers, dynamic discovery, caching
└── types.ts # TypeScript interfacesZero external dependencies beyond the MCP SDK and Zod. WHOIS uses Node.js net module for raw TCP. RDAP uses built-in fetch. No WHOIS npm packages, no API wrappers.
Development
git clone https://github.com/kemalabuteliyte/domain-whois-mcp.git
cd domain-whois-mcp
npm install
npm run build # compile TypeScript → dist/
npm run dev # watch mode
node dist/index.js # run directlyProtocol Details
WHOIS (RFC 3912): Opens TCP to port 43, sends domain\r\n, reads until close. Handles TLD-specific formats (DENIC: -T dn,ace, JPRS: /e suffix, Verisign: domain prefix).
RDAP (RFC 7482/7483): HTTP GET to {server}/domain/{name} with Accept: application/rdap+json. Follows redirects. Returns structured JSON.
License
MIT
Available Tools
8 toolsbulk_domain_checkB
Check multiple domains for availability concurrently. Supports parallel processing with configurable concurrency. Useful for finding available domains across multiple TLDs or name variations.
Inputs: domains (required), method, timeout, concurrency.
domain_checkA
Check if a domain name is available for registration. Tries RDAP first (faster, structured), falls back to WHOIS. Returns availability status and full registration data if registered.
Inputs: domain (required), method, timeout.
find_whois_serverA
Discover the WHOIS and RDAP servers for a domain or TLD. Checks the built-in database first, then queries IANA for unknown TLDs. Returns both WHOIS and RDAP server information.
Inputs: domain (required).
rdap_bootstrap_infoA
Show the IANA RDAP bootstrap data — lists all TLDs that support RDAP and their service URLs. Useful for understanding RDAP coverage across TLDs.
Inputs: filter.
rdap_lookupA
Look up RDAP (Registration Data Access Protocol) information for a domain. RDAP is the modern successor to WHOIS, providing structured JSON responses. Automatically discovers the RDAP server via IANA bootstrap. Not all TLDs support RDAP — falls back with a clear error message.
Inputs: domain (required), server, timeout.
tld_infoA
Get information about a TLD (Top-Level Domain) from IANA. Returns the authoritative WHOIS server, RDAP server, and IANA registry data. Works for gTLDs (.com, .org), new gTLDs (.app, .xyz), and ccTLDs (.uk, .de).
Inputs: tld (required).
whois_lookupA
Look up WHOIS information for a domain name using native WHOIS protocol (TCP port 43). Automatically discovers the correct WHOIS server via IANA if not known. Follows referrals from thin WHOIS to thick WHOIS for complete data. Returns parsed structured data + raw WHOIS text.
Inputs: domain (required), server, timeout, follow_referrals.
whois_rawA
Send a raw WHOIS query to a specific server and return the unprocessed response. Useful for debugging, querying IP WHOIS (rwhois), or non-standard WHOIS servers.
Inputs: query (required), server (required), port, timeout.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 8 tools
Most tools are distinct (whois_lookup vs rdap_lookup vs domain_check), but find_whois_server, tld_info, and rdap_bootstrap_info overlap in surfacing server/bootstrap information and could be confused by an agent. whois_lookup and whois_raw also both query WHOIS, differing only in parsing and server targeting.
Names are uniformly snake_case but follow mixed patterns: whois_lookup/rdap_lookup use verb_noun, domain_check/bulk_domain_check use noun_check, while tld_info and rdap_bootstrap_info are noun phrases. The inconsistency is readable but not predictable across the set.
8 tools is well-scoped for a WHOIS/RDAP domain lookup server. Each tool covers a distinct protocol, use case, or operational need without unnecessary bloat.
The tool set covers WHOIS lookup, RDAP lookup, raw queries, server discovery, TLD metadata, single-domain availability, and bulk availability. This forms a complete surface for domain registration information and WHOIS/RDAP troubleshooting.
Maintenance
Related MCP Connectors
Domain intel for AI agents: RDAP registration, DNS, email deliverability, tech stack.
Domain intel for AI agents: RDAP registration, DNS, email deliverability, tech stack.
Free, no-API-key network lookups for AI agents — IP geolocation, DNS, WHOIS, HTTP and SSL/TLS certificate checks, and full domain health reports.
29 DNS, SEO, SSL, security, WHOIS & mail tools for AI agents. Pay per call (x402) or card API key.
Related MCP Servers
- AlicenseBqualityDmaintenanceEnables AI agents to perform WHOIS lookups to retrieve domain registration details, including ownership, registration dates, and availability status without requiring browser searches.482 npm22MIT
- AlicenseAqualityDmaintenanceEnables AI agents to check domain availability, perform batch domain lookups, and generate intelligent domain name suggestions across multiple TLDs using WHOIS integration.3MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to query registry RDAP services for domain, IP, ASN, entity, and nameserver registration records — including ccTLDs that IANA's bootstrap omits — with unregistered domains returned as answers rather than errors. Requires no authentication or API key.93 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables AI assistants to look up domain registration data through RDAP, including registration date, age, expiry, registrar, status, and nameservers.MIT