Which domain registrar works best with AI agents? It's Porkbun.

Last checked: October 8, 2026. Registrar APIs are changing fast, so check the date before relying on any row below.

AI assistants can now search for a domain, buy it, point its DNS somewhere and set up email, all from a chat or a coding agent. How well that goes depends less on the AI than on the registrar's API: whether the agent can find out what it is allowed to do, whether it can be stopped from spending more than you meant, and whether it can tell a failure it should retry from one it should hand back to you.

We compared five registrars on that basis: Porkbun, Cloudflare, Name.com, GoDaddy, and Namecheap with its sister company Spaceship. Porkbun wrote this article, so weigh it accordingly. We used only each company's own documentation, as published on October 8, 2026, and we point out where the others do things better than we do.

Ranked by overall score out of 10 (how we scored is below). Differences under half a point are within the margin of judgement, so read close scores as a tie. Long story short, Porkbun has the best API for agentic use.

• #1 Porkbun, 9.8/10: covers the most of what an unattended agent needs in one place: every purchase takes an exact price and can be rehearsed first, retries cannot double-charge, spending is capped per month, there is a full sandbox and credential-free mocks, and an agent can pay for a purchase directly by card (held until it succeeds) or in USDC. API keys can be limited to certain domains and IP addresses and made read-only or unable to buy. Where it is behind: Name.com covers more domain events with its webhooks, and premium names can only be bought on the website.
• #2 GoDaddy, 6.2/10: rebuilt its developer platform in 2026, and its new registration flow is one of the safest anywhere: a quote locks the price, fees must be acknowledged and an idempotency key is required. But that flow covers only 2 of its 67 operations; renewals and transfers still use older APIs with no price check. Its official AI connector is read-only, and there are no spending caps or domain webhooks.
• #3 Name.com, 6.1/10: has excellent machine-readable docs, a generous sandbox, signed webhooks for domain events, and a price field and idempotency key on registration. Keys have no scopes, errors have no codes, its AI connector exposes every endpoint without a read-only mode, and purchases are paid from prepaid credit funded by wire or ACH.
• #4 Spaceship, 5.9/10: (Namecheap's sister company) has a modern API with the best key scopes here: a key without the billing scope can manage domains but never buy. It has no sandbox, no dry runs, no price field on purchases and no idempotency keys, so a purchase cannot be rehearsed or safely retried.
• #5 Cloudflare, 5.3/10: has the broadest infrastructure behind the domain (DNS, Workers, Pages, storage), and its hosted AI connector covers the registrar. The registrar API itself is new and narrow: no renewal endpoint, no price confirmation on purchases, and charges go straight to the card on file. And a domain registered there has to use Cloudflare's own DNS: Cloudflare's FAQ says "all domains on Cloudflare Registrar use Cloudflare nameservers", and that to use any others "you will have to move your domain to another Registrar."
• #6 Namecheap, 4.8/10: has the most careful AI connector design of the group (a purchase must be confirmed against a quoted price, and a second connector cannot spend money at all), but its underlying API is an older XML interface with no published specification, and most new accounts cannot switch it on yet.

Each registrar is scored 0 to 3 on 14 data points: 0 when we found nothing in its documentation, 1 for partial or manual-only support, 2 when it is documented and an agent can use it, 3 when it is also machine-readable and safe by default. "Agent payments" means an agent can pay for a single purchase itself through a machine-to-machine payment protocol such as x402 or Stripe MPP; charging an account balance or a card saved in the account does not count. Where a point can be checked in a registrar's published API specification, we checked it there; the reason for every score is under "Why each score" below. The points that matter most for an unattended agent count three times. The total is scaled to 10 and shown to one decimal; differences under half a point are within the margin of judgement.

"Not documented" means we could not find it in that company's documentation, not that it definitely does not exist.

Can it overspend? The agent should state the price it was told and the purchase should fail if the price is different. Porkbun requires that on every registration, renewal and transfer; GoDaddy does it with a time-limited quote; Namecheap's AI connector does it with a confirmation step. Elsewhere the agent has to be trusted to check. A monthly cap on top (Porkbun) or a purchase cap (Name.com) limits the damage if it goes wrong anyway.

Can a retry buy twice? Networks drop. An agent that never saw the answer will try again, and without an idempotency key that can mean a second registration or a second charge. Porkbun accepts a key on every write, GoDaddy requires one on new registrations, Name.com supports one on registration, and Cloudflare asks agents not to retry a registration that is still pending.

What if it pays and the order fails? Paying from prepaid credit is the safest default, because a failed order simply returns the credit. Paying a card directly is riskier unless the card is only held: Porkbun's card payments are authorized first and charged only if the purchase succeeds. Cloudflare and Spaceship charge the card on file, and their docs do not say what happens if the registration then fails.

