Skip to main content
Glama
danielgtmn

domain-mcp

by danielgtmn

domain-mcp

CI License: MIT Python 3.11+ MCP GHCR

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/mcp

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/mcp

Tip: After editing config, fully restart the client (quit + reopen). Some hosts only load MCP servers at startup.

Cursor

  1. Open Cursor Settings → MCP (or edit the MCP config file).

  2. 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/mcp

List / remove:

claude mcp list
claude mcp remove domain-mcp

VS Code (GitHub Copilot Chat / MCP)

  1. Command Palette → MCP: Open User Configuration (or workspace .vscode/mcp.json).

  2. 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/mcp

Map 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

"url": "https://domain.mcp.danielgtmn.com/mcp"

Claude Desktop

npx mcp-remote bridge

Claude Code

claude mcp add --transport http …

VS Code / Copilot

"type": "http" + url

Windsurf

serverUrl or url

Cline / Roo

url or mcp-remote

Continue

streamable-http / mcp-remote

Zed / JetBrains

mcp-remote bridge

Other stdio-only

npx -y mcp-remote <url>


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-mcp

Client 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/mcp

Then 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:latest

MCP tools

Tool

Purpose

check_domain

Check one domain (status, registrar, expiry, NS)

check_domains

Bulk check (parallel, max 50 per call)

domain_info

Registration-oriented lookup

list_supported_tlds

TLDs with known RDAP endpoints

clear_domain_cache

Clear the in-memory TTL cache

Status values

Status

Meaning

available

No RDAP/WHOIS record → likely free

registered

Registration found

unknown

Response could not be classified

unsupported

No RDAP and WHOIS fallback failed

invalid

Bad domain syntax

error

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. .de)

WHOIS

Fallback via IANA whois: referral for most other TLDs

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.py

How it works

check_domain("foo.com")
    → normalize (IDN → punycode)
    → RDAP (IANA bootstrap + overrides)
         ├─ not found  → available
         ├─ found      → registered (+ metadata)
         └─ no endpoint / error → WHOIS fallback

Documentation

In-repo

docs/

Wiki (published from docs/)

https://github.com/danielgtmn/domain-mcp/wiki

Page

Topic

Installation

Source, Docker, verify

Configuration

MCP client wiring

Tools

API reference

Supported TLDs

Coverage model

Architecture

Internals

Docker

Tags & release pipeline

FAQ

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 only

Workflow: .github/workflows/release-docker.yml

Development

uv sync --group dev
uv run pytest
uv run ruff check src tests

See 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 Docker

Limitations

  • 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 tools
check_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.
ParametersJSON Schema
NameRequiredDescriptionDefault
domainYes
use_cacheNo
include_rawNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.2/5.0
Behavior3/5

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.

Conciseness4/5

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.

Completeness3/5

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.

Parameters2/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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.
ParametersJSON Schema
NameRequiredDescriptionDefault
domainsYes
use_cacheNo
include_rawNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A3.9/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

C2.8/5.0
Behavior2/5

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.

Conciseness4/5

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.

Completeness2/5

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.

Parameters4/5

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.

Purpose3/5

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.

Usage Guidelines2/5

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.
ParametersJSON Schema
NameRequiredDescriptionDefault
domainYes
include_rawNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

A4.2/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

  1. 5 tool updatesv0.1.0
    • First observedcheck_domain
    • First observedcheck_domains
    • First observedclear_domain_cache
    • First observeddomain_info
    • First observedlist_supported_tlds

TDQS

A3.5/5.0
Disambiguation4/5

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.

Naming Consistency4/5

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.

Tool Count4/5

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.

Completeness4/5

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

ActivityMaintained
ResponsivenessNo issues

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

Related MCP Servers

  • A
    license
    A
    quality
    D
    maintenance
    A Model Context Protocol (MCP) server that provides comprehensive domain name research tools, including RDAP, WHOIS, and DNS query functionality.
    1
    2
    Apache 2.0
  • F
    license
    Not graded
    quality
    Not graded
    maintenance
    An 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
    -

Latest Blog Posts

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