Domain Search Mcp
About
Check domain availability and pricing across Porkbun, Namecheap, RDAP, WHOIS. Includes social handle checking for 10 platforms.
Details
- Author
- dorukardahan
- Downloads
- 451
- Categories
- Search, Other, API
Jump to
- Multi-source search across Porkbun, Namecheap, RDAP, WHOIS
- Price comparison across registrars
- Over 50 TLD support including .com, .io, .dev, .ai
- Social handle checking for GitHub, Twitter, npm, and more
- Premium domain detection with pricing insights
- Expiration tracking for taken domains
Setting up with Highlight
This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:
- Download and install Highlight from highlightai.com/download
- Navigate to the plugins tab and select "Add Custom Plugin"
-
Configure the plugin with the settings below
Plugin Name
Domain Search McpCommand (node, npx, python, etc.)Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
- Enable "Start Automatically" if you want the plugin to start when Highlight launches
From the repository
Install by running npx -y domain-search-mcp in your terminal. It works with any MCP-compatible client; no additional configuration is required beyond the standard client setup.
search_domain
Search for domain availability and pricing across multiple TLDs. Returns: - Availability status for each domain - Pricing (first year and renewal) - Whether WHOIS privacy is included - Human-readable insights and next steps Examples: - search_domain("vibecoding") → checks vibecoding.com, .io, .dev - search_domain("myapp", ["com", "io"]) → checks specific TLDs
bulk_search
Check availability for multiple domain names at once. Efficiently searches up to 100 domains in parallel with rate limiting. Use a single TLD for best performance. Returns: - Availability status for each domain - Pricing where available - Summary statistics Example: - bulk_search(["vibecoding", "myapp", "coolstartup"], "io")
compare_registrars
Compare domain pricing across multiple registrars. Checks the same domain at different registrars to find: - Best first year price - Best renewal price - Overall recommendation Returns pricing comparison and a recommendation. Example: - compare_registrars("vibecoding", "com") → compares Porkbun vs Namecheap
suggest_domains
Generate and check availability of domain name variations. Creates variations like: - Hyphenated: vibe-coding - With numbers: vibecoding1, vibecoding2 - Prefixes: getvibecoding, tryvibecoding - Suffixes: vibecodingapp, vibecodinghq Returns only available suggestions, ranked by quality. Example: - suggest_domains("vibecoding") → finds available variations
suggest_domains_smart
AI-powered domain name suggestion engine. Generate creative, brandable domain names from keywords or business descriptions. Combines our semantic engine with GoDaddy's AI suggestions for maximum coverage. Features: - Dual-source suggestions: Our semantic engine + GoDaddy AI - Understands natural language queries ("coffee shop in seattle") - Auto-detects industry for contextual suggestions - Generates portmanteau/blended names (instagram = instant + telegram) - Applies modern naming patterns (ly, ify, io, hub, etc.) - Filters premium domains by default - Pre-verified availability via GoDaddy Examples: - suggest_domains_smart("ai customer service") → AI-themed suggestions - suggest_domains_smart("organic coffee", industry="food") → Food-focused names - suggest_domains_smart("vibecoding", style="short") → Minimal length names
tld_info
Get information about a Top Level Domain (TLD). Returns: - Description and typical use case - Price range - Any special restrictions - Popularity and recommendations Example: - tld_info("io") → info about .io domains
check_socials
Check if a username is available on social media and developer platforms. Supports 10 platforms with varying confidence levels: - HIGH: GitHub, npm, PyPI, Reddit, Twitter/X (reliable public APIs) - MEDIUM: YouTube, ProductHunt (status code based) - LOW: Instagram, LinkedIn, TikTok (block automated checks - verify manually) Returns availability status with confidence indicator. Example: - check_socials("vibecoding") → checks GitHub, Twitter, Reddit, npm - check_socials("myapp", ["github", "npm", "pypi"]) → developer platforms only
Claude Desktop / Cursor
Paste into your MCP client config file to install this server.
{
"mcpServers": {
"domain search mcp": {
"domain-search": {
"command": "npx",
"args": [
"-y",
"domain-search-mcp"
]
}
}
}
}
McpServers
{
"domain-search": {
"command": "npx",
"args": [
"-y",
"domain-search-mcp"
]
}
}
Naming engine with availability intelligence— an MCP server that scores the names your model generates and runs availability checks against domains, socials, and package registries. Works with zero configuration using public RDAP/WHOIS, and optionally enriches results with registrar pricing via a backend you control.
🆕 v1.12.0:name_project— a two-phase naming engine. Call it once to get generation instructions for your model, call it again withcandidates[]to get anti-slop scoring, ranking, and live availability checks across domains, socials, and npm. Seename_projectbelow.
🆕 v1.10.0: GoDaddy public endpoint integration! Enhanced fallback chain (RDAP → GoDaddy → WHOIS) with premium/auction domain detection. Circuit breaker pattern ensures resilience.
🤖 v1.9.0+: AI-powered domain suggestions work out of the box! No API keys needed -suggest_domains_smartuses our public fine-tuned Qwen 7B-DPO model. Plus: Redis distributed caching and/metricsendpoint for observability.
Built on theModel Context Protocolfor Claude, Codex, VS Code, Cursor, Cline, and other MCP-compatible clients.
- Check a single name across multiple TLDs.
- Bulk-check up to 100 names for one TLD.
- Compare registrar pricing (uses backend when configured).
- Suggest names and validate social handles.
- Detect premium/auction signals forsearch_domain.
Availability and pricing are intentionally separated:
Availability Chain (zero-config): ┌─────────┐ ┌─────────┐ ┌─────────┐ │ RDAP │ ──► │ GoDaddy │ ──► │ WHOIS │ │ (fast) │ │(premium)│ │(fallback│ └─────────┘ └─────────┘ └─────────┘
- Availability(default, no keys needed):
- RDAP: Primary source - fast, unlimited, public registry data
- GoDaddy: Secondary - adds premium/auction detection (30 req/min, circuit breaker protected)
- WHOIS: Last resort fallback for edge cases
- Recommended:PRICING_API_BASE_URL(backend with Porkbun keys)
- Optional BYOK: Porkbun/Namecheap only when backend is not configured
This keeps the server zero-config while letting power users enable pricing.
Responses includeprice_check_url(registrar checkout/search link) and may includeprice_notewhen a price is estimated. Always verify the final price on the registrar checkout page before purchase.
If an auction/premium signal is detected, results include anaftermarketblock with links to marketplace pages when available. Taken domains may include Sedo auction hints (public feed) and nameserver-based marketplace hints (Sedo/Dan/Afternic).
git clone https://github.com/dorukardahan/domain-search-mcp.git cd domain-search-mcp npm install npm run build npm start
For MCP clients like Claude Desktop, Cursor, VS Code - uses stdin/stdout:
HTTP/SSE (ChatGPT, Web Clients, LM Studio)
For ChatGPT Actions, web apps, and REST API clients:
# Start HTTP server on port 3000 npx -y domain-search-mcp@latest --http # Or with custom port MCP_PORT=8080 npx -y domain-search-mcp@latest --http
- /mcp- MCP protocol (POST for messages, GET for SSE stream)
- /api/tools/- REST API for each tool (ChatGPT Actions compatible)
- /openapi.json- OpenAPI 3.1 specification
- /health- Health check
- /metrics- Prometheus-compatible metrics (cache stats, request counts, AI inference health)
- Start the HTTP server (see above)
- Expose via ngrok:ngrok http 3000
- In ChatGPT, create a Custom GPT and add an Action
- Import the OpenAPI spec fromhttps://your-ngrok-url.ngrok-free.dev/openapi.json
- Test the tools!
For production deployment, use a permanent domain with SSL instead of ngrok.
curl -X POST https://your-domain/api/tools/search_domain \ -H "Content-Type: application/json" \ -d '{"domain_name":"vibecoding"}'
Claude Code(.mcp.jsonin project root):
{ "mcpServers": { "domain-search": { "type": "stdio", "command": "npx", "args": ["-y", "domain-search-mcp@latest"] } } }
Claude Desktop(claude_desktop_config.json):
{ "mcpServers": { "domain-search": { "command": "npx", "args": ["-y", "domain-search-mcp@latest"] } } }
💡 Tip: Always use@latestto ensure you're running the newest version with all features.
All 12 tools listed below are exposed to MCP clients by default. The 6-tool slim profile (name_project,search_domain,bulk_search,check_socials,tld_info,ai_health) is opt-in — setSLIM_TOOLS=trueif you want a sharper tool-selection surface for simpler client integrations (seeEnvironment Variables). A future 2.0 release may flip the default to slim.
ADVANCED_TOOLS=trueis a deprecated alias that forces the full surface and overridesSLIM_TOOLS; it's a harmless no-op today since full is already the default.
Flagship two-phase naming engine.Call it once to get lane-by-lane generation instructions foryourmodel; call it again withcandidates[]to get anti-slop scoring, ranking, and live availability checks across domains, socials, and npm.
- Modes:brief(describe what you're naming),auto(analyze the current workspace),from_name(find domains/variants for a name you already like),from_domain(fit a project/brand to a domain you found).
- Phase 1(nocandidates): returns generation instructions + lane prompts.
- Phase 2(candidatespresent): scores + ranks candidates, then checks availability for the top 12 againsttargets.tlds/targets.platforms— omittargetsfor pure naming with no availability calls.
Scores are heuristic rankings for comparing candidates against each other — not objective, universal brandability truth. Availability results reflect a single source checked at one moment in time; re-verify before you register or rely on anything.
{"mode": "brief", "brief": "an MCP naming engine"}
Brief: an MCP naming engine Now generate between 30 and 50 name candidates spread across these lanes: - [evocative] Real words borrowed for their feeling, not their meaning (like Slack, Notion, Bolt). Single dictionary words preferred. - [invented] Coined words that do not exist but sound like they could (like Zapier, Klarna). Must be pronounceable on first read. - [compound] Two short real words fused (like Facebook, Snapchat). Both halves must stay readable; no glue letters. - [premium] Short, expensive-feeling names: 4-7 letters, strong single or double syllable (like Stripe, Vercel, Arc). Rules: single words or tight compounds, no taglines, no explanations yet. Then call name_project again with the SAME arguments plus candidates:[...] to get scoring and availability.
Phase 2— resubmit the same arguments pluscandidates:
{"mode": "brief", "brief": "an MCP naming engine", "candidates": ["Nexify", "Corda"]}
| Name | Score | Verdict | Badges | Why | | --- | --- | --- | --- | --- | | Corda | 97 strong | - | - | no AI-slop patterns; clean pronunciation and typing | | Nexify | 60 middling | - | - | slop: overused prefix "nex-"; slop: overused suffix "-ify" | 2 candidates received, 2 passed constraints, top 2 returned. No availability-check targets - pure naming mode.
Badges:tld✓free to register,tld$for sale (aftermarket/premium - registered or priced, not free to register),tld✗taken,tld?unknown. ccTLD checks (.ai/.io/.sh/.ac) are cross-checked against native WHOIS/DNS ground truth, not taken on RDAP's word alone.
Seedocs/API.mdfor the full parameter/response schema.
- search_domain: Check a name across multiple TLDs, adds premium/auction signals.
- bulk_search: Check up to 100 names for a single TLD.
- compare_registrars: Compare pricing across registrars (backend when configured).
- suggest_domains: Generate variations (prefix/suffix/hyphen).
- suggest_domains_smart:🤖 AI-poweredbrandable name generation using fine-tuned Qwen 7B-DPO. Zero-config - works instantly!
- analyze_project: Scan local project or GitHub repo to extract context and suggest matching domain names.
- hunt_domains: Find valuable domains for investment - scans Sedo auctions, generates patterns, calculates investment scores.
- expiring_domains: Monitor domains approaching expiration (requires federated negative cache).
- tld_info: TLD metadata and restrictions.
- check_socials: Username availability across platforms.
- ai_health: Check status of AI inference services (VPS Qwen, circuit breakers, adaptive concurrency).
Set a backend URL that owns registrar keys (Porkbun). The MCP will call/api/quoteand/api/compareon that backend for pricing.
PRICING_API_BASE_URL=https://your-backend.example.com PRICING_API_TOKEN=optional_bearer_token
Used only ifPRICING_API_BASE_URLis not set.
- Porkbun keys:
- https://porkbun.com/account/api
- https://porkbun.com/api/json/v3/documentation
- https://ap.www.namecheap.com/settings/tools/apiaccess/
- https://www.namecheap.com/support/api/intro/
PORKBUN_API_KEY=pk1_your_api_key PORKBUN_API_SECRET=sk1_your_secret NAMECHEAP_API_KEY=your_api_key NAMECHEAP_API_USER=your_username NAMECHEAP_CLIENT_IP=your_whitelisted_ip
For horizontal scaling across multiple MCP instances, configure Redis:
Without Redis, the server uses in-memory caching (works fine for single instances). Redis enables:
- Shared cache across multiple server instances
- Persistent cache surviving restarts
- Better cache hit rates in load-balanced deployments
AI-powered suggestions (suggest_domains_smart) use your own inference endpoint when configured. PointQWEN_INFERENCE_ENDPOINTat a llama.cpp/Qwen server you control. If it is unset, suggestions fall back to the built-in offline semantic engine (no external calls, no API keys needed).
# Public hosts must use HTTPS; loopback/private hosts may use HTTP. QWEN_INFERENCE_ENDPOINT=http://127.0.0.1:8070 QWEN_API_KEY=optional_if_secured
Tool responses are returned asMarkdown tables by default. If you need raw JSON for programmatic use, set:
- Live price is attempted first for everyavailabledomain.
- If live quotes fail or are rate-limited, the result falls back to the catalog estimate and includesprice_note.
- Always verify pricing viaprice_check_urlbefore purchase.
search_domain("myproject", ["com", "io", "dev"]) ┌─────────────────┬───────────┬─────────┬────────┐ │ Domain │ Available │ Premium │ Source │ ├─────────────────┼───────────┼─────────┼────────┤ │ myproject.com │ ✅ │ No │ rdap │ │ myproject.io │ ❌ │ - │ rdap │ │ myproject.dev │ ✅ │ Yes │ godaddy│ └─────────────────┴───────────┴─────────┴────────┘
suggest_domains_smart("coffee shop in seattle", { style: "brandable" }) → seattlebrew.com, pugetperk.io, raincitycoffee.co, cascadiacafe.com
bulk_search(["startup", "launch", "begin", "init"], "io") → Checks startup.io, launch.io, begin.io, init.io in parallel
npm run dev # watch mode npm test # run Jest npm run build # compile to dist/
Seedocs/RELEASE.mdfor the tag-triggered release flow. Version tags trigger the GitHub Release, npm trusted publishing with provenance, and MCP Registry publication through GitHub Actions.
- Do not commit API keys or.mcpregistry_files.
- WithoutPRICING_API_BASE_URL(or BYOK keys), pricing is not available (availability still works).
If you usenpx domain-search-mcp(without@latest), npx may cache an old version.
Fix: Update your MCP config to use@latest:
"args": ["-y", "domain-search-mcp@latest"]
npx clear-npx-cache # then restart your MCP client
cd domain-search-mcp git pull origin main npm install npm run build
- Watch the repo: Click "Watch" → "Releases only" onGitHubto get notified of new versions.
- Check releases: SeeGitHub Releasesfor changelog and upgrade notes.
- npm page:npmjs.com/package/domain-search-mcpshows the latest version.
For detailed system architecture diagrams, seedocs/ARCHITECTURE.md:
- Transport layer (stdio vs HTTP/SSE)
- Tool execution flow
- Data source waterfall (RDAP → Pricing API → WHOIS)
- VPS deployment architecture
- AI suggestion flow
- MCP session lifecycle
Q: Does this work without any API keys?A: Yes! Availability checking uses public RDAP and GoDaddy endpoints. Only pricing requires API keys.
Q: Which MCP clients are supported?A: Claude Desktop, Claude Code, VS Code, Cursor, Cline (stdio), and ChatGPT, LM Studio (HTTP/SSE).
Q: How accurate is premium domain detection?A: GoDaddy's public endpoint detects most premium and auction domains. Always verify on registrar checkout.
Q: Can I self-host the AI suggestions?A: Yes! SetQWEN_INFERENCE_ENDPOINTto your llama.cpp server running the fine-tuned model.
- npm:npmjs.com/package/domain-search-mcp
- MCP Registry:registry.modelcontextprotocol.io
- Glama:glama.ai/mcp/servers/@dorukardahan/domain-search-mcp
- Context7:context7.com/dorukardahan/domain-search-mcp
- Architecture- System design and data flow
- API Reference- Tool schemas and responses
- Configuration- Environment variables
- Workflows- Common usage patterns
Search global news using natural language. Webz.io News Search API returns the most relevant articles and content, with filters for source, country, language, date, sentiment, and category.
Search the web using Kagi's search API
Multi-provider search broker for AI agents. Routes across SearXNG, Brave, Serper, Tavily, and Exa with automatic fallback, RRF ranking, content extraction, and budget enforcement.
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.




