Atom MCP Documentation

Quick Start

Atom MCP is live. There is no waitlist and no API key — you connect through your MCP client's connector UI, and the client handles registration and OAuth for you.

https://mcp.atom.com/mcp Add to Claude Add to ChatGPT

In your MCP client, add a custom connector with the URL https://mcp.atom.com/mcp (Claude → Customize → Connectors → Add custom connector; or ChatGPT connectors).
The client auto-registers via Dynamic Client Registration — nothing to copy or paste.
You're sent to log in with your existing Atom account.
Approve the consent screen, choosing which scopes the agent gets.
Done. The agent can now call tools — no API key, no client ID, no manual setup.

# In Claude: Customize → Connectors → Add custom connector
Name: Atom
URL:  https://mcp.atom.com/mcp

# Your client then walks you through:
#   1. Dynamic Client Registration (automatic)
#   2. Log in with your Atom account
#   3. Approve the consent screen (domains:read / domains:register)

# Once connected, your agent issues MCP tools/call messages, e.g.
{
  "method": "tools/call",
  "params": {
    "name": "search_brandable_domains",
    "arguments": { "concept": "AI legal startup" }
  }
}

Authentication

Atom MCP authenticates with OAuth 2.1 with PKCE and Dynamic Client Registration. Atom is its own Authorization Server — users authorize with their existing Atom login. There are no API keys.

Live and production-ready. Used by Atom infrastructure.

Your MCP client handles the whole flow for you:

Dynamic Client Registration — the client registers itself with Atom automatically; you never copy a client ID or secret.
Authorization Code + PKCE — you log in with your Atom account and approve a consent screen.
Bearer token — the client then sends an OAuth access token on each request; you never see or manage it directly.

# Handled automatically by your MCP client:
# 1. Dynamic Client Registration  → registers the client with Atom
# 2. Authorization Code + PKCE     → you log in with your Atom account
# 3. Consent screen                → you grant domains:read and/or domains:register
# 4. Token exchange                → client receives an OAuth access token

POST https://mcp.atom.com/mcp
Authorization: Bearer <oauth-access-token>   # sent by your MCP client

{
  "method": "tools/call",
  "params": {
    "name": "check_domain_availability",
    "arguments": { "domain": "example.com" }
  }
}

Expired or revoked tokens return 401 Unauthorized; the client will re-run the OAuth flow. Disconnect the connector to revoke access at any time.

Scopes

Access is governed by two OAuth scopes, granted by the user on the consent screen. A tool call that needs a scope the token doesn't carry returns 403 Forbidden.

Scope	Description	Tools
`domains:read`	Discovery and evaluation — search, availability, name generation, appraisal, details, trademark screening, and checkout links.	check_domain_availability, generate_domain_names, appraise_domain, get_domain_details, screen_trademark_conflicts, get_checkout_link
`domains:register`	Purchase/register a domain by debiting the user's Atom account balance. A separate, explicit consent — connecting for discovery never implies spend authority.	register_domain

search_brandable_domains is open and requires no authentication. All other read tools require domains:read. The only transactional tool, register_domain, requires domains:register, which the user must grant separately on the consent screen.

Connection Flow

Connecting is driven entirely by your MCP client's connector UI and OAuth — there are no connect codes, handles, or tokens to manage by hand.

The user authorizes with their own Atom account. The agent only gets the scopes the user approves on the consent screen.

Add the connector — In your MCP client, paste the URL https://mcp.atom.com/mcp (Claude → Customize → Connectors → Add custom connector; or ChatGPT connectors).
Auto-registration — The client registers itself via Dynamic Client Registration. Nothing to copy.
Log in — You're redirected to log in with your existing Atom account.
Consent — Approve the consent screen, choosing domains:read and, if you want the agent to buy, domains:register.
Call tools — The client now carries an OAuth token and can call tools within the granted scopes.

// In your MCP client, add a custom connector:
//   URL: https://mcp.atom.com/mcp
//
// The client then runs OAuth 2.1 + PKCE with Dynamic Client Registration:
//   - You log in with your Atom account
//   - You approve the consent screen (domains:read / domains:register)
//
// After consent, tool calls just work — no handle to pass:
{"method":"tools/call","params":{"name":"check_domain_availability","arguments":{"domain":"example.com"}}}

Endpoint: https://mcp.atom.com/mcp

How Access Works

Dynamic Client Registration identifies the connecting MCP client automatically — no manual credentials.
The user logs in with their existing Atom account and approves a consent screen.
OAuth issues a scoped access token bound to that user and the scopes they granted.
Access is per-user — the token only reaches that user's own Atom account; no cross-account access.
The user can revoke access anytime by disconnecting the connector.
Spend is gated — only register_domain can debit a balance, only with domains:register, under server-side price authority and per-call/per-day caps.

Tool Reference

Atom MCP exposes eight tools. search_brandable_domains is open; the other read tools require domains:read; register_domain requires domains:register. Every call uses the MCP tools/call shape with a name and an arguments object.

Discovery

search_brandable_domains open

Semantic search over Atom's curated premium inventory. Returns buyable brandable names with their prices. No authentication required.

Arguments:

concept (string, required) — Natural-language description of the brand or idea (e.g. "AI legal startup")
page (number, optional) — Page number
page_size (number, optional) — Results per page (max 100)

{
  "method": "tools/call",
  "params": {
    "name": "search_brandable_domains",
    "arguments": {
      "concept": "AI legal startup"
    }
  }
}

check_domain_availability domains:read

Check whether a specific domain is available, taken, or premium. If it's taken, returns relevant Atom alternatives.

Arguments:

