Namecheap MCP connects your AI assistant (such as Claude) to your Namecheap account. Through it, the assistant can check and register domains, manage domain contacts, and read or edit DNS records on your behalf — you just ask in plain language, and the assistant calls the right tools.

Getting started

You need a Namecheap account. Namecheap MCP is available at https://mcp.namecheap.com/mcp.

How you connect depends on your AI assistant:

• Claude (web and desktop) — open Settings, choose Connectors, add a custom connector, and point it at https://mcp.namecheap.com/mcp. Anthropic's Claude is the client we have verified this to work with.
  
  NB: While domain registration via Namecheap MCP is fully supported overall, this capability is not yet available through the Claude connector specifically. Search, domain lookup, contact management, and DNS record management are already available and verified to work with Claude today.
  
  
• Other MCP clients — add a remote MCP server and point it at https://mcp.namecheap.com/mcp. Other clients may work, but we haven't verified them yet.

When you connect, you'll be asked to sign in to Namecheap and grant the assistant access to your account. Which tools the assistant can use depends on the access you approve — if a tool is rejected because access wasn't granted, reconnect and approve the access it needs.

Tools at a glance

Namecheap registrations complete synchronously, so there is no background-operation tool to poll:

Contacts: inline or by reference

Wherever a contact is required (domain_register, domain_set_contacts), each role accepts either:

• inline contact details — the full contact object (firstName, lastName, email, …). It is saved to your Namecheap account automatically; you do not have to call contacts_save first.
• a reference — { "contactId": "…" } pointing at a contact you saved earlier with contacts_save.

A contactId is an opaque string (1–32 characters). Do not parse it or assume a format — just pass it back where a contact is accepted.

Common workflows

Several tools are designed to be used together: the output of one becomes the input of the next.

Register (buy) a domain

1. domains_check_availability — check the name(s) you want. Only proceed when result is available. Each available name includes the USD price to register it (standard and premium alike), or priceUnavailableReason when it can't be determined, plus minRegisterPeriodInYears and maxRegisterPeriodInYears — the term that TLD allows. Note the price covers price.pricedYears years, which is the TLD's shortest allowed term and is not always 1.
2. domain_register (preview) — call with confirmationToken unset to get status: confirmation_required, a fresh confirmationToken, and the price that will be charged. Nothing is billed. The tool's response text is a full confirmation — term, price breakdown, auto-renew, WHOIS privacy, payment source, and the registrant/admin/tech/billing contacts — show it to the user as-is. Pick years between minRegisterPeriodInYears and maxRegisterPeriodInYears from step 1 — an out-of-range value is rejected outright. Contacts can be passed inline here, or as { contactId } if you saved them with contacts_save.
3. domain_register (accept/decline) — after the user agrees, call again with the exact same arguments plus that confirmationToken and confirmationResponse: "accept". This bills the account's default payment method and is irreversible. It returns the outcome directly (no polling): usually status: completed with the amount charged, or status: pending while the registry finishes. To cancel instead, call again with the same confirmationToken and confirmationResponse: "decline" — nothing is billed. If the price can't be determined on either call, the tool returns status: price_unavailable instead and nothing is charged.
4. domains_list — if the result was pending, call domains_list for the domain shortly to confirm it is registered.

domains_check_availability --> domain_register --> domain_register --> (domains_list if pending)
 (available? + price +          (token unset:       (token + accept:     confirm final state
  min/maxRegisterPeriod)         confirmation,       completed/pending)
                                 confirmationToken,
                                 no charge)

Update the contacts on a domain you own

1. domain_set_contacts — assign contacts to the domain, inline or by { contactId }. Completes immediately. verificationStatus is always null for Namecheap. Some TLD registries require extended attributes — pass them via tldAttributes.

Change a domain's nameservers

1. domains_list — find the domain and see its current nameservers ({ provider, hosts }; populated when fetching a single domain).
2. domain_set_nameservers — switch it to Namecheap's default nameservers with provider: "basic" (no hosts), or point it at your own with provider: "custom" and a list of 2–12 hosts. It returns the resulting { provider, hosts }. Re-applying the state a domain is already in returns a validation error rather than a no-op — treat that as expected, not a failure to retry.

Manage DNS records

1. domains_list — find the domain you want to manage (or pass its name directly if you know it).
2. dns_records_get — read the current records for the domain.
3. dns_records_save or dns_records_delete — add, update, or remove records. Records returned by dns_records_get have the same shape the save and delete tools accept (delete just omits ttl), so the assistant can read, adjust, and write back. Matching is case-insensitive except for TXT records, which are case-sensitive.

Review your portfolio

• domains_list — page through all your domains with sorting, or fetch a single domain by name. See the tool below for which fields Namecheap reports.
• contacts_get — look up the details behind any contact ID you see on a domain.

