Use NamingSignal from Claude Code

Step 1: Create a free API key

Sign in at namingsignal.com (free account, no card) and create a key at namingsignal.com/developers/keys. Keys are user-owned and individually revocable, so create one key per client: one for Claude Code, another for CI, another for a teammate's machine. Revoking one never signs the others out.

The free plan includes 15,000 Naming Credits per UTC calendar month, shared across the web app, REST API, CLI, and MCP.

Step 2: Add the remote MCP server

NamingSignal runs a remote Streamable HTTP MCP server at https://namingsignal.com/mcp. Add it to Claude Code with your key in the Authorization header:

claude mcp add --transport http naming-signal https://namingsignal.com/mcp \
  --header "Authorization: Bearer YOUR_NAMINGSIGNAL_KEY"

Add --scope user to make the server available in every project, or --scope project to share it with a team through a checked-in .mcp.json. If you prefer the file directly, this project-level .mcp.json is equivalent and reads the key from the NAMING_SIGNAL_API_KEY environment variable instead of hardcoding it:

{
  "mcpServers": {
    "naming-signal": {
      "type": "http",
      "url": "https://namingsignal.com/mcp",
      "headers": {
        "Authorization": "Bearer ${NAMING_SIGNAL_API_KEY}"
      },
      "timeout": 600000
    }
  }
}

No local install is needed for the remote server. Prefer a local process? The same server ships on npm: claude mcp add naming-signal --env NAMING_SIGNAL_API_KEY=YOUR_KEY -- npx -y @namingsignal/mcp. The CLI is @namingsignal/cli.

Step 3: Run a first sprint

Paste a prompt like this into Claude Code:

Use the naming-signal MCP server. Compile a naming brief from this description:
"<one sentence about the product, its user, and the painful job it solves>".
Show me the brief and wait for my corrections. Then run create_naming_sprint
with count 40 and TLDs com and dev, and summarize the registry survivors with
their evidence states, sources, and check dates. Treat unknown as unknown,
never as available.

Claude will call compile_project_brief, show you the brief for corrections, then run the sprint. Expect a 40-name sprint with domain checks to take a minute or two; the server streams progress notifications so Claude Code can show that work is still moving.

What the five tools do

• compile_project_brief: Turns a sentence, prompt, or README into an editable naming brief with explicit unknowns, before any generation happens.
• create_naming_sprint: Generates a candidate field (40 for a feedback round, 100 to 200 for an initial sprint), checks every selected domain ending, and returns registry survivors first. Streams MCP progress notifications while it works.
• check_names: Exact domain checks, and optional developer-namespace checks, for names you already have. Compact evidence lines by default.
• analyze_candidates: Deeper source-backed research for one to three finalists: namesakes, namespaces, preliminary trademark starting points, and explicit manual actions.
• get_purchase_links: Exact-domain registrar search links for manual verification. The server never purchases, reserves, or registers anything.

Every tool is annotated read-only. Output is compact JSON by default (one text block, no duplicated structured content); pass verbose: true only when you need full evidence objects, because verbose payloads are much larger in an agent context.

Timeouts for long sprints

Large sprints (100 to 200 names across several TLDs) can run for minutes in one tool call. Two Claude Code settings matter:

• The per-server timeout field in .mcp.json is a hard wall-clock limit per tool call, in milliseconds. The example above sets 600000 (ten minutes). Setting it to 60,000 or higher also raises Claude Code's per-request timer for HTTP servers, which otherwise waits only 60 seconds for the first response byte.
• The MCP_TOOL_TIMEOUT environment variable sets the same limit globally when no per-server value exists.

The hosted endpoint bounds a single call at 300 seconds. For very large runs, start with a 40-name sprint, review survivors, and iterate with feedback rather than pushing one maximum-size call.

What a typical sprint costs

Every metered operation is priced in Naming Credits, and GET /api/v1/health publishes the live schedule so agents can read the same numbers the meter uses.

How an agent should read the evidence

• likely_available is a calibrated registry signal at a point in time, never a guarantee of registrar purchaseability or price.
• Timeouts, rate limits, unsupported TLDs, and failed calibration stay unknown. Never summarize unknown as available.
• Registrar verification is a manual final step; use the verifyUrl the tools return.
• Trademark output is preliminary research, never legal clearance.
• Report hard blockers separately from scores; a good average does not erase a disqualifying collision.

Working from Codex instead? See the Codex quickstart. For the REST contract behind these tools, read the API documentation.