# Namecheap API MCP

> Read and edit a Namecheap portfolio from any MCP client — the non-ChatGPT path to the same account.

[Canonical HTML page](https://top-mcps.com/mcp/namecheap-mcp) · [server.json](https://top-mcps.com/mcp/namecheap-mcp.json) · [methodology](https://top-mcps.com/about/methodology)

## Install

### Claude Desktop — `claude_desktop_config.json`

Paste under mcpServers. Fully quit and reopen Claude after editing.

```json
{
  "mcpServers": {
    "namecheap-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "namecheap-api-mcp@latest"
      ],
      "env": {
        "NAMECHEAP_API_USER": "${NAMECHEAP_API_USER}",
        "NAMECHEAP_API_KEY": "${NAMECHEAP_API_KEY}",
        "NAMECHEAP_USERNAME": "${NAMECHEAP_USERNAME}",
        "NAMECHEAP_CLIENT_IP": "${NAMECHEAP_CLIENT_IP}"
      }
    }
  }
}
```

### Claude Code — `CLI or .mcp.json`

Run from your repo. Commit .mcp.json to share with your team.

```shell
# export NAMECHEAP_API_USER=your_api_user
# export NAMECHEAP_API_KEY=your_api_key
# export NAMECHEAP_USERNAME=your_username
# export NAMECHEAP_CLIENT_IP=your_allowlisted_ip
claude mcp add namecheap-mcp -- npx -y namecheap-api-mcp@latest
```

### Cursor — `.cursor/mcp.json`

Global path: ~/.cursor/mcp.json. Reload window after editing.

```json
{
  "mcpServers": {
    "namecheap-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "namecheap-api-mcp@latest"
      ],
      "env": {
        "NAMECHEAP_API_USER": "${NAMECHEAP_API_USER}",
        "NAMECHEAP_API_KEY": "${NAMECHEAP_API_KEY}",
        "NAMECHEAP_USERNAME": "${NAMECHEAP_USERNAME}",
        "NAMECHEAP_CLIENT_IP": "${NAMECHEAP_CLIENT_IP}"
      }
    }
  }
}
```

### VS Code — `.vscode/mcp.json`

VS Code uses the "servers" key (not "mcpServers").

```jsonc
{
  "servers": {
    "namecheap-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "namecheap-api-mcp@latest"
      ],
      "env": {
        "NAMECHEAP_API_USER": "${NAMECHEAP_API_USER}",
        "NAMECHEAP_API_KEY": "${NAMECHEAP_API_KEY}",
        "NAMECHEAP_USERNAME": "${NAMECHEAP_USERNAME}",
        "NAMECHEAP_CLIENT_IP": "${NAMECHEAP_CLIENT_IP}"
      }
    }
  }
}
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Open via Cascade → hammer icon → Configure.

```json
{
  "mcpServers": {
    "namecheap-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "namecheap-api-mcp@latest"
      ],
      "env": {
        "NAMECHEAP_API_USER": "${NAMECHEAP_API_USER}",
        "NAMECHEAP_API_KEY": "${NAMECHEAP_API_KEY}",
        "NAMECHEAP_USERNAME": "${NAMECHEAP_USERNAME}",
        "NAMECHEAP_CLIENT_IP": "${NAMECHEAP_CLIENT_IP}"
      }
    }
  }
}
```

### Cline — `cline_mcp_settings.json`

Open via the Cline sidebar → MCP Servers → Edit.

```json
{
  "mcpServers": {
    "namecheap-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "namecheap-api-mcp@latest"
      ],
      "env": {
        "NAMECHEAP_API_USER": "${NAMECHEAP_API_USER}",
        "NAMECHEAP_API_KEY": "${NAMECHEAP_API_KEY}",
        "NAMECHEAP_USERNAME": "${NAMECHEAP_USERNAME}",
        "NAMECHEAP_CLIENT_IP": "${NAMECHEAP_CLIENT_IP}"
      }
    }
  }
}
```

### Continue — `~/.continue/config.json`

Continue uses modelContextProtocolServers with a transport block.

```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "npx",
          "args": [
            "-y",
            "namecheap-api-mcp@latest"
          ],
          "env": {
            "NAMECHEAP_API_USER": "${NAMECHEAP_API_USER}",
            "NAMECHEAP_API_KEY": "${NAMECHEAP_API_KEY}",
            "NAMECHEAP_USERNAME": "${NAMECHEAP_USERNAME}",
            "NAMECHEAP_CLIENT_IP": "${NAMECHEAP_CLIENT_IP}"
          }
        }
      }
    ]
  }
}
```

### Codex CLI — `~/.codex/config.toml`

Codex uses TOML. Each server is a [mcp_servers.<name>] subtable.

```shell
# ~/.codex/config.toml
[mcp_servers.namecheap-mcp]
command = "npx"
args = [
  "-y",
  "namecheap-api-mcp@latest",
]
env = { NAMECHEAP_API_USER = "${NAMECHEAP_API_USER}", NAMECHEAP_API_KEY = "${NAMECHEAP_API_KEY}", NAMECHEAP_USERNAME = "${NAMECHEAP_USERNAME}", NAMECHEAP_CLIENT_IP = "${NAMECHEAP_CLIENT_IP}" }
```

### Zed — `~/.config/zed/settings.json`

Zed calls them "context_servers". Settings live-reload on save.

```jsonc
{
  "context_servers": {
    "namecheap-mcp": {
      "command": {
        "path": "npx",
        "args": [
          "-y",
          "namecheap-api-mcp@latest"
        ]
      },
      "env": {
        "NAMECHEAP_API_USER": "${NAMECHEAP_API_USER}",
        "NAMECHEAP_API_KEY": "${NAMECHEAP_API_KEY}",
        "NAMECHEAP_USERNAME": "${NAMECHEAP_USERNAME}",
        "NAMECHEAP_CLIENT_IP": "${NAMECHEAP_CLIENT_IP}"
      }
    }
  }
}
```

### ChatGPT — `ChatGPT → Apps directory`

Namecheap API MCP doesn't ship a hosted HTTPS endpoint today. ChatGPT supports remote MCP servers only — to use this server in ChatGPT you'll need to deploy it to a public HTTPS URL first (e.g. via Cloudflare Workers or Vercel) or wait for an official remote build.

```none

