how to audit your domain renewal costs with claude code.

domain admin is the kind of work nobody schedules. it matters four times a year and is invisible the rest of the time, which is precisely why people discover their renewal bill by reading a card statement.

the fix that has actually worked for us is not a better dashboard. it is putting the portfolio behind a tool call, so the audit happens in the terminal you were already in. the `owndle` CLI and MCP server are on npm, and this is the whole setup.

what you are installing

one npm package that is two things. as a CLI it gives you `owndle audit`, `owndle domains`, `owndle search` and a watchlist. as an MCP server — started with `owndle mcp` — it speaks the Model Context Protocol over stdio, so Claude Code, Claude Desktop, Cursor or any other MCP client can call the same operations on your behalf.

MCP is the part worth understanding: an open standard for letting a model call external tools. rather than pasting a CSV of your domains into a chat window and hoping the model reads it correctly, you give the agent authenticated access to the live portfolio.

the server runs locally, talking to your agent over stdin and stdout. nothing about your conversation goes anywhere near us — only the API calls the tools make.

step one: install

globally, if you want the CLI on your path:

• `npm install -g owndle`

or not at all, if you only want the MCP server, since `npx` fetches it on demand:

• `npx owndle help`

the second is the one most people should take. the config below invokes `npx -y owndle mcp`, so your client always runs the current published version rather than a stale global install answering questions with last quarter's code.

step two: mint an API key

the tools read your portfolio, so they need to know whose portfolio. in the dashboard, go to settings → API keys and create one. it looks like `owndle_sk_…` and it is shown once, so put it somewhere you will find it again.

the honest bit: API keys are a Founder-tier feature and above. the free tier covers ten domains in the web dashboard, but programmatic access — CLI, MCP, REST — starts at the £29/month tier. to try the idea before paying for it, the free tools need no key at all: price check works in a browser and works fine for an agent to fetch.

step three: add it to your client

this is the config block. it is identical across clients:

{"mcpServers":{"owndle":{"command":"npx","args":["-y","owndle","mcp"],"env":{"OWNDLE_API_KEY":"owndle_sk_…"}}}}

what changes is the file it goes in. Claude Code reads an `.mcp.json` in the project root, or registers it via `claude mcp add`; Cursor reads `.cursor/mcp.json`; Claude Desktop has its own config file. check your client's documentation for the exact path rather than any blog post's version of it, ours included.

two things catch people out. restart the client after editing, because MCP servers are launched at startup and config files are not hot-reloaded. and if `.mcp.json` is committed to a shared repository, do not put a live key in it — the `env` block can read from your shell instead.

if you would rather not wire up an agent at all, `owndle login` stores the same key for the CLI and every subcommand works without passing it.

the six tools

the server exposes six. worth knowing what they are, because it shapes what you can sensibly ask for:

• audit_portfolio — the whole portfolio in one call: total annual renewal cost, how much of it is recoverable by switching registrars, how many domains expire soon, and the estimated resale value of the lot. this one answers most questions.
• list_domains — every domain you track with its registrar, expiry date, renewal cost, the cheapest registrar for that TLD and a valuation. the raw table, for when the agent needs to sort or group rather than summarise.
• search_domains — availability for a name, the cheapest registrars ranked by five-year cost rather than year one, alternatives scored on TLD trust and brandability, plus social handle checks. the only tool about domains you do not own yet.
• list_watches — your watchlist: domains somebody else holds that you want if they lapse, each with its position in the deletion lifecycle.
• add_watch — put a domain on that list.
• remove_watch — take one off, by the id `list_watches` returned.

note what is missing. no renew tool, no transfer tool, no way for an agent to spend your money. four of the six are read-only and the two writes only touch a watchlist. that is deliberate: an agent that can audit a portfolio is useful, one that can transfer a domain because it misread a sentence is a liability.

the prompts worth asking

you do not need to name the tools. describe the outcome and let the client pick.

"which of my domains am I overpaying on?" the one that pays for itself. it calls `audit_portfolio`, which prices every domain you own against a cross-registrar catalogue and returns the gap. that gap is renewal arbitrage — same domain, same registry record, different retail markup — and it is usually the largest number in a portfolio nobody has looked at. follow it with "sort those by annual saving and tell me which three are worth the transfer paperwork".

"what expires in the next 90 days?" `list_domains` plus arithmetic the model is good at. the value is in the follow-up: "which of those have auto-renew off", "which are at a registrar I no longer use", "draft a calendar entry for each". note this is a pull — you have to ask. to be told without asking, that is expiry monitoring, alerting at 90, 30, 7 and 1 days whether or not a terminal is open.

"what's my total annual domain spend?" a single `audit_portfolio` call, and reliably the most uncomfortable answer of the three. people underestimate this figure badly, because it accumulates in small increments across several registrars and never appears as one line anywhere.

past those three, the good prompts are the compound ones an agent handles well and a dashboard does not: "group my domains by registrar and give me the annual cost of each", or "of the names I am not using, which are worth more than five years of renewals".

what to do with the answer

the audit produces a list of overpriced renewals. moving them is manual work at a registrar's UI, and it is worth doing in expiry order rather than saving order — a transfer usually adds a year to the registration, so a domain expiring next month is both urgent and cheap to move. the transfer guide covers the unlock-and-auth-code dance at the registrar people most often want to leave.

check the destination price against the live tables before you commit, not the agent's summary. same data, but a number in a chat log is only as fresh as the message.

why an agent suits this specific job

because the failure mode of domain management is not difficulty, it is attention. nothing about renewing a domain is hard. the work only surfaces when you deliberately go and look, and the reward for looking is usually "everything is fine", which trains you not to.

a tool call collapses that cost to nothing. you are in the terminal, you think "what is that costing me", and a moment later you know. if you would rather click, the web dashboard does the same job with the same data, and the MCP server page has the REST endpoints if you would rather script it.