Some questions about your domain portfolio are answered with a few clicks in the dashboard. Others require an API integration. Today, we are releasing something for everything in between: the OpusDNS MCP Server.
Why a Third Way?
With our dashboard and API, we already offer two extremely powerful tools. However, in practice, a gap often emerges:
- The Dashboard is ideal for viewing your portfolio’s current state and performing quick, one-off actions.
- The API is built for automation, running the same operation thousands of times a day as part of a larger workflow.
But what about the space in between?
The one-off query ("What expires next quarter, and where is auto-renew still disabled?"), the ad-hoc bulk change ("Lock transfers across 100 domains at once"), or the sequence of three individual steps ("Register domain, set up zone, and point to campaign page"): things you need exactly once today. They are too complex for manual clicking in the dashboard, but too tedious to write a custom API script for.
This is precisely where our new Model Context Protocol (MCP) server comes in. It replaces neither the dashboard nor the API. Instead, it extends both worlds: bringing the flexibility of the API into the intuitive format of natural language, directly inside the AI clients you already work in. A third tool for your toolkit.
A Quick Word on MCP
The Model Context Protocol is an open standard for connecting AI applications to external systems. Instead of every assistant needing its own bespoke plugin for every service, a provider ships one MCP server and every compatible client can use it: Claude and Claude Code, ChatGPT, Cursor, VS Code, or the agent you built in-house.
For us, the appeal was obvious: We spent the past year building an API-first registrar platform from the ground up with no legacy layers to work around. MCP is simply the interface that lets a language model use this platform directly, without an SDK (Software Development Kit), without glue code, and without waiting for someone else to build an integration.
Natural Language as a Query Language
Filters in any interface are built around the resource you are currently looking at, and for daily views, that is exactly right. But some questions combine conditions that no single filter row can express. Previously, those required writing a script:
- "How many domains do I have, and what is expiring in the next 90 days?"
- "Which of my .com domains expire in the next 30 days? Just names and dates."
- "Which domains expiring this quarter still have auto-renew turned off and no transfer lock set?"
- "Show me everything tagged migration that still points to the old provider's nameservers."
For these cases, the MCP server provides two dedicated portfolio tools: One returns totals and breakdowns by status, TLD, and expiration date. The other lists domains while projecting only the fields you actually asked for. On large accounts, this makes all the difference: you get a compact answer instead of a wall of JSON. The conversation stays fast enough for immediate follow-ups, which is usually where the genuinely useful version of the question appears.
Bulk Changes That Run Through Jobs, Not a Loop
The same principle applies to changes, with an important difference in implementation. Changes across many domains do not become a loop of individual API calls. They are resolved into a batch and submitted to OpusDNS Jobs, the same engine our own automation uses.
The flow is deliberate. You describe the change, the server resolves your selector, and shows you the planned batch, including the exact number of affected domains. Nothing is submitted until you approve it. From there, you can monitor progress and pause, resume, retry, or cancel the batch.
- "Lock transfers on everything tagged migration."
- "Turn off auto-renew on every .io expiring this quarter."
- "Renew acme-labs.com for a year."
- "There are errors in this batch. Retry only the ones that ran out of funds."
That last example is our favorite: A partially failed bulk operation is normally an afternoon of manual reconciliation. Now, it is just a single question.
A single batch resolves to a maximum of 1,000 domains (the cap of the Jobs API for a bulk command). For larger volumes, narrow your selector and run multiple batches.
Chained Operations from a Single Instruction
Launching a domain is rarely just one step. You register it, create the DNS zone, point traffic where it belongs, and make sure emails arrive. Each step depends on the result of the previous one. This sequence is tedious to click through and overkill to script for a single deployment.
"Register wintersale-2027.de, create a DNS zone from our standard record set, forward the apex to campaign.example.com over HTTPS, and set up an email forward from info@ to our shared inbox."
One instruction, four operations, executed in order, each using the output of the last, with every operation pausing for your approval. If something unexpected comes back—say, the domain is taken or the zone already exists—the agent stops and informs you rather than pushing ahead blindly.
This again highlights how well the MCP server and dashboard complement each other: execute the sequence in a single sentence, then open the dashboard to confirm the result looks exactly as expected.
Nine Tools, Not Hundreds
One design decision is worth highlighting because it makes the difference between an MCP server that works and one that only technically works.
Every tool an MCP server exposes is loaded into the model's context window before you type a single character. Generate one tool per API endpoint, and a full registrar API fills that window with schemas before any work even begins. Less room is left for your data, and the model has to choose among a hundred near-identical options.
Therefore, the OpusDNS MCP Server exposes nine focused tools in total:
- 3 tools for API discovery and invocation: The model searches the operation catalog, requests details, and executes them. Discovery happens on demand, exactly when relevant.
- 6 specialized portfolio and bulk tools: Purpose-built because these tasks deserve better than a generic API call.
The result is a context footprint that stays flat whether our API exposes 50 or 500 operations. New API capabilities become discoverable through the same search tool without requiring client updates on your side.
"The naive approach is to hand the model a hundred tools and hope it picks the right one. We went the other way: a small, sharp tool surface and discovery on demand. The result is a server that stays fast and predictable no matter how much our API grows."
— Kilian Ries, Head of IT and Cloud Infrastructure at OpusDNS
Server-Enforced Approvals
Domain operations are not a sandbox. A nameserver change propagates, a transfer out is difficult to reverse, and a deletion triggers a redemption period and incurs fees. The guardrails are therefore not mere prompt instructions given to the model—they are a hard gate in front of the API.
Anything that is not a read operation is blocked before the request reaches the OpusDNS API and requires your explicit approval. This covers every write, every cost-bearing operation, every deletion, and every transfer. The check lives directly on the server rather than in the model's instructions; no amount of clever prompting can bypass it. Approval is bound to the exact action, including the exact resolved list of domains in a bulk operation: approve a batch of 40 domains, and exactly 40 will be executed.
Approvals expire after about five minutes and are single-use. Every call the agent makes is a standard, logged OpusDNS API call, fully traceable like any other.
"An agent is a very fast colleague with no institutional memory. You give it what you would give a new team member: limited permissions, a test environment, and an audit log of what it did."
— Thomas Weiß, Backend & AI Developer at OpusDNS
The OpusDNS MCP Server at a Glance
- Status: Beta (available immediately)
- Tools: 9 in total (3× API Discovery/Call, 2× Portfolio, 4× Bulk)
- Bulk Handling: Runs via OpusDNS Jobs with preview, approval, and batch control (up to 1,000 domains per batch)
- Safety: Server-enforced approval on every write action, bound to the exact resolved payload
- Authentication: Sign in with your OpusDNS account
- Transport: Remote Streamable HTTP, MCP protocol revision 2026-07-28, with fallback for older clients
- Clients: Claude and Claude Code, ChatGPT, Cursor, VS Code, and any other MCP-compatible client
- Environments: Production and a free, fully isolated Sandbox
- Additional Feature: Act on behalf of a sub-organization
Get Started
The MCP Server is live today in Beta. Point your client to one of these endpoints and sign in with your OpusDNS account:
Our Sandbox environment is a separate, free account and fully isolated from production. We recommend starting there: it is the fastest way to discover which of your workflows it actually shortens, and the right place to let an agent make its first mistakes safely.
Full documentation—from client setup to tool references, worked workflows, approvals, and data handling—is available at developers.opusdns.com/mcp-server.
If you hit any rough edges, want a specific feature exposed differently, or have a workflow we haven't thought of: reach out to us. That feedback loop is how most of our platform was built.
Don't have an OpusDNS account yet? Create one for free—with no platform fees and no minimum spend. To stay tuned on what ships next, follow us on LinkedIn or subscribe to our newsletter.