Tool reference

Every tool returns its result as structured JSON, and every tool completes immediately — Namecheap has no long-running background operations.

Contacts

Contacts are the people or organizations attached to a domain registration (registrant, admin, tech, billing). A contact is referenced everywhere by its contact ID — an opaque string.

contacts_save — Save Contact

Saves contact details and returns the generated contact ID. Validation of some fields (such as stateProvince and postalCode) depends on the selected country.

Idempotent. Saving details identical to a contact you saved before reuses that existing contact ID instead of creating a duplicate.

Returns

{ "contactId": "..." }

contactId (opaque, 1–32 chars) is what you pass to domain_register, domain_set_contacts, and contacts_get.

When Namecheap's address validation proposes a corrected address, the result may additionally include an addressSuggestion:

{
  "contactId": "...",
  "addressSuggestion": {
    "status": "corrected",
    "suggestedAddress": {
      "address1": "...", "address2": "...", "city": "...",
      "stateProvince": "...", "country": "...", "postalCode": "..."
    }
  }
}

Each field of suggestedAddress is present only when Namecheap proposes a value for it. Treat it as a suggestion to show the user, not an automatic change — the contact is still saved with the details you submitted.

contacts_get — Get Contact

Reads the details of a saved contact by its contact ID. (There is no list-all-contacts tool — contact IDs come from contacts_save.)

Returns — { contact } with:

Domains

Domain name inputs (domain/domainName) accept Unicode (IDN) or ASCII (A-label) — either way, the tool normalizes the name to punycode automatically before use. domains_check_availability and domain_register additionally require a TLD Namecheap supports for registration: a domain whose TLD isn't supported is treated as not available rather than checked or charged. The other domain tools (domains_list, domain_set_contacts, domain_set_nameservers) and the DNS tools normalize the name only and never reject on TLD support.

domains_list — List Domains

Retrieves a paginated list of your domains. Pass domain to fetch a single domain by name instead (pagination and ordering are then ignored, and the result includes a note saying so if they were supplied).

Returns — { items, total } where each item describes a domain:

Namecheap-specific reporting:

• contacts, eppStatuses, suspensions, and verificationStatus are not reported — they come back empty or null.
• unicodeName always mirrors name.
• nameservers is populated only when fetching a single domain via domain. In the multi-item list it reports the basic default with no hosts.
• contactDetails is populated only when fetching a single domain via domain. It carries the actual registrant/admin/tech/billing contact details assigned to that domain, so you can read them without holding a contact ID. The id-based contacts field still comes back empty even in the single-domain case, and contactDetails is not included in the multi-item list.
• autoRenew is a real true/false only in the multi-item list. Fetching a single domain via domain returns autoRenew: null, because Namecheap's single-domain lookup carries no auto-renew field — reported as null rather than a misleading false.

domains_check_availability — Check Domain Availability

Checks whether one or more domain names are available to register. Uses the single-domain endpoint for one name and the bulk endpoint for multiple. A domain whose TLD isn't supported for registration is not sent to the availability check at all — it's returned immediately as tldNotSupported.

Returns — { results }, one entry per requested name:

Only available names are priced; taken/invalid results carry neither price nor priceUnavailableReason.

Most TLDs allow one year, but some do not. .ai, for example, has a two-year minimum. For those, price.amount is the total for the minimum term — not a one-year price you could act on — and price.pricedYears says so:

{
  "domain": "example.ai",
  "result": "available",
  "premiumPricing": [],
  "price": { "amount": 79.98, "currency": "USD", "pricedYears": 2, "pricePerYear": 39.99, "isPremium": false },
  "minRegisterPeriodInYears": 2,
  "maxRegisterPeriodInYears": 10
}

pricePerYear is present here — 79.98 divided by the two years it covers gives 39.99. This is the total divided by the term, not a price you could pay for a single year (a one-year .ai registration cannot be bought). Always show amount together with pricedYears ("$79.98 for 2 years"), never amount alone. For an ordinary TLD, pricedYears is 1 and pricePerYear equals amount.

Namecheap-specific reporting

• minRegisterPeriodInYears/maxRegisterPeriodInYears come from Namecheap's own TLD catalogue. Where that catalogue understates a minimum, the gateway corrects it from what the pricing service will actually sell: the first affected request may report the catalogue's value, and every request after it reports the corrected one.
• pricePerYear is never reported for a premium name — a premium quote carries no term, so a per-year figure would be invented.
• Both period fields are reported for every available name, premium included, even where no price could be produced.

domain_register — Register Domain

Registers (buys) a domain. This bills your account's default payment method and is irreversible. Recommended sequence: domains_check_availability -> domain_register. A domain whose TLD isn't supported for registration is rejected immediately — before any availability check, pricing, or charge.

