DoDomain MCP server: Claude, ChatGPT, Cursor

DoDomain ships a remote MCP (Model Context Protocol) server, so AI assistants and agents (Claude, coding agents, anything that speaks MCP) can check a domain's DNS provider, mint a connect session, hand your user the hosted connect link, and verify DNS, using the same REST API and permissions your integration already has.

One URL, nothing else to configureCopy Anchor Link

The server lives at:

https://app.dodomain.io/api/mcp

Fastest: Add to ClaudeCopy Anchor Link

Using Claude on the web, desktop or mobile? Add DoDomain to Claude opens DoDomain's listing in Claude's connector directory: click Connect, then approve the DoDomain sign-in.

Let your coding agent set itself upCopy Anchor Link

Paste this sentence into Claude Code, Codex, Cursor, OpenCode or GitHub Copilot. The agent fetches DoDomain's setup instructions and adds this server, installs the SDK for your stack and verifies the result:

Fetch and execute the appropriate instructions to set me up for DoDomain from https://dodomain.io/agent-setup/prompt.md

The same commands, one page per agent, are at dodomain.io/agent-setup. The manual setup for each client follows.

How sign-in worksCopy Anchor Link

It speaks Streamable HTTP (stateless) and authenticates with OAuth 2.1 (PKCE plus dynamic client registration), publishing the standard discovery documents (RFC 9728 protected-resource and RFC 8414 authorization-server metadata). MCP clients find the authorization server, register themselves, and start the sign-in flow automatically. You add the URL, sign in with your DoDomain account, and approve the requested scopes on the consent page. No API keys, no manual client setup.

Claude CodeCopy Anchor Link

claude mcp add --transport http dodomain https://app.dodomain.io/api/mcp

Start a new session, run /mcp, pick dodomain and choose Authenticate.

CodexCopy Anchor Link

codex mcp add dodomain --url https://app.dodomain.io/api/mcp
codex mcp login dodomain

CursorCopy Anchor Link

Add the server to ~/.cursor/mcp.json (every project) or .cursor/mcp.json (one project), merging into mcpServers if the file exists:

{
  "mcpServers": {
    "dodomain": {
      "url": "https://app.dodomain.io/api/mcp"
    }
  }
}

OpenCodeCopy Anchor Link

Add the server to opencode.json in the project root (or ~/.config/opencode/opencode.json), then sign in:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "dodomain": {
      "type": "remote",
      "url": "https://app.dodomain.io/api/mcp",
      "enabled": true
    }
  }
}

opencode mcp auth dodomain

GitHub Copilot (VS Code)Copy Anchor Link

Add the server to .vscode/mcp.json, then start it from MCP: List Servers and sign in when VS Code asks:

{
  "servers": {
    "dodomain": {
      "type": "http",
      "url": "https://app.dodomain.io/api/mcp"
    }
  }
}

Claude.aiCopy Anchor Link

One click: Add DoDomain to Claude opens DoDomain's listing in Claude's connector directory. By hand, as a custom connector: in Claude's web or desktop app, open Settings → Connectors → Add custom connector and paste the URL above as the remote MCP server URL. Claude walks you through the DoDomain sign-in and consent screen, then the tools appear in your conversations.

Connect from any MCP clientCopy Anchor Link

Buttons for Claude and ChatGPT open the directory listing; the others install directly or jump to the instructions.

Any client that supports remote MCP servers over Streamable HTTP with OAuth works the same way: give it the URL below, sign in to DoDomain when the browser opens, and approve the scopes. The URL is the only configuration. Claude Code, Codex, Cursor, OpenCode, GitHub Copilot and Claude.ai have their own sections above; the other common clients follow.

https://app.dodomain.io/api/mcp

ChatGPTCopy Anchor Link

One click: Open DoDomain in ChatGPT opens DoDomain's published ChatGPT app; click Connect, then sign in. Manual: Settings → Apps & Connectors → Create (developer mode), name it DoDomain, paste the URL, authentication OAuth. (For the Codex CLI, see Codex above.)

Cursor and VS Code, one clickCopy Anchor Link

Add to Cursor · Add to VS Code. The hand-written config files are in the Cursor and GitHub Copilot (VS Code) sections above; VS Code's MCP: Add Server → HTTP command writes the same .vscode/mcp.json.

Google AntigravityCopy Anchor Link

Install the plugin from the repository (or from the Antigravity Marketplace once listed):

agy plugin install https://github.com/DevinoSolutions/mcp-servers/antigravity-plugins/dodomain

Or add the server by hand in ~/.gemini/config/mcp_config.json (Antigravity requires the serverUrl key):

{ "mcpServers": { "dodomain": { "serverUrl": "https://app.dodomain.io/api/mcp" } } }

GeminiCopy Anchor Link