domain (string, required) — e.g. "example.com"

{
  "method": "tools/call",
  "params": {
    "name": "check_domain_availability",
    "arguments": {
      "domain": "example.com"
    }
  }
}

generate_domain_names domains:read

AI-generated brandable names, grounded against live availability and Atom's premium inventory so suggestions are actually obtainable.

Arguments:

concept (string, required) — Description of the brand, product, or idea
count (number, optional) — How many names to generate

get_domain_details domains:read

Full details for a single Atom listing — price, status, and associated metadata.

Arguments:

domain (string, required) — The domain name to look up

Evaluation

appraise_domain domains:read

AI appraisal with reasoning and comparable sales. The result is an estimate, not a guarantee of price or sale value.

Arguments:

domain (string, required) — The domain to appraise

screen_trademark_conflicts domains:read

Preliminary USPTO trademark screen for a name. This is a preliminary screen for awareness only — not legal advice. Consult an attorney before relying on the result.

Arguments:

domain (string, required) — The domain or brand name to screen

Buy

get_checkout_link domains:read

Returns a pre-filled, authenticated Atom checkout URL for a listing. The link itself charges nothing — the user completes the purchase on Atom.

Arguments:

domain (string, required) — The listing to check out

register_domain domains:register

Register/purchase a domain by debiting the user's Atom account balance. This is the only transactional ("write") tool. It is a two-step quote → confirm flow and is idempotent, so a retried confirm never double-charges.

Arguments:

domain (string, required) — e.g. "example.com"
step (string, required) — "quote" to get a price, then "confirm" to purchase
quote_id (string, required for confirm) — The quote returned by the quote step

// 1. Quote
{"method":"tools/call","params":{"name":"register_domain","arguments":{"domain":"example.com","step":"quote"}}}

// 2. Confirm (debits the user's Atom balance; idempotent)
{"method":"tools/call","params":{"name":"register_domain","arguments":{"domain":"example.com","step":"confirm","quote_id":"q_abc123"}}}

Error Handling

MCP carries JSON-RPC messages under the hood, so protocol-level errors use the standard JSON-RPC error shape. Auth and rate-limit conditions surface as HTTP status codes that your MCP client handles for you.

HTTP	Code	Description
401	—	Missing, expired, or revoked OAuth token — the client re-runs the OAuth flow
403	—	Insufficient scope (e.g. calling `register_domain` without `domains:register`)
429	—	Rate limit exceeded
—	`-32700`	Invalid JSON
—	`-32600`	Invalid request
—	`-32602`	Invalid parameters
—	`-32603`	Internal error

JSON-RPC error format (MCP transport):

{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32600,
    "message": "Error description"
  }
}

When a token lacks the scope a tool needs, the call is rejected with 403 Forbidden. The user can grant the missing scope by reconnecting the connector and approving it on the consent screen — for example, granting domains:register before the agent can use register_domain.

Rate Limits & Spend Controls

Requests are rate-limited per OAuth token, and responses are cached where appropriate to keep latency low. Exceeding a limit returns 429 Too Many Requests.

Purchasing through register_domain is additionally protected:

Server-side price authority — the price is determined by Atom, never trusted from the client.
Per-call and per-day spend caps — bound how much an agent can spend from a balance.
Idempotent purchases — a retried confirm with the same quote never double-charges.
Explicit consent — spend requires the separate domains:register scope.

Limits and caps may be adjusted over time.

Works With

Streamable HTTP (MCP)

Atom MCP works with any MCP-compatible agent, including:

Claude — listed in the Anthropic Connectors Directory; add via Customize → Connectors → Add custom connector.
ChatGPT — add as a connector.
Any MCP client — point it at https://mcp.atom.com/mcp.

MCP Protocol

Atom MCP is served over Streamable HTTP (Model Context Protocol, 2025-03-26 spec) at https://mcp.atom.com/mcp, secured with OAuth 2.1. MCP carries JSON-RPC messages on this transport, so tool invocations use the standard tools/call shape — but in practice your MCP client speaks the protocol for you; you don't hand-craft requests.

Core methods:

tools/list — Returns available tools. Only tools allowed by the token's scopes are included.
tools/call — Invoke a tool with name and arguments

{
  "method": "tools/call",
  "params": {
    "name": "search_brandable_domains",
    "arguments": {
      "concept": "AI legal startup"
    }
  }
}

For MCP protocol details, see modelcontextprotocol.io.

Versioning

Atom MCP is versioned at the protocol and tool level, and we maintain backward compatibility for published tools — tool names and schemas don't change underneath you. New capabilities are added as new tools; any breaking change ships under a new version and is announced in advance. Current server version: v2.

Reliability & Support

Atom MCP runs on the same production infrastructure that powers Atom.com.

Availability. Target uptime 99.9%. The server is stateless and horizontally scaled behind HTTPS, with curated inventory cached for fast, consistent responses.
Latency. Most read tools (search, availability, appraisal, details, trademark) typically respond in under ~1–2 seconds; name generation runs an AI model plus live availability checks and usually completes in a few seconds.
Try before you connect. search_brandable_domains is open and needs no auth — you can exercise it immediately. For the full read tools, connect in your client's developer/custom-connector mode and authorize with a normal Atom account; no separate credentials required.
Rate limits & fair use. Per-identity rate limits and result caps keep the service responsive; clients receive a clean 429 with Retry-After when limits are hit (see Rate Limits).
Support. Questions, issues, or partnership inquiries: legal@atom.com. Status and changes are reflected on this page and the overview.
Changelog. Material changes are noted with the server version above; breaking changes are announced before they ship.