years must be within the TLD's own allowed period. The 1–10 bound below is the outer limit across all TLDs; each TLD is narrower. .ai allows 2–10, .co and .io allow 1–5, .sg 1–2, .fr exactly 1. A years outside that range is rejected with a validation error naming the allowed range — before any availability check, pricing or charge — and the value is not quietly adjusted for you:

Read minRegisterPeriodInYears/maxRegisterPeriodInYears from domains_check_availability first and pick a years inside it. The same check re-runs on the confirming (confirmationResponse: "accept") call, so it can never be bypassed by confirming.

Two-step pre-charge confirmation. Call first with confirmationToken unset: the tool prices the domain fresh, builds a full confirmation — term, price breakdown (including any ICANN fee and whether the domain is premium), auto-renew, WHOIS privacy, payment source, and the registrant/admin/tech/billing contacts (a contact identical to the registrant is shown as "same as registrant") — and returns status: "confirmation_required" with that price and a fresh confirmationToken. Nothing is registered or billed on this call. The full confirmation is the tool's response text; show it to the user as-is. Once they agree, call again with the exact same arguments plus this confirmationToken and confirmationResponse: "accept" to submit the purchase, or confirmationResponse: "decline" to cancel it — nothing is billed on a decline. The token is bound to these exact arguments and the quoted price and expires after a short time: a missing, expired, tampered, or no-longer-matching token on the confirming call simply returns a brand-new confirmation with a fresh token — never an error, never a charge. If the price cannot be determined on either call, the tool returns status: "price_unavailable" instead of a token and never charges; retry later.

Synchronous. Unlike some registrars, Namecheap registration completes as part of the call — there is no operation to poll. A confirmed call returns its outcome directly (see the status table below).

Returns — after the first call (nothing charged):

{
  "domain": "example.com",
  "years": 1,
  "status": "confirmation_required",
  "price": {
    "amount": 9.08,
    "currency": "USD",
    "pricedYears": 1,
    "pricePerYear": 9.08,
    "icannFee": 0.2,
    "isPremium": false
  },
  "confirmationToken": "v1.eyJ2IjoxLCJwIjoi...aWQiOjF9.9F3q7z_5c8Vb...",
  "note": "Nothing has been charged yet. Show the confirmation to the user and, once they agree, call domain_register again with this confirmationToken and confirmationResponse=\"accept\" to complete the purchase, or confirmationResponse=\"decline\" to cancel."
}

Alongside this JSON, the tool's response text is the full confirmation to show the user — it restates the domain, term, and price above, plus lines for Auto-renew: on/off, WHOIS privacy: on/off, Payment source: Namecheap account funds, and each of the registrant/admin/tech/billing contacts (name, email, country — a contact matching the registrant reads "same as registrant"), followed by instructions for the next call. For a multi-year term, price.amount is the total for the whole term and price.pricePerYear is that total divided by the term — e.g. years: 5 on .com returns { "amount": 71.40, "pricedYears": 5, "pricePerYear": 14.28 }, and example.ai with years: 2 returns { "amount": 79.98, "pricedYears": 2, "pricePerYear": 39.99 }.

Returns — after confirmationResponse: "accept" (registered and charged):

{
  "domain": "example.com",
  "years": 1,
  "status": "completed",
  "charged": { "amount": 9.08 },
  "operation": { "kind": "order", "id": 123456 },
  "price": {
    "amount": 9.08,
    "currency": "USD",
    "pricedYears": 1,
    "pricePerYear": 9.08,
    "icannFee": 0.2,
    "isPremium": false
  },
  "note": "..."
}

Returns — after confirmationResponse: "decline" (nothing charged):

{
  "domain": "example.com",
  "years": 1,
  "status": "cancelled",
  "price": { "amount": 9.08, "currency": "USD", "pricedYears": 1, "pricePerYear": 9.08, "icannFee": 0.2, "isPremium": false },
  "note": "Registration of example.com was not submitted because the purchase was not confirmed."
}

Returns — if the price can't be determined, on either call:

{
  "domain": "example.com",
  "years": 1,
  "status": "price_unavailable",
  "priceUnavailableReason": "Price is currently unavailable for this domain.",
  "note": "Registration of example.com could not be priced right now, so nothing was confirmed or charged. Try again shortly."
}

status can be:

operation here is { kind: "order", id } — an order receipt, not something to poll. The price shown at confirmation_required is exactly what will be charged on confirmationResponse: "accept" — price.amount is the total for that whole term and price.pricedYears states the term, so always show the two together. When the TLD carries an ICANN fee, price.amount already includes it and price.icannFee states the fee amount so it can be explained.