• Gemini app: Settings → Connected apps → Custom apps → Add a custom app, paste the URL, then mention @DoDomain in a chat. (Custom apps are currently limited to personal Google accounts in the US.)
• Gemini CLI: gemini extensions install https://github.com/DevinoSolutions/mcp-servers then /mcp auth dodomain, or add { "mcpServers": { "dodomain": { "httpUrl": "https://app.dodomain.io/api/mcp" } } } to ~/.gemini/settings.json.

KiroCopy Anchor Link

One click: Add to Kiro. Or in .kiro/settings/mcp.json:

{ "mcpServers": { "dodomain": { "url": "https://app.dodomain.io/api/mcp" } } }

Perplexity, Mistral Le Chat, GrokCopy Anchor Link

• Perplexity (Pro, Max, Enterprise): Settings → Connectors → Custom connector, paste the URL, authentication OAuth.
• Mistral Le Chat (all plans): Intelligence → Connectors → Add Connector → Custom MCP Connector, paste the URL.
• Grok: grok.com → Connectors → New connector → Custom, paste the URL.

Other clientsCopy Anchor Link

• Replit: Add to Replit, or Integrations → Add MCP server.
• Devin, Windsurf, Zed, JetBrains Junie, Cline, MCP Inspector, your own agent built on an MCP SDK: add a remote (HTTP) MCP server with the URL above; each prompts for the OAuth sign-in on first use. Cline can also install it from the Cline marketplace entry using its llms-install.md.

Tokens are scoped to what you approve on the consent screen; a tool you did not grant is never shown to the assistant. Revoke access at any time from the dashboard under Connected apps; see Revoking access.

The eight toolsCopy Anchor Link

Every tool calls the same /api/v1 REST surface documented in the API reference, on the teams you chose when you approved the connection (see Teams). None are destructive: nothing an agent can call deletes apps, connections, or DNS records.

The server uses Code Mode. Its tool list has two tools, search_tools and execute_typescript, not one tool per row below. Your assistant calls search_tools to find the tools below, then runs a short TypeScript program through execute_typescript that calls them. Each call goes through the same scope and team checks as a direct call, and a refused call comes back as an error inside the program, such as SCOPE_MISSING or TEAM_REQUIRED.

Scopes and consentCopy Anchor Link

Access is scoped. When a client connects, the consent page lists exactly what it asked for, and the token it receives carries only the scopes you approve. What search_tools returns is filtered to the granted scopes: a client granted only read scopes never even sees create_connect_session.

These are the seven scopes, worded as the consent screen words them:

TeamsCopy Anchor Link

If you belong to more than one DoDomain team, the consent screen asks which ones the connection can use: the teams you tick (your current team is ticked to start with), or All my teams, which also covers teams you join later. The connection can act on a team only while you are still a member of it; leave a team and the connection loses it on the next request. If you rejoin a team the connection was granted, it can use that team again; to stop that, disconnect the client (dashboard, Connected apps) or connect it again without that team. To change the teams later, connect the client again and choose again: the new choice replaces the old one for the whole connection, including the access tokens the client already holds.

When a connection covers more than one team, the agent says which team each call is for. list_teams returns the teams it can use, and the tools that read or write team data (check_domain, list_apps, list_connections, create_connect_session, reverify_connection) take an optional teamId. With more than one team, a call without teamId is refused with TEAM_REQUIRED (except check_domain, whose answer does not depend on the team), and a call naming a team the connection cannot use is refused with TEAM_NOT_FOUND; both list the usable teams. With a single team, teamId can be left out.

Over REST, the same choice is the DoDomain-Team header (a team id from GET /api/v1/teams); see the API reference. A secret key (dd_sk_) belongs to exactly one team, so it needs no header, and a header naming any other team is refused with 404 TEAM_NOT_FOUND.

Revoking accessCopy Anchor Link

Every connected client is listed in the dashboard under Connected apps. Revoking one takes effect immediately: both its access and refresh tokens stop working on the next request, because every MCP request checks that your consent still exists.

Rate limits and pricingCopy Anchor Link

MCP access is included on every plan: there is no separate SKU. Requests ride the same per-minute plan meters as the REST API (Free 60, Pro 300, Scale 1,200 requests/min per team), and the monthly connection quota is metered identically to REST: creating a session costs nothing, and one unit is charged when a domain is first verified. create_connect_session is refused with quota_exceeded exactly when the REST endpoint would refuse it: on every plan once the team's monthly cap is reached, and on Free also once the Free teams owned by any of this team's owners together reach it, or once its unfinished sessions reach what the month has left plus 10 (see Pricing).

SecurityCopy Anchor Link

MCP callers authenticate exclusively with OAuth 2.1: PKCE on every flow, access tokens that expire after 30 days by default (a revoked client is still refused on its next request), and refresh only for clients granted it at consent. Your dd_sk_ secret keys are never exposed to agents: the MCP endpoint does not accept them. Grants are per-user, per-client, scope-limited, and revocable instantly from the dashboard.