Can you leave? An agent will happily register a domain wherever it is pointed, and the choice can be hard to undo. Most registrars let you point a domain at any DNS provider. Cloudflare Registrar does not: its domains must use Cloudflare's nameservers for as long as they stay there, so changing DNS provider means transferring the domain to another registrar (https://developers.cloudflare.com/registrar/faq/).

Can you keep an agent from buying at all? Spaceship (a key without the billing scope), GoDaddy and Cloudflare (scoped tokens) can do this at the key level. Namecheap offers a connector that cannot spend. Porkbun keys can be set to "Manage, but no purchases" or read-only, and the monthly cap applies to every key.

1. A machine-readable description of the API (OpenAPI, llms.txt  ) that says which calls cost money or delete things.
2. A required price on every purchase, and a way to rehearse it without buying.
3. Idempotency keys, so retries are safe.
4. A sandbox, so the agent can be tested before it touches a real account.
5. A spending cap you set, separate from what the agent is told.
6. Errors that say what to do next, not just what went wrong.
7. A way to give the agent only the access it needs.

Every score with the evidence behind it. Paths are from each registrar's published API specification; "Not found in the docs" means we could not find it in the company's own documentation, not that it cannot exist.

• Who can use the API: 3. Any account can use it; purchases need a verified email and phone.
• Least-privilege keys: 3. Keys can be limited to specific domains and IP addresses and given permission scopes (read-only, no purchases, or any of eight scopes); every operation in the spec names its scope (x-porkbun-scope), and each AI connector connection gets its own key.
• Machine-readable docs: 3. OpenAPI spec with 136 operations, every one carrying x-porkbun-agent metadata (safe, cost, destructive, reversible, needs confirmation), plus llms.txt, llms-full.txt and task guides.
• AI connector (MCP): 3. Hosted (OAuth) and local servers with read/destructive annotations, and restricted endpoints that leave out purchasing and secret-returning tools.
• Safe purchases and writes: 3. Every purchase takes the exact price (cost, or acknowledgedCost for hosting) and fails if it differs; 77 operations accept Idempotency-Key; dry runs on purchases, DNS and nameserver changes.
• Actionable errors: 3. 134 of 136 operations declare an error code; responses also carry next_action with what to do (retry, fix the request, add funds, ask the user).
• Rate-limit signalling: 3. The spec declares X-RateLimit-* headers on responses and 429 with Retry-After on every authenticated operation.
• Sandbox and mocks: 3. Full sandbox with test credit (pk1_sb_ keys, /sandbox/* operations) and credential-free mock responses (/mock).
• Spending control: 3. Monthly API spend limit ($100 until the owner sets one), low-balance alerts and auto top-up controls, and a key without the purchase and funding scopes can manage everything but never spend.
• Agent payments: 3. A single purchase can be paid directly in USDC over x402 or by card from a Stripe Link wallet (MPP), the card held and charged only if the purchase succeeds.
• Event notifications: 2. Signed webhooks with delivery logs (12 /webhook operations); events cover registration, renewal, expiry, completed transfers, DNS changes, Cloudflare moves and account verification, with each event's payload documented.
• Registrar coverage: 3. Register, renew, transfer in and out, contacts, nameservers, glue, DNSSEC, URL forwarding and a price list (/pricing/get) are all in the spec, plus buying expired-domain closeouts and searching taken names for sale across aftermarkets (/aftermarket/search). Premium and aftermarket purchases are website-only.
• Beyond domains: 2. DNS, email forwarding and mailboxes, SSL, static and WordPress hosting, and moving domains to the customer's Cloudflare.
• Use any DNS provider: 3. Any nameservers (/domain/updateNs).

GoDaddy: 6.2 out of 10

• Who can use the API: 2. Needs a domain or a qualifying plan, and paid calls need a payment method or prepaid balance; an older official page still says 50 domains.
• Least-privilege keys: 2. Scoped personal access tokens with expiry for the v3 API; no per-domain or IP limits found, and v1/v2 still use the older key.
• Machine-readable docs: 2. OpenAPI specs (67 operations across v1, v2, v3), llms.txt and per-page agent notes, but no metadata in the specs, three API versions, and contradictions between pages.
• AI connector (MCP): 2. Hosted, correctly annotated, but read-only: search and availability only. Changes go through a separate command-line tool.
• Safe purchases and writes: 2. New registrations are very safe: a quote locks the price (quoteToken), fees must be acknowledged, and an idempotency key is required; validate endpoints exist. But only 2 operations take an idempotency key, and v1 renewal and transfer take no price.
• Actionable errors: 3. 53 of 67 operations declare an error code, with fields and a retry time.
• Rate-limit signalling: 2. The docs describe rate-limit headers on every response but give two different limits; the spec declares only Retry-After.
• Sandbox and mocks: 2. A test environment (OTE, in the spec's servers), though the docs say not every API has one; no mocks.
• Spending control: 1. Prepaid balance (Good as Gold) can stand in for a card; no caps or budgets found.
• Agent payments: 0. Not found in the docs: card on file or prepaid balance; purchases are not compatible with EU strong customer authentication.
• Event notifications: 1. A polled notification queue (/v2/customers/{customerId}/domains/notifications), not webhooks.
• Registrar coverage: 2. Register, renew, transfers in and out, contacts, nameservers and URL forwarding, but the specs have no DNSSEC or price-list operations.
• Beyond domains: 2. DNS, Node.js hosting, mailboxes, SSL and commerce.
• Use any DNS provider: 3. Any nameservers (PUT /domain-names/{domain-name}/nameservers).

Name.com: 6.1 out of 10

• Who can use the API: 3. Any account; accounts with two-factor sign-in turn API access on in settings (authentication guide).
• Least-privilege keys: 1. One username and token per environment over HTTP Basic auth; no scopes, domain limits, IP allowlist or OAuth found.
• Machine-readable docs: 2. OpenAPI 3.1 spec (72 operations) with llms.txt, llms-full.txt and Markdown pages, but no per-operation cost or destructive markers.
• AI connector (MCP): 2. A local MCP server that makes one tool per endpoint, defaulting to the test environment, plus a hosted docs-search server; no read-only mode or annotations.
• Safe purchases and writes: 2. Registration, renewal and transfer accept purchasePrice, enforced when sent (required only for premium names); idempotency key on registration but not renewal or transfer; no dry run.
• Actionable errors: 1. Errors are a message and details with the HTTP status; the spec declares no error code field.
• Rate-limit signalling: 2. Limits are documented (20 per second, 3,000 per hour); the spec declares only X-RateLimit-Reset.
• Sandbox and mocks: 2. Sandbox (api.dev.name.com, the spec's default server) with $100,000 of test credit; no mocks.
• Spending control: 2. Prepaid credit only, with a default $2,500 purchase cap (funding guide); no monthly budget.
• Agent payments: 0. Not found in the docs: credit is added by wire or ACH.
• Event notifications: 3. Webhook subscriptions over the API (/core/v1/notifications), signed, covering expiry, transfers, registry rejection and compliance notices.
• Registrar coverage: 3. Register, renew, transfers, contacts, nameservers, vanity nameservers, DNSSEC, URL and email forwarding and price lists are all in the spec.
• Beyond domains: 1. DNS and forwarding; no hosting, SSL or mailboxes found.
• Use any DNS provider: 3. Any nameservers (POST /core/v1/domains/{domainName}:setNameservers).

Spaceship: 5.9 out of 10

• Who can use the API: 3. No eligibility requirement found.
• Least-privilege keys: 3. Per-key scopes declared on all 50 operations; purchases need domains:billing, so a key can manage without buying.
• Machine-readable docs: 2. Downloadable OpenAPI spec with scopes and code samples on every operation, but no llms.txt (404) and no changelog.
• AI connector (MCP): 1. Hosted connector; its help page (July 2026) says registration bills the default payment method and is irreversible, with no confirmation step documented.
• Safe purchases and writes: 0. The registration request (POST /v1/domains/{domain}) has no price field, no operation takes an idempotency key, and there is no dry run.
• Actionable errors: 3. RFC 7807 problem responses with a typed spaceship-error-code header on every operation.
• Rate-limit signalling: 3. The spec declares X-RateLimit-* and Retry-After, with a limit per operation.
• Sandbox and mocks: 0. No sandbox or mocks found.
• Spending control: 2. A key without the billing scope cannot buy; no caps or budgets.
• Agent payments: 0. Not found in the docs: the default payment method.
• Event notifications: 1. No webhooks; asynchronous operations are polled (/v1/async-operations/{operationId}).
• Registrar coverage: 2. Register, renew, restore, transfer in, contacts and nameservers; the spec has no DNSSEC, forwarding or price-list operations.
• Beyond domains: 2. DNS, container hosting (Hyperlift) and a domain marketplace.
• Use any DNS provider: 3. Any nameservers (PUT /v1/domains/{domain}/nameservers).

Cloudflare: 5.3 out of 10

• Who can use the API: 3. Any account with Registrar write permission (registrar API guide).
• Least-privilege keys: 3. Scoped API tokens, limited by zone, account, IP address and expiry, and OAuth for third-party apps (token and OAuth docs).
• Machine-readable docs: 2. Large public OpenAPI spec and llms.txt files, but no read-only, destructive or confirmation markers on the registrar operations, and the guide contradicts the reference on transfers.
• AI connector (MCP): 2. The hosted MCP server covers the registrar through OAuth or a token, but has no read-only mode or per-tool annotations; restriction comes only from the token's permissions.
• Safe purchases and writes: 1. The registration request (POST /accounts/{account_id}/registrar/registrations) has no price field and no idempotency header; the docs say to check the price first and treat the domain name as the idempotency key.
• Actionable errors: 2. All 26 registrar operations declare structured error codes, without a suggested next step.
• Rate-limit signalling: 2. Rate-limit headers are documented in the limits guide but not declared on the registrar operations in the spec.
• Sandbox and mocks: 2. A registrar sandbox (10 /registrar-sandbox operations) that charges nothing; it has no transfer-in, and there are no mocks.
• Spending control: 0. Not found in the docs: no cap or budget; registrations charge the account's default payment method.
• Agent payments: 0. Not found in the docs: card on file only, and successful registrations are non-refundable.
• Event notifications: 1. No registrar webhooks; status is polled (registration-status, transfer-in-status).
• Registrar coverage: 1. Register and transfer in only: the spec has no renewal, nameserver, contact-update or DNSSEC operation for registrar domains, and premium names are not supported.
• Beyond domains: 3. The broadest platform here: DNS, Workers, Pages, R2, email routing and much more.
• Use any DNS provider: 0. "All domains on Cloudflare Registrar use Cloudflare nameservers"; using others means moving to another registrar (Registrar FAQ).

Namecheap: 4.8 out of 10

• Who can use the API: 1. Production API access needs 20+ domains, a $50 balance or $50 spent in two years (API FAQ).
• Least-privilege keys: 1. The key goes in the query string, every caller IP must be allowlisted in advance (IPv4 only), and there are no scopes.
• Machine-readable docs: 1. No published API spec or llms.txt; HTML reference pages whose changelog stops in 2018.
• AI connector (MCP): 3. Hosted connectors with sign-in: purchases need a confirmation tied to the quoted price, and a second connector cannot spend money at all.
• Safe purchases and writes: 1. The AI connector confirms prices; the underlying API documents no idempotency or dry run.
• Actionable errors: 2. Numeric error codes per command, without a suggested next step.
• Rate-limit signalling: 1. Limits documented (50 a minute, 700 an hour, 8,000 a day) with no headers.
• Sandbox and mocks: 2. Sandbox (api.sandbox.namecheap.com); no mocks.
• Spending control: 2. Key-based API purchases use the prepaid balance; the main AI connector charges a saved card or account funds, but only after a confirmation bound to the price, and a second connector cannot spend at all. No caps or budgets.
• Agent payments: 0. No agent payment protocol found: purchases charge account funds or, through the AI connector, a saved payment method.
• Event notifications: 0. Not found in the docs.
• Registrar coverage: 2. Register, renew, transfers, contacts, nameservers, URL and email forwarding and pricing; DNSSEC not found.
• Beyond domains: 1. DNS and SSL certificates.
• Use any DNS provider: 3. Any nameservers (domains.dns.setCustom).

On October 8, 2026 we read each company's own developer documentation, llms.txt   files, help-center articles and changelogs, and checked every point a specification can show (price fields on purchases, idempotency keys, validate and dry-run operations, error codes, rate-limit headers, key scopes, and which operations exist) against the API specification each company publishes: Porkbun (https://porkbun.com/api/json/v3/spec), Name.com (https://docs.name.com/api/v1/namecom.api.yaml), GoDaddy (https://developer.godaddy.com/openapi/domains-v3.json, plus the v1 and v2 files), Cloudflare (https://github.com/cloudflare/api-schemas) and Spaceship (https://docs.spaceship.dev/, "Download OpenAPI specification"). Namecheap does not publish one, so its scores rest on its documentation pages. We did not use third-party reviews, forums or unofficial libraries. Where a company's pages contradicted each other, we went with the most recent official source. Namecheap updated its AI connector documentation on October 8, 2026, so we rechecked how its purchases are paid that day. APIs change quickly, and several of these launched or changed in the last few months; if you see something out of date, tell us and we will correct it.

Porkbun's API documentation: https://porkbun.com/api/json/v3/documentation · For AI agents: https://porkbun.com/llms.txt · AI connector: https://porkbun.com/mcp