Auto-renew reporting: when autoRenew: true is requested, auto-renew is turned on right after the domain is registered and charged, as its own step. A completed registration therefore carries an additive autoRenew: { requested: true, applied }. If that separate call fails, the result still reports status: "completed" with charged set (the domain is registered and paid for) but autoRenew.applied is false, and the note explains that auto-renew did not apply and how to turn it on:

{
  "domain": "example.com",
  "years": 1,
  "status": "completed",
  "charged": { "amount": 9.08 },
  "operation": { "kind": "order", "id": 123456 },
  "autoRenew": { "requested": true, "applied": false },
  "price": { "amount": 9.08, "currency": "USD", "pricedYears": 1, "pricePerYear": 9.08, "icannFee": 0.2, "isPremium": false },
  "note": "example.com was registered successfully. Auto-renew was requested but could not be turned on after the charge — the domain is registered and the charge has completed. Enable auto-renew again, or check its current state via domains_list."
}

autoRenew is omitted entirely when it wasn't requested (autoRenew: false on the call).

domain_set_contacts — Set Domain Contacts

Changes the contacts assigned to a domain you own. Completes immediately.

Returns

{ "verificationStatus": null }

Namecheap does not report an RAA verification state, so verificationStatus is always null.

domain_set_nameservers — Set Domain Nameservers

Changes a domain's registrar-level nameservers. Completes immediately. The change is reflected by domains_list (single-domain fetch) afterwards.

Returns

{ "provider": "custom", "hosts": ["ns1.example.com", "ns2.example.com"] }

Re-applying the state a domain is already in (e.g. setting basic when it is already basic) returns a validation error rather than a no-op success — treat that as an expected result, not a failure to retry.

DNS records

The domainName these tools take accepts Unicode (IDN) or ASCII (A-label) and is normalized to punycode automatically; TLD support is not enforced here.

dns_records_get — Get DNS Records

Retrieves a paginated list of DNS resource records for a domain.

Returns — { items, total }, plus omittedRecords when the zone contains records this tool cannot return (see below). Each item is a record as described in Record shapes, plus an optional group field indicating where the record comes from (custom — created by you, product — managed by a product, personalNs — personal nameservers).

Namecheap-specific: a record that cannot be represented in the typed contract is omitted from items. Two kinds are omitted: record types outside the contract — the URL, FRAME and URL301 redirect records Namecheap stores in the zone (a parked domain normally has one) — and malformed CAA/TLSA/HTTPS/SVCB values. total still counts every record in the zone, including the omitted ones, so total can be larger than the number of records you can page through. Every omitted record is listed in omittedRecords by type and name, so nothing is dropped without being reported; the field is absent when nothing was omitted. Manage omitted records in the Namecheap dashboard.

{
  "items": [
    { "type": "CNAME", "name": "www", "cname": "parkingpage.namecheap.com.", "ttl": 1800 }
  ],
  "total": 2,
  "omittedRecords": [
    { "type": "URL", "name": "@" }
  ]
}

dns_records_save — Save DNS Records

Adds custom DNS records or updates the TTL of existing ones. Records are matched case-insensitively, except TXT records (case-sensitive).

Returns — { "saved": <number> }, the count of submitted records. Unless force is set, a successful response means every record was accepted and confirmed present in the zone; if any record fails, the whole call returns an error instead.

Namecheap-specific: after writing, the zone is re-read to confirm the records actually persisted. Namecheap can accept a record and then drop it — for example an MX record at @ on a domain with email forwarding enabled, whose mail records Namecheap manages itself. A record accepted but missing from that re-read is reported as a conflict naming the record, not counted as saved. force: true deliberately opts out of that protection: the call then reports success and saved counts the records as submitted, even if some were dropped, so only use it when you intend to bypass conflict handling. If the re-read itself cannot be completed, the call fails — with force set or not — with a message saying the write may have been applied but could not be confirmed; re-read the zone with dns_records_get before retrying, rather than repeating the write. SRV records are the one exception: if Namecheap cannot return SRV records during the re-read, they are reported as saved without being confirmed.

dns_records_delete — Delete DNS Records

Deletes custom DNS records. Deletions cannot be undone. Records are matched case-insensitively, except TXT records (case-sensitive).

Returns — { "deleted": <number> }, the count of submitted records. If any record cannot be matched, the whole call fails and nothing is deleted.

Record shapes

Every record has:

• type — one of the 13 supported types below.
• name — the record name excluding the domain: use @ for the domain itself (apex) and * for a wildcard.
• ttl (save only, optional) — cache time in seconds, 60–3600.

Type-specific fields:

Errors

When a call fails, the tool returns an error with a code and a human-readable detail explaining what went wrong — for example invalid input (a malformed domain name or contact ID), a domain or contact that doesn't exist, or a conflict with the current state. If a tool is rejected because the assistant wasn't granted access to it, reconnect Namecheap MCP and approve the access it asks for.