Porkbun (official)

Porkbun MCP Server (official)

[npm version] [npm downloads] [License: MIT]

The official MCP server from Porkbun, built and maintained by Porkbun (by Owen Borseth, Porkbun's CTO). It is published on npm as @porkbunllc/mcp-server and hosted by Porkbun at https://mcp.porkbun.com/mcp. Other "Porkbun MCP" projects on GitHub and in MCP directories are community wrappers around the public API; they are not made or supported by Porkbun. In the official MCP Registry it is listed as com.porkbun/mcp, a name the registry grants only to whoever proves control of porkbun.com; community projects appear under io.github.* names.

A Model Context Protocol server that exposes the Porkbun v3 API as native tools for AI agents — Claude Desktop, Cursor, Cline, and any other MCP-compatible client.

Setup guide, client configs and the full tool list: porkbun.com/mcp

No install: use the hosted connector. Porkbun runs this server at https://mcp.porkbun.com/mcp. Add that URL as a custom connector in ChatGPT or Claude (or claude mcp add --transport http porkbun https://mcp.porkbun.com/mcp in Claude Code), sign in to Porkbun and approve. No API key to copy. (An app that asks for an OAuth client ID and secret can register one at https://porkbun.com/oauth2/register with token_endpoint_auth_method: client_secret_post. A client that can't do OAuth can send the account's API key pair as X-API-Key + X-Secret-API-Key headers instead, or as a single secret, Authorization: Bearer pk1_…:sk1_…, if it can store only one.) Steps per client: Connect ChatGPT or Claude. How it is deployed: deploy/README.md. The ChatGPT and Claude directory listings use a narrower variant, /mcp/no-purchases (no tool that spends money or returns a secret); it changes which tools are offered, not what a connection may do.

Status: full Porkbun v3 coverage (domains, DNS, SSL, hosting, webhooks; current version on the npm badge above). Also runs hosted at https://mcp.porkbun.com/mcp for ChatGPT and Claude, with sign-in instead of API keys (clients that can't do OAuth can send an API key pair). Provisions Cloud for WordPress and edits the site's pages, posts and images directly (wordpress_request, wordpress_upload_media: no WordPress password needed, so it works from ChatGPT and Claude), or mints REST API credentials for your own code. Builds and edits Link in Bio pages. Moves domains to a customer's own Cloudflare account and then manages those records, the proxy and zone settings. An isolated sandbox: a pk1_sb_ key runs every tool against a simulated environment with fake credit — no real registry actions, DNS changes or charges — and still delivers signed webhooks. A credential-free mock server returns schema-accurate example responses for any endpoint.

What's included

Read tools (free, no spend, no state changes)

The list_doc_topics / read_doc / search_docs tools let an agent ground itself in Porkbun's own documentation (the /llms Markdown surface) mid-conversation — no web browsing required, and no API credentials needed. You can add the server purely to research the API, then supply keys when you're ready for live operations.

Account funding (charges a saved card, not credit)

Domain lifecycle writes (spend account credit)

Domain settings writes (free)

DNS / DNSSEC / URL- and email-forwarding / glue writes (free)

Secure Static Hosting

Cloud for WordPress

create_hosting with a CLOUDWORDPRESS… sku provisions a managed WordPress site instead of static hosting (the file tools don't apply — manage it through WordPress).

Link in Bio (a single page of links on a domain)

Most .com domains registered at Porkbun come with a free page. create_link_in_bio turns on a free one (50 links); create_hosting with PIXIELINKSM1 / PIXIELINKSY1 buys a paid plan (1000 links, scheduling, animation, passcode protection, analytics IDs) and upgrades a free page in place, content included. Edits show up at once in the page and in the editor on porkbun.com.

Cloudflare connect (move domains to the customer's own Cloudflare account)

Connecting the Cloudflare account itself is a human step — Cloudflare's consent screen has to be completed in a browser — so get_cloudflare_connection hands you a URL to show your user, then acts as the poll target. Everything after that is automated.

• get_cloudflare_connection — connected or not, and where to send the human if not (poll this)
• list_cloudflare_inventory — every domain with its eligibility and a plain-English reason
• preview_cloudflare_move — exactly which records a move would copy or drop, queueing nothing
• connect_domains_to_cloudflare — queue one or many (async: returns queued, never connected)
• get_cloudflare_queue / get_cloudflare_domain_status — progress, and the audit trail
• retry_cloudflare_domain / rollback_cloudflare_domain — re-queue a failure, or restore Porkbun nameservers
• get_cloudflare_records / create_cloudflare_record / edit_cloudflare_record / delete_cloudflare_record — manage DNS in the zone that actually answers once a domain has moved
• set_cloudflare_proxy — turn the orange cloud on or off, per record (a move always imports DNS-only, on purpose)
• get_cloudflare_zone — Cloudflare's own zone state, plus nameserver-drift detection
• get_cloudflare_zone_settings / set_cloudflare_zone_settings — SSL mode and friends
• disconnect_cloudflare — forget the grant (domains already moved keep working)

Sandbox / test mode

Use a sandbox API key (public key prefixed pk1_sb_, secret sk1_sb_) and every tool above runs against an isolated test environment — same server, you just swap the key. Registrations, renewals, transfers, DNS, contacts, glue, and DNSSEC are all simulated against a separate sandbox datastore: no real registry actions, no DNS changes, no certificates, and no charges. Your sandbox account starts with fake account credit, availability/pricing reflect the real catalog, and every response includes "sandbox": true. Create a sandbox key on porkbun.com/account/api. Or mint one instantly with create_sandbox_key — no signup, no credentials. (Hosting and email endpoints aren't simulated and return SANDBOX_UNSUPPORTED with a sandbox key.)

Mock server (no credentials)

mock_call returns a schema-accurate example response for any endpoint with no key required — nothing to set up. Pass a path like domain/listAll or dns/create/example.com (omit it to list every mockable endpoint), or set error: true for the error shape. Responses touch no datastore and match the live API's shape exactly, so you can build and test client code before you have any credentials.

Webhook writes (free)

Porkbun POSTs a signed JSON payload to your endpoint when subscribed events occur (domain.registered, domain.renewed, domain.transfer.completed, domain.expiring, dns.record.created|updated|deleted, cloudflare.connect.completed|failed, account.verification.code_sent|completed; fields per event: https://porkbun.com/llms/webhooks). Verify the X-Porkbun-Signature header — it's sha256= + HMAC-SHA256 of {timestamp}.{rawBody} keyed by the endpoint secret, where {timestamp} is the X-Porkbun-Webhook-Timestamp header.

Claude plugin

plugin/ is a Claude plugin (claude.ai, Cowork and Claude Code): the hosted connector at https://mcp.porkbun.com/mcp/no-purchases plus four skills: publish-website (publish a site Claude builds to Porkbun Secure Static Hosting instead of giving upload steps), change-dns-safely, diagnose-domain (site down, mail bouncing, DNS not updating) and move-dns-to-porkbun. It holds no code. Install it in Claude Code with /plugin marketplace add oborseth/Porkbun-MCP then /plugin install porkbun@porkbun (the repo root carries a marketplace file, .claude-plugin/marketplace.json, pointing at ./plugin), or try a working copy with claude --plugin-dir ./plugin. Raise version in plugin/.claude-plugin/plugin.json with every change to the folder.

Gemini CLI

gemini extensions install https://github.com/oborseth/Porkbun-MCP

Adds the hosted server (gemini-extension.json at the repo root) and a short GEMINI.md with usage rules. Then run /mcp auth porkbun to sign in with your Porkbun account. Keep version in gemini-extension.json in step with package.json: the extension gallery picks up tagged releases.

Install

You'll need Node.js 18 or newer.

npx -y @porkbunllc/mcp-server

This downloads and runs the latest version on demand. No global install needed.

Configure your MCP client

Claude Desktop

Add this to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{  "mcpServers": {    "porkbun": {      "command": "npx",      "args": ["-y", "@porkbunllc/mcp-server"],      "env": {        "PORKBUN_API_KEY": "pk1_your_public_key_here",        "PORKBUN_SECRET_API_KEY": "sk1_your_secret_key_here"      }    }  }}

Restart Claude Desktop. Porkbun tools should appear in the tool picker.

Docs-only, no keys: the documentation tools (search_docs, read_doc, list_doc_topics) work without credentials, so you can omit the env block entirely to use the server just for API research. The authenticated tools return a clear "set PORKBUN_API_KEY" message until you add keys.

Cursor / Cline / Continue

Cursor, one click: Add Porkbun to Cursor adds the hosted server (https://mcp.porkbun.com/mcp); you sign in with Porkbun on first use, no API key. If the link doesn't open from here (some sites strip cursor:// links), use the button on https://porkbun.com/mcp.

For the local server, most MCP-aware editors use the same mcpServers config block as above. See your client's documentation for the exact location. Agents installing it can follow llms-install.md.

Get API keys

Create API keys at porkbun.com/account/api. You'll need both the public key (pk1_…) and the secret key (sk1_…).

Or let the assistant get one: the server starts without keys, and request_api_key (no credentials needed) returns a link where you approve a new key, optionally with only some permissions; retrieve_api_key then hands the assistant the key pair once. Put it in the config below and restart the server.

By default, API access is opt-in per domain. To use the API to manage all your domains, enable the "Opt In All Domains" toggle in the same settings page. Otherwise you'll need to enable API access for each domain individually under Domain Management.

Recommended: scope the key to your agent

Each API key supports three optional restrictions, set at porkbun.com/account/api when you create the key, or later with the gear icon next to it:

• Allowed IPs — one entry per line; supports bare IPv4/IPv6 plus CIDR ranges (198.51.100.0/24, 2001:db8::/32). Requests from other IPs fail with HTTP 403 IP_NOT_ALLOWED before any other check runs.
• Allowed domains — one entry per line, exact match. Operations against domains not in the list fail with HTTP 403 DOMAIN_NOT_ALLOWED.
• Permissions — Full access, Read-only, Manage, but no purchases, or custom scopes (read, dns, domains, email, hosting, purchase, funding, account). A tool call outside them fails with HTTP 403 INSUFFICIENT_SCOPE and changes nothing; ping shows the key's scopes.

Empty fields = no restriction (matches current behavior). When you give an MCP server a key, the recommended pattern is:

1. Create a fresh key dedicated to the agent (not your master key).
2. List the specific domains the agent should manage.
3. Give it only the permissions it needs (often Manage, but no purchases).
4. If you know the agent's egress IP, list it too.

The blast radius of an accidentally-leaked key drops to "operations on these domains from this IP" instead of "anything on the account."

Environment variables

Local development

git clone https://github.com/oborseth/Porkbun-MCP.gitcd Porkbun-MCPnpm installnpm run buildnpm start          # or: node dist/index.js

The server speaks JSON-RPC 2.0 over stdio. Smoke test from a shell:

(printf '%s\n' \  '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}' \  '{"jsonrpc":"2.0","method":"notifications/initialized"}' \  '{"jsonrpc":"2.0","id":2,"method":"tools/list"}') \  | PORKBUN_API_KEY=pk1_… PORKBUN_SECRET_API_KEY=sk1_… node dist/index.js

Paying for purchases directly in USDC (x402)

register_domain, renew_domain, transfer_domain, buy_closeout, create_hosting, create_mailbox and renew_mailbox take pay_with_usdc: true, which skips account credit entirely. The API answers with an x402 payment requirement (USDC on Base, the exact price), and:

• with PORKBUN_X402_PRIVATE_KEY set, this server signs it and the purchase completes in the same tool call. It only signs terms that are exactly the quoted price in USDC on Base, and never above PORKBUN_X402_MAX_CENTS;
• without it (and always on the hosted connector, which holds no one's key), the tool returns status: PAYMENT_REQUIRED with a checkoutId, an x402Url and a payUrl. Pay the x402Url with a wallet tool (for example Coinbase's awal x402 pay <x402Url> --scheme auth-capture) or have the user pay the payUrl page, then call the same tool again with usdc_checkout_id.

If a purchase fails after payment, the payment is not sent back to the wallet: it stays on the Porkbun account as credit (the error says so, with the new balance), ready to retry from credit or spend on anything else. Guide: Pay with USDC (x402).

Paying for purchases by card, with a hold (Stripe MPP)

The same five tools take pay_with_card: true for a user with a Stripe Link agent wallet. The tool returns status: PAYMENT_REQUIRED with a single-use payUrl and a cardPaymentId; pay the link with an MPP wallet tool (link-cli mpp pay <payUrl> -X POST --context "..."; the user approves in Link), which only authorizes the card. Call the same tool again with card_payment_id: the card is charged if the purchase succeeds, and the hold is released (nothing charged) if it fails. Guide: Pay with the user's card (MPP).

Money parameters are in cents, and say so

Every money parameter ends in _cents and takes integer US cents: cost_cents: 1108 is $11.08, amount_cents: 803 is $8.03. The unit is in the name because some clients build their approval prompt from the raw arguments, and a bare amount: 803 was shown to a user as "$803". The old names (cost, amount, threshold, acknowledged_cost, price_min, price_max) are still accepted in the same unit; sending both names with different values is refused before anything reaches the API.

Reliability

Write operations automatically attach a per-call Idempotency-Key header. Retried calls within 24 hours return the cached response, so your agent can safely retry on network errors without double-charging or double-registering.

Privacy

This MCP server is a thin client that runs locally (on your machine, or wherever you host it) and relays your requests directly to the Porkbun API over HTTPS. It does not add any data collection of its own:

• What it sends, and to whom. Your API key/secret and the arguments of each tool call are sent only to https://api.porkbun.com (and, for the credential-free documentation and mock tools, to https://porkbun.com). Nothing is sent anywhere else.
• Storage. The server keeps your credentials in memory for the lifetime of the process (read from environment variables); it does not write them to disk, log them, or cache your data.
• Hosted connector. At mcp.porkbun.com the same code runs on Porkbun's infrastructure. It stores no API keys: each request carries the user's OAuth access token (or, from clients that can't do OAuth, their API key pair), which is forwarded to the Porkbun API and kept in memory only briefly (a 30-second validity cache, keyed by a hash). Request logs record method, path, status and timing, never tokens, keys or request bodies.
• No telemetry. There is no analytics, tracking, or third-party sharing performed by this connector.
• Data you access through it (domains, DNS, contacts, billing, etc.) is your Porkbun account data, handled by Porkbun under its policy.

Full data-handling, retention, third-party, and contact details are in Porkbun's privacy policy: https://porkbun.com/legal/agreement/privacy_policy

License

MIT

Links

• Setup guide and tool list
• Porkbun API documentation
• Privacy policy
• Model Context Protocol
• Issues / contributions