The Porkbun MCP Server exposes the Porkbun domain registrar API as AI-accessible tools (46 total), enabling full domain lifecycle management, DNS configuration, and more. Spend-based operations auto-attach idempotency keys to prevent double-charging.
Account & Status
ping – Verify API connectivity and credentials
get_balance – Check account credit balance
get_api_settings – View spend limits, low-balance alerts, auto top-up config, and MTD spend
Domain Research & Pricing
check_domain – Check availability and get registration/renewal/transfer pricing
get_pricing – Browse pricing for all TLDs (no auth required)
list_marketplace – Browse aftermarket domains for sale
get_registration_requirements – Get TLD-specific registration requirements
Domain Management
list_domains – Paginate through account domains with rich filtering
get_domain – Get full metadata for a single domain
get_nameservers / update_nameservers – View or replace nameservers
update_auto_renew – Enable or disable auto-renewal
Domain Lifecycle (incur cost)
register_domain – Register a new domain (requires price confirmation)
renew_domain – Renew an existing domain
transfer_domain – Initiate an inbound transfer with an EPP/auth code
list_transfers / get_transfer_status – Monitor in-progress transfers
DNS Records
list_dns_records, create_dns_record, update_dns_record, delete_dns_record
DNSSEC
list_dnssec_records, create_dnssec_record, delete_dnssec_record
URL Forwarding
list_url_forwards, create_url_forward, delete_url_forward
Glue Records
list_glue_records, create_glue_record, update_glue_record, delete_glue_record
SSL Certificates
get_ssl_bundle – Retrieve the free Porkbun-issued SSL certificate bundle
Webhooks
list_webhooks, get_webhook, create_webhook, update_webhook, rotate_webhook_secret, test_webhook, resend_webhook, delete_webhook, list_webhook_deliveries, get_webhook_delivery, get_webhook_event_types
API Documentation (no auth required)
list_doc_topics, read_doc, search_docs – Browse and search the Porkbun API reference
Allows interaction with the Porkbun API, providing tools for domain management including checking availability, pricing, DNS records, DNSSEC, URL forwarding, glue records, domain registration, renewal, transfer, and account settings.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Porkbun MCP Server check if example.com is available for registration"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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.17.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.
Read tools (free, no spend, no state changes)
Tool | Description |
| Verify API connectivity and credentials |
| Check availability and pricing for a single domain |
| TLD registration requirements as JSON Schema — is it API-registerable, the create payload, and registry eligibility fields (.us nexus, .ca legal type, …) |
| Get registration/renewal/transfer pricing for all TLDs (no auth needed) |
| Browse the Porkbun aftermarket — filter by TLD, max price, name substring |
| Paginate through domains; filter by tld, expiry, auto-renew, API access |
| Get metadata for a single domain in the account |
| Get account credit balance |
| Get monthly spend limit, low-balance alert, auto top-up config, MTD spend |
| Get current nameservers for a domain |
| List DNS records for a domain |
| List DNSSEC DS records published at the registry |
| List URL forwarding rules for a domain (incl. exact |
| List glue records (host-to-IP mappings) for a domain |
| List in-progress and recent inbound transfers |
| Get status of a specific inbound transfer |
| Retrieve the free Porkbun-issued SSL bundle for a domain |
| Get a domain's four contacts (registrant/admin/tech/billing) with current values |
| List the event types a webhook endpoint can subscribe to |
| List webhook endpoints (URL, events, status, delivery health, secret) |
| Get a single webhook endpoint by id |
| List recent delivery attempts (status, attempts, HTTP, error); ~30-day history |
| Get a single delivery incl. the full signed payload |
| List Porkbun API doc topics (the docs index) |
| Read a doc page as Markdown ( |
| Keyword-search the full reference; returns the most relevant sections |
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)
Tool | Description |
| Register a new domain — call |
| Renew an existing domain |
| Initiate an inbound transfer (returns transferId; takes 5-7 days) |
Domain settings writes (free)
Tool | Description |
| Turn auto-renewal on or off |
| Replace the nameserver list for a domain (full replace, not append) |
| Edit domain contacts — any subset of registrant/admin/tech/billing; a registrant change fires the new-owner notice email. On address-validated TLDs ( |
DNS / DNSSEC / URL-forwarding / glue writes (free)
Tool | Description |
| Create a new DNS record (A, AAAA, CNAME, MX, TXT, etc.) |
| Update an existing DNS record by its ID |
| Delete a DNS record by its ID |
| Submit a DNSSEC DS record to the registry |
| Remove a DNSSEC DS record by key tag |
| Create a URL forwarding rule (permanent/temporary/masked; optional |
| Delete a URL forwarding rule by ID |
| Create a glue record (host-to-IP mapping at the registry) |
| Replace the IP list for a glue record |
| Delete a glue record by host |
Secure Static Hosting
Tool | Description |
| List API-provisionable hosting products + plans, with price (cents), interval, trial length, features |
| Provision hosting for a domain by |
| Get hosting status for a domain (plan, trial, expiry, auto-renew) |
| Upload static files (base64, ≤10MB/call) to a domain's hosting |
| List files under a path in a domain's hosting |
| Delete a file (or empty dir) from a domain's hosting |
| Create a directory (and missing parents) in a domain's hosting (deploy auto-creates dirs in a file path) |
| Deprovision (cancel) hosting for a domain |
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.)
Tool | Description |
| No credentials needed — instantly mint a throwaway sandbox key pair ( |
| Sandbox only — grant fake account credit (default $1000) so paid ops can keep being exercised after funds run out |
| Sandbox only — wipe the sandbox account's domains/DNS/orders/credit and re-grant $1000, for a clean slate between test runs |
| Sandbox only — fire a sample signed webhook event of any type (incl. cron-driven |
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.
Tool | Description |
| No credentials needed — schema-accurate example response for any endpoint ( |
Webhook writes (free)
Tool | Description |
| Register an HTTPS endpoint to receive signed event payloads; returns the signing secret |
| Change an endpoint's URL, events, or status (ACTIVE/DISABLED) |
| Generate a new signing secret for an endpoint |
| Send a |
| Re-queue a past delivery (reuses the original event id) |
| Delete a webhook endpoint |
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.
Related MCP server: domain-suite-mcp
You'll need Node.js 18 or newer.
npx -y @porkbunllc/mcp-serverThis downloads and runs the latest version on demand. No global install needed.
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 theenvblock entirely to use the server just for API research. The authenticated tools return a clear "set PORKBUN_API_KEY" message until you add keys.
Most MCP-aware editors use a similar mcpServers config block. See your client's documentation for the exact location.
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.
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:
Create a fresh key dedicated to the agent (not your master key).
List the specific domains the agent should manage.
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."
Variable | Required | Purpose |
| for live ops | Your Porkbun public API key. Omit to use only the credential-free documentation tools. |
| for live ops | Your Porkbun secret API key. Omit to use only the credential-free documentation tools. |
| no | Override the API base URL (e.g. for testing against |
| no | Override the docs host used by the |
git clone https://github.com/oborseth/Porkbun-MCP.git
cd Porkbun-MCP
npm install
npm run build
npm start # or: node dist/index.jsThe 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.jsWrite 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.
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
MIT
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Hosted MCP with 91 agent tools: X, domains, SEO, Maps, Trends, Search, YouTube, TikTok, and more.
Free public MCP for AI agents — 193 tools, 44 workflows. No API key.
Domain search, registration, DNS, marketplace, and checkout with your AI agent.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/oborseth/Porkbun-MCP'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
