Atom MCP Documentation

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.

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.

1. Add the connector — In your MCP client, paste the URL https://mcp.atom.com/mcp (Claude → Customize → Connectors → Add custom connector; or ChatGPT connectors).
2. Auto-registration — The client registers itself via Dynamic Client Registration. Nothing to copy.
3. Log in — You're redirected to log in with your existing Atom account.
4. Consent — Approve the consent screen, choosing domains:read and, if you want the agent to buy, domains:register.
5. 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

1. Dynamic Client Registration identifies the connecting MCP client automatically — no manual credentials.
2. The user logs in with their existing Atom account and approves a consent screen.
3. OAuth issues a scoped access token bound to that user and the scopes they granted.
4. Access is per-user — the token only reaches that user's own Atom account; no cross-account access.
5. The user can revoke access anytime by disconnecting the connector.
6. 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.

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.

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

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.