Porkbun MCP Server

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.

Status: v0.18.0 — full Porkbun v3 coverage (domains, DNS, SSL, hosting, webhooks) plus an isolated sandbox/test mode: use a pk1_sb_ key and every tool runs against a simulated environment with fake credit — no real registry actions, DNS changes, or charges. Sandbox delivers signed webhooks too, and a credential-free mock server returns schema-accurate example responses for any endpoint. Also provisions Cloud for WordPress and mints WordPress REST API credentials so an agent can manage the site it just created.

What's included (64 tools)

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.

Domain lifecycle writes (spend account credit)

Domain settings writes (free)

DNS / DNSSEC / URL-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).

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). 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.

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

Most MCP-aware editors use a similar mcpServers config block. See your client's documentation for the exact location.

Get API keys

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

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 two optional restrictions, set via the gear icon next to the key in porkbun.com/account/api:

• 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.

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. 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.git
cd Porkbun-MCP
npm install
npm run build
npm 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

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.
• 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

• Porkbun API documentation
• Privacy policy
• Model Context Protocol
• Issues / contributions