domain-mcp
Click on "Install 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-mcpcheck if example.com is available"
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-mcp
MCP server to check whether domain names are available or already registered.
Uses RDAP (structured registry JSON) first, with WHOIS fallback when a TLD has no RDAP endpoint. TLD coverage tracks the IANA RDAP bootstrap (~1,200 TLDs) plus community overrides (e.g. .de) and IANA WHOIS for the rest — not a hand-curated shortlist.
Disclaimer: “Available” means no registration record was found. It is not a purchase guarantee. Premium, reserved, or policy-blocked names may still be unregistrable. Confirm at a registrar before buying.
Features
MCP tools for single and bulk domain checks
RDAP-first lookups via whoisit
WHOIS fallback (IANA → registry, one referral hop)
IDN / punycode support
In-memory TTL cache
Remote hosted MCP + local stdio
Official Docker image on GHCR (versioned from GitHub Releases)
Docs in-repo (
docs/) synced to the GitHub Wiki
Related MCP server: mcp-server-dns
Hosted endpoint
https://domain.mcp.danielgtmn.com/mcpCheck | URL |
MCP | |
Health | |
Landing (browser) | |
Info (JSON) |
No install required for the hosted instance — only wire the URL (or a stdio bridge) into your client.
The previous host https://domain-mcp.gietmanic.com/mcp remains as an alias.
Install remote MCP (hosted)
Use the same endpoint everywhere:
https://domain.mcp.danielgtmn.com/mcpTip: After editing config, fully restart the client (quit + reopen). Some hosts only load MCP servers at startup.
Cursor
Open Cursor Settings → MCP (or edit the MCP config file).
Add:
macOS / Linux — ~/.cursor/mcp.json
Windows — %USERPROFILE%\.cursor\mcp.json
{
"mcpServers": {
"domain-mcp": {
"url": "https://domain.mcp.danielgtmn.com/mcp"
}
}
}Project-scoped alternative: .cursor/mcp.json in the repo root (same JSON).
Claude Desktop
Claude Desktop is primarily stdio-based. Bridge the remote URL with mcp-remote (requires Node.js 18+):
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json
{
"mcpServers": {
"domain-mcp": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://domain.mcp.danielgtmn.com/mcp"
]
}
}
}Restart Claude Desktop. On first run, npx downloads mcp-remote automatically.
Claude Code (CLI)
claude mcp add --transport http domain-mcp https://domain.mcp.danielgtmn.com/mcpList / remove:
claude mcp list
claude mcp remove domain-mcpVS Code (GitHub Copilot Chat / MCP)
Command Palette → MCP: Open User Configuration (or workspace
.vscode/mcp.json).Add a server entry:
{
"servers": {
"domain-mcp": {
"type": "http",
"url": "https://domain.mcp.danielgtmn.com/mcp"
}
}
}If your VS Code build uses the older mcpServers shape, this equivalent also works in many setups:
{
"mcp": {
"servers": {
"domain-mcp": {
"type": "http",
"url": "https://domain.mcp.danielgtmn.com/mcp"
}
}
}
}Windsurf (Codeium)
Edit Windsurf → Settings → Cascade → MCP or ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"domain-mcp": {
"serverUrl": "https://domain.mcp.danielgtmn.com/mcp"
}
}
}If serverUrl is ignored in your build, try the Cursor-style url key or the mcp-remote stdio bridge (same as Claude Desktop).
Cline / Roo Code (VS Code extension)
In the extension MCP settings (often cline_mcp_settings.json / Roo MCP config):
{
"mcpServers": {
"domain-mcp": {
"url": "https://domain.mcp.danielgtmn.com/mcp",
"disabled": false
}
}
}If the extension only supports command-based servers, use the mcp-remote bridge:
{
"mcpServers": {
"domain-mcp": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://domain.mcp.danielgtmn.com/mcp"],
"disabled": false
}
}
}Continue.dev
In ~/.continue/config.json (or assistant config), under mcpServers / experimental MCP:
{
"mcpServers": [
{
"name": "domain-mcp",
"type": "streamable-http",
"url": "https://domain.mcp.danielgtmn.com/mcp"
}
]
}Exact schema can vary by Continue version — if HTTP type is unsupported, use:
{
"name": "domain-mcp",
"command": "npx",
"args": ["-y", "mcp-remote", "https://domain.mcp.danielgtmn.com/mcp"]
}Zed
In ~/.config/zed/settings.json (MCP support depends on Zed version):
{
"context_servers": {
"domain-mcp": {
"command": {
"path": "npx",
"args": [
"-y",
"mcp-remote",
"https://domain.mcp.danielgtmn.com/mcp"
]
}
}
}
}JetBrains IDEs (AI Assistant / MCP plugins)
Prefer the stdio bridge (widest plugin support):
{
"mcpServers": {
"domain-mcp": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://domain.mcp.danielgtmn.com/mcp"]
}
}
}Paste into the plugin’s MCP server settings UI if it does not read a JSON file.
Generic / any stdio-only client
If the client only runs local processes:
npx -y mcp-remote https://domain.mcp.danielgtmn.com/mcpMap that command + args into the client’s MCP config the same way you would any other stdio server.
Optional API key
If the host sets DOMAIN_MCP_API_KEY, send a bearer token.
HTTP-native clients:
{
"mcpServers": {
"domain-mcp": {
"url": "https://domain.mcp.danielgtmn.com/mcp",
"headers": {
"Authorization": "Bearer YOUR_API_KEY"
}
}
}
}mcp-remote bridge:
{
"mcpServers": {
"domain-mcp": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://domain.mcp.danielgtmn.com/mcp",
"--header",
"Authorization: Bearer YOUR_API_KEY"
]
}
}
}(Header flag support depends on mcp-remote version; if unsupported, use a client with native headers.)
Quick matrix
Client | Recommended setup |
Cursor |
|
Claude Desktop |
|
Claude Code |
|
VS Code / Copilot |
|
Windsurf |
|
Cline / Roo |
|
Continue | streamable-http / |
Zed / JetBrains |
|
Other stdio-only |
|
Local install (stdio)
For offline use, development, or when you prefer a process on your machine.
From source
git clone https://github.com/danielgtmn/domain-mcp.git
cd domain-mcp
uv sync
uv run domain-mcpClient config (local)
{
"mcpServers": {
"domain-mcp": {
"command": "uv",
"args": [
"--directory",
"/absolute/path/to/domain-mcp",
"run",
"domain-mcp"
]
}
}
}Or the venv binary:
{
"mcpServers": {
"domain-mcp": {
"command": "/absolute/path/to/domain-mcp/.venv/bin/domain-mcp"
}
}
}Docker (self-host)
HTTP (remote-style URL on localhost):
docker pull ghcr.io/danielgtmn/domain-mcp:latest
docker run --rm -p 8000:8000 ghcr.io/danielgtmn/domain-mcp:latest
# → http://localhost:8000/mcpThen point any client at http://localhost:8000/mcp the same way as the hosted URL.
stdio:
docker run -i --rm -e MCP_TRANSPORT=stdio ghcr.io/danielgtmn/domain-mcp:latestMCP tools
Tool | Purpose |
| Check one domain (status, registrar, expiry, NS) |
| Bulk check (parallel, max 50 per call) |
| Registration-oriented lookup |
| TLDs with known RDAP endpoints |
| Clear the in-memory TTL cache |
Status values
Status | Meaning |
| No RDAP/WHOIS record → likely free |
| Registration found |
| Response could not be classified |
| No RDAP and WHOIS fallback failed |
| Bad domain syntax |
| Network / rate-limit / server error |
Supported TLDs
domain-mcp does not hardcode a small TLD list:
Path | Coverage |
RDAP | ~1,200 TLDs from IANA + overrides (e.g. |
WHOIS | Fallback via IANA |
Full wiki table (1,200+ TLDs + RDAP URLs):
docs/Supported-TLDs.md · Wiki · Supported-TLDs
Live list via tool list_supported_tlds. Regenerate docs:
uv run python scripts/generate_supported_tlds.pyHow it works
check_domain("foo.com")
→ normalize (IDN → punycode)
→ RDAP (IANA bootstrap + overrides)
├─ not found → available
├─ found → registered (+ metadata)
└─ no endpoint / error → WHOIS fallbackDocumentation
In-repo | |
Wiki (published from |
Page | Topic |
Source, Docker, verify | |
MCP client wiring | |
API reference | |
Coverage model | |
Internals | |
Tags & release pipeline | |
Caveats |
Wiki sync runs on every push to main that touches docs/ (workflow Publish Wiki). Enable Wikis in repo settings and create an initial wiki page once so the wiki remote exists.
Docker releases
Publishing a GitHub Release with tag vX.Y.Z builds a multi-arch image and pushes:
ghcr.io/danielgtmn/domain-mcp:X.Y.Z
ghcr.io/danielgtmn/domain-mcp:vX.Y.Z
ghcr.io/danielgtmn/domain-mcp:X.Y
ghcr.io/danielgtmn/domain-mcp:latest # stable releases onlyWorkflow: .github/workflows/release-docker.yml
Development
uv sync --group dev
uv run pytest
uv run ruff check src testsSee CONTRIBUTING.md.
Project layout
src/domain_mcp/
server.py # FastMCP tools (stdio + HTTP)
checker.py # RDAP + WHOIS orchestration
whois_fallback.py # Minimal WHOIS client
normalize.py # Validation / IDN
models.py # Result types
docs/ # → GitHub Wiki
.github/workflows/ # CI, wiki sync, release DockerLimitations
WHOIS text formats vary; classification is best-effort outside RDAP.
Registries rate-limit; keep bulk checks modest.
Some ccTLDs expose little public data.
Availability ≠ guaranteed registration at a given registrar.
Security
See SECURITY.md.
License
MIT © Daniel Gietmann
Available Tools
5 toolscheck_domainB
Check if a single domain is available or registered.
Args:
domain: Domain name to check (e.g. example.com, bücher.de).
include_raw: Include raw RDAP/WHOIS payload (verbose).
use_cache: Use in-memory TTL cache (default 5 minutes).
Returns:
Status (available/registered/unknown/…), registrar, dates, nameservers.
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes | ||
| use_cache | No | ||
| include_raw | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral disclosure burden. It discloses some behavior via the Args (use_cache = TTL cache with 5-minute default, include_raw = verbose payload) and Returns (status, registrar, dates, nameservers), which adds context. However, it does not disclose network latency considerations, rate-limit behavior, or what happens with unsupported TLDs, which could matter for a network-dependent checking tool with sibling list_supported_tlds.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise and well-structured with Args/Returns sections. The Args section repeats parameter names that already exist in the schema, but adds meaningful commentary with examples and defaults. Each line earns its place; no filler. Could be slightly tighter but is efficient overall.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a network-dependent tool with a an output schema, the description is decently complete: it covers inputs, outputs, and cache behavior. However, it lacks guidance on edge cases like invalid domains, unsupported TLDs (despite a sibling list_supported_tlds suggesting TLD awareness matters), and expected behavior when RDAP/WHOIS fails. The absence of annotations increases the burden the description must carry, and this falls slightly short for a tool with real-world network dependencies.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for all parameter meaning. It does explain each parameter: domain (with example including internationalized 'bücher.de'), include_raw (verbose), use_cache (in-memory TTL cache, 5 min default). While this adds value beyond the bare schema, the explanation is light — it doesn't detail return value structure for include_raw or how cache invalidation works, though the output schema partially mitigates this.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool checks if a single domain is available or registered, using a specific verb ('Check') with a resource ('single domain'). It distinguishes itself from the sibling check_domains (batch) by explicitly noting 'a single domain', providing differentiation. The Args section and Returns section add clarity to the purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions 'single domain' which implicitly differentiates from check_domains (batch), suggesting when to use this vs the batch tool. However, it doesn't explicitly state when NOT to use it or call out alternatives by name like domain_info or list_supported_tlds. Usage guidance is implied through the 'single domain' keyword rather than being explicit about exclusions or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_domainsA
Check multiple domains in parallel (rate-limit friendly bulk check).
Args:
domains: List of domain names (max recommended: 50 per call).
include_raw: Include raw payloads (large responses).
use_cache: Use in-memory TTL cache.
Returns:
Summary counts plus a results list in the same order as input.
| Name | Required | Description | Default |
|---|---|---|---|
| domains | Yes | ||
| use_cache | No | ||
| include_raw | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does well: it discloses that results are returned in input order (a key behavioral trait), that include_raw can produce 'large responses' (size concern), that caching is in-memory and TTL-based (implying cache can go stale), and notes parallel execution with rate-limit friendliness. This is richer behavioral context than typical.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded: the first line states the core purpose and key differentiator (parallel bulk check, rate-limit friendly). The Args section uses clear docstring formatting, and the Returns line is a single efficient sentence. Every sentence earns its place with no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has an output schema that documents the return structure, so the Returns line adequately summarizes. The three parameters are all documented in the Args section with useful detail. Given the moderate complexity (bulk parallel operation with caching and raw payload options), the description covers the essential behavioral and usage context well, though it could note potential cache-staleness implications of use_cache.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must compensate for all three parameters, and it does reasonably well: domains has a max-recommended count, include_raw signals size tradeoff via 'large responses', and use_cache is described as 'in-memory TTL cache'. This adds meaningful semantic context beyond the bare schema titles, though it lacks nuance on what 'raw' actually contains.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool checks multiple domains in parallel, distinguishing it as a bulk operation. However, it doesn't explicitly differentiate from the sibling 'check_domain' beyond the plural/bulk implication, nor does it state what 'check' means (availability, DNS, WHOIS, etc.) — the verb 'check' remains ambiguous about the specific domain attribute being verified.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description notes it's 'rate-limit friendly' and specifies a max recommended 50 domains per call, which gives useful context for when to prefer this bulk tool. However, it doesn't explicitly state when to use check_domains vs the single check_domain sibling, nor when to toggle include_raw or use_cache — the when/when-not guidance for these params is implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
clear_domain_cacheC
Clear the in-memory domain check cache.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden of behavioral disclosure. The description states the action (clear cache) but doesn't disclose side effects—does this invalidate domain checks for all domains? Does it require privileges? Is there any persistence impact? With zero annotations, this is under-specified for a mutating tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single clear sentence with no waste. It's appropriately brief for a zero-parameter tool. Could arguably benefit from one additional clause explaining when to invoke, but the current form is efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
While an output schema exists, this is a mutating cache-clearing operation with no annotations and no usage guidance. For a tool with side effects, additional context (side effects, prerequisites, frequency of need) would meaningfully improve agent decision-making. The current description is bare-minimum.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are 0 parameters, and schema description coverage is 100%. The baseline for 0 params is 4 since there is nothing for the description to compensate for. The description adds nothing beyond what's needed, and none is required.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states it clears the in-memory domain check cache, giving a clear verb and resource (clear + cache). However, it doesn't distinguish clearly from siblings—given sibling tools are check_domain, domain_info, etc., the cache-clearing purpose is reasonably distinct, but the description doesn't explain what the cache is used for or why an agent might want to clear it.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool. It doesn't explain scenarios (e.g., after updates to domain rules, when stale check results are observed) or when NOT to use it. For a cache-clearing maintenance tool with no schema parameters, usage context is entirely absent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
domain_infoA
Get registration details for a domain (registrar, expiry, nameservers).
Same underlying check as check_domain; prefer this when you need WHOIS-like
metadata for a domain you already know is registered.
Args:
domain: Domain name to look up.
include_raw: Include raw RDAP/WHOIS payload.
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes | ||
| include_raw | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden. It discloses the check is the same underlying as check_domain and mentions the optional include_raw flag behavior. However, it doesn't describe the output format, error behavior for unregistered domains, rate limits, or what fields populate when include_raw is false. Adequate but sparse for an unannotated tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact paragraphs plus a structured Args list. Front-loaded with purpose, then usage guidance, then parameters. Every sentence earns its place with zero filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 2-parameter tool with an output schema present and decent description coverage, this is reasonably complete. The description explains the tool's purpose, its relationship to check_domain, and parameter intent. Could add error handling or unregistered-domain behavior, but given the tool's simplicity and output schema availability, the coverage is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so neither schema nor description documents parameter semantics beyond names. The description mentions 'domain' and 'include_raw' in the Args section but only restates what the names imply—no format hints, no example values, no types beyond the schema defaults. The description adds minimal meaning beyond the parameter names.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it retrieves registration details (registrar, expiry, nameservers) for a domain. It explicitly differentiates from check_domain by noting they share the same underlying check but this tool is preferred for WHOIS-like metadata on already-registered domains. Verb+resource+scope are all specific.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to prefer this tool ('prefer this when you need WHOIS-like metadata for a domain you already know is registered') and names the alternative (check_domain). Lacks an explicit 'when not to use' clause, but the positive guidance and sibling differentiation are clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_supported_tldsA
List TLDs with known RDAP endpoints (IANA bootstrap + overrides).
TLDs missing from this list may still work via WHOIS fallback.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses that the list is not exhaustive (via WHOIS fallback note), which is useful behavioral context about coverage limitations. However, it doesn't describe return format, ordering, or whether this reflects real-time vs cached data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences with zero waste. Front-loaded with the core purpose, followed by one useful caveat. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is a simple read-only list with no parameters and an output schema available. The description covers the essential purpose and a critical caveat (WHOIS fallback). An output schema exists, so return values don't need description. Slightly more behavioral context (caching, freshness) could push it higher.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, so schema coverage is 100% and there are no parameters to document. The description reasonably describes what is being listed without needing to explain parameter syntax, satisfying the baseline 4 for a zero-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'List TLDs with known RDAP endpoints (IANA bootstrap + overrides)' — a specific verb (list) and specific resource (TLDs with known RDAP endpoints) with scoping detail. The mention of IANA bootstrap + overrides distinguishes scope from a generic TLD listing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly notes that 'TLDs missing from this list may still work via WHOIS fallback', providing important context about when this list is not exhaustive. It doesn't explicitly state when to prefer this over siblings, but the fallback caveat gives useful usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
5 tool updates
v0.1.0- First observed
check_domain - First observed
check_domains - First observed
clear_domain_cache - First observed
domain_info - First observed
list_supported_tlds
TDQS
The tools are mostly distinct: check_domain and check_domains are clearly single vs bulk variants, while domain_info is differentiated by its stated purpose (metadata for known-registered domains). However, check_domain and domain_info perform essentially the same underlying check, which could cause mild misselection; the description mitigates this but the overlap is real.
The naming follows a consistent verb_noun pattern (check_domain, check_domains, domain_info, list_supported_tlds, clear_domain_cache). Minor deviation: domain_info uses 'info' rather than a clearer verb like 'get_domain_info', breaking the otherwise clean pattern, and clear_domain_cache uses an adjective+noun rather than object-first.
Five tools is within the ideal 3-15 range and appropriate for a domain-checking server. The count feels slightly trimmed—check_domain and domain_info are near-duplicates, suggesting one could be folded into the other—but the overall scope is reasonably well served.
The server covers checking, bulk checking, metadata lookup, TLD discovery, and cache management, covering the core domain-lookup workflows well. Minor gaps exist: there is no tool for WHOIS-style detailed records beyond raw payloads, and no capability to register or manage domains (if that were in scope). For pure lookups, the surface is complete.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
MCP server for DNSimple — domains, DNS zone records, availability, pricing and contacts.
Check domain name availability via RDAP. Single, bulk, and smart suggestions. No API key needed.
Public MCP server for summaries, DNS lookup, catalog, replies, and JSON checks.
Domains MCP — domain registration lookup + availability search over live
Related MCP Servers
- AlicenseAqualityDmaintenanceA Model Context Protocol (MCP) server that provides comprehensive domain name research tools, including RDAP, WHOIS, and DNS query functionality.12Apache 2.0
- AlicenseAqualityDmaintenanceMCP server for DNS lookups, reverse DNS, WHOIS, and domain checks. Zero auth, zero config.5593MIT
- FlicenseNot gradedqualityNot gradedmaintenanceAn MCP server for domain availability checks, WHOIS lookups, and domain suggestions using RDAP and TCP port 43. It allows users to perform bulk checks and retrieve registration details across multiple TLDs without requiring an API key.43-
- AlicenseNot gradedqualityDmaintenanceAn MCP server for domain management, enabling domain availability checks, bulk domain checks, and API connectivity testing through the RealtimeRegister API.191MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/danielgtmn/domain-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server