```

## At a glance

- **Maintainer:** Community (lanternrow)
- **Transport:** stdio
- **Auth model:** API key
- **Required secrets:** NAMECHEAP_API_USER, NAMECHEAP_API_KEY, NAMECHEAP_USERNAME, NAMECHEAP_CLIENT_IP
- **Supported clients:** Claude, Cursor, VS Code, Windsurf, Any MCP-compatible client, Namecheap accounts
- **License:** MIT
- **Language:** TypeScript
- **Latest version:** latest
- **Last verified:** 2026-09-17
- **GitHub stars:** 0 (fetched 2026-10-15T10:09:13.491Z)
- **Score:** 53/100 (rubric 2026-09 — see https://top-mcps.com/about/methodology)
- **Source:** https://github.com/lanternrow/namecheap-api-mcp

## Tools & permissions

Showing 12 of 16 tools the server reported on `tools/list`. The rest exist and are not listed here.

| Tool | Description | Args | Side effects |
|------|-------------|------|--------------|
| `check_connection` | Verify credentials and return the account balance summary. | `—` | network |
| `list_domains` | List domains with expiry, lock, auto-renew and WhoisGuard status. | `—` | read |
| `check_domains` | Bulk availability and premium pricing, max 50 per call. | `—` | network |
| `get_domain_info` | Detailed status for one domain. | `—` | read |
| `get_dns_hosts` | Read every DNS host record on a domain. | `—` | read |
| `set_dns_hosts` | Replace ALL host records — anything omitted is deleted. | `—` | write |
| `set_custom_nameservers` | Point a domain at external nameservers. | `—` | write |
| `set_default_dns` | Switch a domain back to Namecheap BasicDNS. | `—` | write |
| `set_email_forwarding` | Replace the full email-forwarding rule set. | `—` | write |
| `set_registrar_lock` | Lock or unlock the domain at the registrar. | `—` | write |
| `get_pricing` | Namecheap pricing for a product type. Heavy — cache it. | `—` | network |
| `list_ssl_certificates` | List SSL certificates with type, host and expiry. | `—` | read |

## Security & scope

- **Access scope:** read-write
- **Sandbox:** Namecheap operates a sandbox at sandbox.namecheap.com; point the credentials there first.
- **Gotchas:**
  - `set_dns_hosts` replaces the entire record set. Namecheap deletes anything not included in the call, so an agent that sends a partial list silently wipes the rest of the zone. Read with `get_dns_hosts` first and send the merged set.
  - Namecheap requires the calling IP to be allowlisted in the account. `NAMECHEAP_CLIENT_IP` must match the machine actually making the request, which makes this awkward on a dynamic-IP laptop.
  - Third-party wrapper holding full API credentials — not a scoped token.

## Quick answer

**What it does.** Exposes Namecheap's API as MCP tools: `list_domains`, `check_domains` (bulk availability plus premium pricing), `get_dns_hosts` / `set_dns_hosts`, `get_nameservers` / `set_custom_nameservers` / `set_default_dns`, `get_email_forwarding` / `set_email_forwarding`, `get_registrar_lock` / `set_registrar_lock`, `get_pricing`, and `list_ssl_certificates`.

**Best for:**
- Portfolio audits (expiry, lock, auto-renew, WhoisGuard)
- Bulk availability checks, up to 50 per call
- Switching nameservers to an external DNS provider
- Email forwarding rules
- Unlocking a domain before a transfer out

**Not for:**
- Registering or renewing domains
- Accounts at other registrars
- Setups where allowlisting a static IP is impossible

## Description

A community MCP wrapping the Namecheap API with 16 tools: portfolio listing with expiry and lock status, availability and premium-price checks up to 50 domains per call, the full DNS host-record set, nameserver switching, email forwarding, registrar lock, and SSL certificate listing. It is the answer to the gap the Namecheap ChatGPT App leaves — that app only works inside ChatGPT.

## Why it matters

Namecheap is the default registrar for a large share of indie developers, and until now this directory could only point them at a ChatGPT-only integration. This server puts the same portfolio in Claude Code, Cursor, VS Code and any other client.

## Key features

- 16 tools verified by probe
- Bulk availability with premium pricing
- Works in every MCP client, not only ChatGPT
- Registrar-lock control for transfers out
- MIT

## FAQ

### How is this different from the Namecheap ChatGPT App?

The App is OAuth and works only inside ChatGPT, and it can register domains. This server works in every MCP client and takes an API key, but does not register — it is read plus DNS, nameserver, forwarding and lock writes.

### Why does it need my IP address?

Namecheap's API allowlists by source IP. `NAMECHEAP_CLIENT_IP` has to be the address the request actually leaves from, and the same address must be added in the Namecheap account. On a laptop with a changing IP this is the main setup friction.

### Is it safe to let an agent edit DNS here?

Only with the merge caveat: `set_dns_hosts` is a full replace, not a patch. An agent that sets one record without reading the existing set first will delete everything else on the domain.

## Changelog

- **2026-09-17** — Refreshed install snippets and fact sheet; verified for 2026.