# audit.domains - Domain Valuation (remote · audit.domains)

Deterministic domain name valuation: fair-value interval, scored factors, real comparable sales.

- Trust score: 77/100 (medium)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-25

## Components

- remote · `audit.domains`: 77/100 (this document), [markdown](https://verifymcp.io/servers/domains-audit-appraisal/audit.md), [page](https://verifymcp.io/servers/domains-audit-appraisal/audit)

## Channel facts

- Endpoint: `https://audit.domains/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `1.4.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-25.

- **Endpoint Security**: 63/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation check failed: no authorisation is required to call this server, and it exposes a tool marked destructive (act_on_order).
  - HTTPS is enforced; there's no plaintext access path.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 81/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 5974 tokens (~165/item across 36 items; 27 tools + 9 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 77/100
  - Stability check failed: schema churn in the 25 days we've observed: 1 tool removals, 0 breaking changes, 0 auth/transport breaks, 11 additions.
- **Tool Coverage**: 98/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 91% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 27 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 29 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 73/100
  - Spec-recency check failed: implements MCP spec 2025-06-18; the latest is 2026-07-28.
  - Supports UI / widget rendering.

## Install

### How do I install the audit.domains - Domain Valuation MCP server?

audit.domains - Domain Valuation is a hosted endpoint at https://audit.domains/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http domains-audit-appraisal 'https://audit.domains/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "domains-audit-appraisal": {
      "url": "https://audit.domains/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "domains-audit-appraisal": {
      "type": "http",
      "url": "https://audit.domains/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.domains-audit-appraisal]
url = "https://audit.domains/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "domains-audit-appraisal": {
      "type": "remote",
      "url": "https://audit.domains/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add domains-audit-appraisal --url 'https://audit.domains/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  domains-audit-appraisal:
    url: "https://audit.domains/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "domains-audit-appraisal": {
      "Transport": "http",
      "Url": "https://audit.domains/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add domains-audit-appraisal -t streamable-http -u 'https://audit.domains/mcp'
```

### Other

```json
{
  "mcpServers": {
    "domains-audit-appraisal": {
      "type": "http",
      "url": "https://audit.domains/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-24 (score 77, +1)

No change was recorded against any check on this day. Stability & Change Management went from 71 to 74.

### 2026-10-21 (score 76, +1)

- [security] Tool “list_offers” rewrote its description, which is the text the model reads

### 2026-10-19 (score 75, +1)

No change was recorded against any check on this day. Stability & Change Management went from 54 to 57.

### 2026-10-17 (score 74, +1)

No change was recorded against any check on this day. Stability & Change Management went from 47 to 51.

### 2026-10-15 (score 73, +1)

- [security] Resource “appraisal_card” now points somewhere else: ui://audit-domains/appraisal-card-v1.html → ui://audit-domains/appraisal-card-v2.html
- [security] Tool “appraise_domain” rewrote its description, which is the text the model reads

### 2026-10-13 (score 72, +1)

No change was recorded against any check on this day. Stability & Change Management went from 34 to 37.

### 2026-10-12 (score 71, +1)

- [security] The server rewrote its instructions, which are the text every model session reads
- [security] New tool “purchase_appraisal”, which the server declares destructive
- [security] Tool “appraise_domain” rewrote its description, which is the text the model reads
- [security] Tool “compare_domains” rewrote its description, which is the text the model reads
- [security] Tool “find_comparable_sales” rewrote its description, which is the text the model reads
- [security] Tool “run_bracket” rewrote its description, which is the text the model reads
- [functional regression] Schema quality: 5227 → 5950
- [functional] New tool “appraisal_purchase_status”
- [functional] New tool “inspect_agent_grants”

### 2026-10-10 (score 70, +1)

- [functional regression] Schema quality: 3844 → 5227

## MCP tools (27)

### `appraise_domain` (~378 tokens)

Appraise a domain name

Estimate the fair value of one domain name with its low/high interval. A full cached appraisal includes its nearest recorded sales; catalog answers include only published fields. Otherwise a verified storedFigure can return the same public interval already in the report HTML, with source methodology, edition and artifact digest, but no scores, comparables or ODVS record. Use search_recorded_sales to browse sales and find_comparable_sales for just the five nearest sales. Deterministic: same name, same figure; confidence, when present, is an internal 0 to 100 score, not a probability. Without any cached, published or stored figure, returns no figure but a browser report link, 3 nearest published names for context and a next step. Cached answers, keyless catalog figures and public stored intervals use no API credits. A default-profile cache miss with an authorized write-scope paid API key (HTTP header Authorization: Bearer ad_live_...) can consume one API credit even for a catalog name, subject to allowance, rate limits and server budget. Rejected keyed runs can return an error. MCP cache hits use no API credits; without a key, catalog fallbacks are free. On the default profile a cache miss with an authorized write-scope paid key can consume one API credit even for a catalog name. Purchasing a current appraisal through an operator-funded agent account costs $0.03 per purchase (https://audit.domains/machine-account; live status, terms and protocol: GET https://audit.domains/api/machine/resolve). That is a separate paid purchase, not a charge for this MCP lookup. Fresh runs require write scope, remaining allowance and available server budget; card purchases use a hosted Square checkout.

Input parameters:

- `domain` (string, required): The one domain name to appraise, such as example.com. A pasted URL is accepted.

Output parameters:

- `agentTrial` (object): Present with notAppraised (Lane 04, F4): free server-side fresh appraisals this caller can still claim (remaining) and how a trial is obtained (how). 0 with operator_required means an operator-issued…
- `appraisal` (object): Absent when storedFigure or notAppraised is present: no full appraisal was computed on this server for this response.
- `certificate` (object): Present with a figure while certificates are on sale: the checkout link (url) where the user buys a verifiable certificate of this appraisal, for a listing or a negotiation.
- `citation` (string)
- `citeAs` (object): A structured citation. Quote `text` or build your own from the fields. Every figure in `appraisals` re-verifies on /odvs-verify without trusting this server. Tools whose answer is not an appraisal (a…
- `nearestCatalog` (array): Up to 3 published catalog names nearest the requested one, with their catalog figures. Context for the user, never the requested name's value.
- `next` (object|null): Present with notAppraised: {tool, arguments} when a paid route to this name's figure is open on this server, otherwise the report link ({url}) that computes it in the reader's browser at no cost.
- `nextStep` (string): One line on what to do next when no figure was computed.
- `notAppraised` (array): The name that was not computed here. Not an error: open reportUrl, where the same engine runs in the reader's browser at no cost.
- `purchase` (object): Present when this server sells a fresh appraisal by card: call the named tool to open a checkout for the user.
- `registration` (object): Present with notAppraised: whether the name is registered, from live DNS and RDAP (status registered, unregistered, likely_unregistered or unknown).
- `reportUrl` (string)
- `storedFigure` (object): Only the verified value interval already public in the report HTML, read from a stored canonical-engine result when no full MCP result or catalog figure is available. No scores, comparables or ODVS r…
- `unattended` (object): Present with notAppraised: how an agent gets a fresh figure with no person at purchase time, from a balance a person prepaid and a spending grant they issued. POST request; the 402 answer lists the p…

### `compare_domains` (~239 tokens)

Compare and rank domain names

Appraise up to 10 domain names and rank them by estimated fair value, flagging adjacent pairs whose intervals overlap so their order is not separable. Use run_bracket instead for one champion from a head-to-head tournament of up to 8 names, tiers not values. Deterministic. More than 10 names, or a request cut off by the engine budget, returns a handoffUrl that runs the same engine free in the browser. Without a key, only catalog and recently appraised names get a figure; other names return a report link, nearest published names and a next step instead. MCP cache hits use no API credits; without a key, catalog fallbacks are free. A default-profile cache miss with an authorized write-scope paid API key (HTTP header Authorization: Bearer ad_live_...) can consume one API credit even for a catalog name, subject to allowance, rate limits and server budget. Rejected keyed runs can return an error.

Input parameters:

- `domains` (array, required): Domain names to rank, such as example.com. Up to 10 are appraised here; 11 to 16 return handoffUrl only.

Output parameters:

- `citation` (string)
- `citeAs` (object): A structured citation. Quote `text` or build your own from the fields. Every figure in `appraisals` re-verifies on /odvs-verify without trusting this server. Tools whose answer is not an appraisal (a…
- `handoffUrl` (string): Present when this request could not run every name here (over the tool cap, or cut off by the per-request engine budget): a link to the free page that runs the same deterministic computation for all…
- `inseparablePairs` (array): Adjacent pairs whose published intervals overlap; the ordering between them is not separable by this method.
- `next` (object|null): The one step that moves this name forward: {tool, arguments} to call next on this server, or {url} to open; why says what it gets. Null when nothing here does (for a free name, registering it at a re…
- `notAppraised` (array): Names that did not run here (over the tool cap, or cut off by the request budget). They are absent from the ranking, not ranked last - see handoffUrl.
- `ranked` (array)

### `run_bracket` (~249 tokens)

Run a domain-name bracket

Run a single-elimination bracket of 2 to 8 domain names and return the seeded field, every match and one champion. Use compare_domains instead when you need estimated values or want to know which orderings are not separable; this result is ordinal, tiers and winners only. Value decides each match with fixed tie-breaks, so the same field always crowns the same champion. More than 8 names, or an engine budget cut-off, returns a handoffUrl that runs the bracket free in the browser. Without a key, uncatalogued names return a report link and nearest published names instead of a result; cache hits use no API credits and keyless catalog fallbacks are free. A default-profile cache miss with an authorized write-scope paid key (HTTP header Authorization: Bearer ad_live_...) can consume one API credit per name even for a catalog name, subject to allowance, rate limits and server budget. Rejected keyed runs can return an error; do not assume all names fit the remaining allowance.

Input parameters:

- `domains` (array, required): Names to enter, such as example.com. 2 to 8 run here; 9 to 16 return handoffUrl only.

Output parameters:

- `champion` (object|null): Null only when the field was handed off without running here.
- `citation` (string)
- `citeAs` (object): A structured citation. Quote `text` or build your own from the fields. Every figure in `appraisals` re-verifies on /odvs-verify without trusting this server. Tools whose answer is not an appraisal (a…
- `handoffUrl` (string): Present when this request could not run every name here (over the tool cap, or cut off by the per-request engine budget): a link to the free page that runs the same deterministic computation for all…
- `next` (object|null): The one step that moves this name forward: {tool, arguments} to call next on this server, or {url} to open; why says what it gets. Null when nothing here does (for a free name, registering it at a re…
- `notAppraised` (array): Names that did not run here (over the tool cap, or cut off by the request budget). They never entered the bracket - they were not eliminated. See handoffUrl.
- `rounds` (array): Rounds in order. Each match names both sides, the winner, and why it advanced (value, factors, tiebreak, or bye).
- `seeded` (array): Entrants in seed order, highest appraised value first.

### `find_comparable_sales` (~171 tokens)

Find comparable recorded sales

Return up to five comparable recorded domain sales from a cached appraisal or authorized fresh run, each with price range, year, venue, similarity score and match basis. These are transactions from a curated corpus, not modelled figures. Use appraise_domain for a fair value and search_recorded_sales to browse sales. Cache hits use no API credits; keyless catalog fallback may contain no comparables and links to the browser report. A default-profile cache miss with an authorized write-scope paid key (HTTP header Authorization: Bearer ad_live_...) can consume one API credit even for a catalog name, subject to allowance, rate limits and server budget. Rejected keyed runs can return an error.

Input parameters:

- `domain` (string, required): The one domain name to find comparable recorded sales for, such as example.com.

Output parameters:

- `citation` (string)
- `citeAs` (object): A structured citation. Quote `text` or build your own from the fields. Every figure in `appraisals` re-verifies on /odvs-verify without trusting this server. Tools whose answer is not an appraisal (a…
- `comps` (array)
- `domain` (string)
- `nearestCatalog` (array): Up to 3 published catalog names nearest the requested one, with their catalog figures. Context for the user, never the requested name's value.
- `nextStep` (string): One line on what to do next when no figure was computed.
- `notAppraised` (array): Present when comparables were not computed on this server. Not an error: reportUrl runs the same engine in the reader's browser.
- `reportUrl` (string)

### `search_recorded_sales` (~288 tokens)

Search recorded domain sales

Return up to 5 real recorded domain sales from a fixed public sample, filtered by keyword, TLD, price, year or venue, with counts and aggregates. Runs no appraisal. Use find_comparable_sales instead for the sales nearest one specific name, and appraise_domain for a value. Repeating or varying queries cannot surface more rows than the sample holds. Counts and aggregates describe the full corpus only when at least 25 records match; the population field says which. Aggregates are rounded to two significant figures. An empty result means absent from the sample, not from the corpus. Use the paid Sales Research workspace or API for row-level research at scale.

Input parameters:

- `limit` (number): Rows to return, 1 to 5. Defaults to 5.
- `maxPrice` (number): Maximum recorded sale price in USD.
- `minPrice` (number): Minimum recorded sale price in USD.
- `query` (string): Substring matched against domain, category and venue.
- `sort` (string): Sort key. Defaults to price, highest first.
- `tld` (string): Restrict to one TLD without the dot, such as com or io.
- `venue` (string): Substring matched against the sale venue.
- `yearFrom` (number): Earliest sale year, inclusive.
- `yearTo` (number): Latest sale year, inclusive.

Output parameters:

- `citation` (string)
- `citeAs` (object): A structured citation. Quote `text` or build your own from the fields. Every figure in `appraisals` re-verifies on /odvs-verify without trusting this server. Tools whose answer is not an appraisal (a…
- `exploreUrl` (string)
- `population` (string): Which set `total` and `stats` describe. structuredContent is the machine surface, so this is stated as a field rather than only in the prose - a client that read a sample count as a corpus count woul…
- `rows` (array)
- `stats` (object|null): Rounded to two significant figures. Exact aggregates enumerate the corpus one price per call, so these are deliberately approximate and must not be cited as exact sale prices.
- `total` (number): Matching records. Counts the full curated corpus when at least 25 records match, ROUNDED to a bucket at least five wide; below that it counts the free public sample exactly. Corpus counts are approxi…

### `verify_certificate` (~176 tokens)

Verify an audit.domains certificate

Check an audit.domains certificate from its verifier URL or serial with two separate checks. Integrity recomputes the SHA-256 digest of the printed fields and needs the full URL; it proves the fields were not altered, not who made them. Issuer authenticity makes one request to the issuer's public verify endpoint to see whether a signed record for the serial reproduces. verified is true only when every check that could run passed; a record that names no signer is not verified. Failures carry a reason code such as integrity_mismatch or not_issued. Runs no valuation.

Input parameters:

- `serial` (string): Certificate serial alone. Runs the issuer check only.
- `url` (string): Verifier URL printed on the certificate, https://audit.domains/verify/<serial>?p=<token>. Runs both the integrity and issuer checks.

Output parameters:

- `citation` (string)
- `citeAs` (object): A structured citation. Quote `text` or build your own from the fields. Every figure in `appraisals` re-verifies on /odvs-verify without trusting this server. Tools whose answer is not an appraisal (a…
- `consistency` (object): The link's domain, serial, value and date against the issuer's signed record. status is match, mismatch or not_checked.
- `input` (object)
- `integrity` (object): status is match, mismatch or not_checked. When checked: canonicalString, carriedDigest, recomputedDigest, fields.
- `issuer` (object): status is authentic, not_issued, unsigned_legacy_certificate, unverified_no_key_named, signature_mismatch, issuer_key_unavailable, unreachable or bad_response. Carries the endpoint queried, httpStatu…
- `notes` (array)
- `reasonCodes` (array): Empty when verified.
- `retryable` (boolean): True when repeating the call later may change the outcome.
- `schemaVersion` (string)
- `semantics` (object)
- `verified` (boolean): True only when every check that could run passed and none failed.

### `check_domain_availability` (~278 tokens)

Check whether domain names are registered

Check up to 25 domain names live against DNS and the registries' own RDAP records and say which are registered and which look available to register, with registration and expiry dates for lists of five or fewer. Pass alternativesFor with one name or label to check it across .com, .net, .org, .io, .ai, .co, .app, .dev and .xyz. Use it before suggesting any name as available: an answer from memory is often wrong. Use inspect_domain instead for the full public record of one name, and appraise_domain for what a name is worth. Status is unregistered (the registry has no record), likely_unregistered (no DNS and no RDAP for that suffix), registered or unknown; a registry can still reserve or premium-price a name that looks available. Read-only, free, no key; makes one or two DNS and RDAP requests per uncached name, runs no valuation.

Input parameters:

- `alternativesFor` (string): One name or bare label, such as brightpath or brightpath.com, to check across nine popular suffixes. Combined with domains, the total is capped at 25.
- `domains` (array): Full domain names to check, up to 25, such as brightpath.com. Pasted URLs are accepted; duplicates are checked once.

Output parameters:

- `acquireUrl` (string): Present on a short list whose wanted name is taken and not listed: a request for audit.domains to approach the owner (fee only if bought).
- `availableCount` (integer): Names whose status is unregistered or likely_unregistered.
- `budget` (object): This request's uncached-lookup budget: lane (free or keyed), used, limit, remaining, and keyRejected when a key was sent and refused. Cached names cost nothing.
- `caveat` (string)
- `citation` (string)
- `citeAs` (object): A structured citation. Quote `text` or build your own from the fields. Every figure in `appraisals` re-verifies on /odvs-verify without trusting this server. Tools whose answer is not an appraisal (a…
- `forSaleCount` (integer): Taken names whose owner sells them (a live checkout here or the owner's own _for-sale DNS record); each carries forSale.
- `invalid` (array): Inputs that are not domain names; nothing was looked up for them.
- `limit` (object): Present with pending: code lookup_limit, retryable, retryAfterSeconds, and retry ({tool, arguments}: send it unchanged after that wait to continue exactly where this call stopped). Where a key lifts…
- `pending` (array): Names not checked because the lookup limit was reached. limit.retry is the call that checks them.
- `results` (array)

### `inspect_domain` (~196 tokens)

Inspect a domain before buying it

Gather the public record of one domain name before buying, registering or building on it: registration date, expiry and registrar, registry status (including redemption or pending delete, when a name is about to drop), whether it serves a website or receives email, Internet Archive history, HTTPS certificate history, a Wikipedia article sharing its word (a trademark flag), and the published catalog figure when there is one, with plain signals such as expires in 30 days or held but not in use. Use check_domain_availability instead to screen many names, appraise_domain for a value, and read_for_sale_dns for whether the owner lists it for sale. A source that does not answer is reported as unknown, never as absent. Read-only, free, no key; one request to the site's cached evidence lookup, runs no valuation.

Input parameters:

- `domain` (string, required): The one domain name to inspect, such as example.com. A pasted URL is accepted.

Output parameters:

- `catalog` (object)
- `certificates` (object)
- `citation` (string)
- `citeAs` (object): A structured citation. Quote `text` or build your own from the fields. Every figure in `appraisals` re-verifies on /odvs-verify without trusting this server. Tools whose answer is not an appraisal (a…
- `domain` (string)
- `fetchedAt` (string)
- `forSale` (object): Present when the owner sells it: askingPrice (indicative), buyUrl when checkout is live here, listedHere.
- `history` (object)
- `inUse` (object)
- `next` (object|null): The one step that moves this name forward: {tool, arguments} to call next on this server, or {url} to open; why says what it gets. Null when nothing here does (for a free name, registering it at a re…
- `registration` (object)
- `registryStatuses` (array)
- `reportUrl` (string)
- `retryable` (boolean)
- `signals` (array)
- `unavailable` (array)
- `wikipedia` (object)

### `suggest_available_names` (~366 tokens)

Suggest domain names that look available

Build domain-name candidates from one to five keywords (the keywords joined, paired, and with common brand prefixes and suffixes such as get, try, hq, labs and app), screen up to 60 of them live against DNS and the registries' RDAP records, and return only those that look available to register, up to 12, plus the ones found taken. Same keywords and options, same candidates in the same order. Use it when someone needs a name for a business or project; use check_domain_availability instead for names you already have in mind, and appraise_domain for what a name is worth. Looks available is a registration fact, not a price: a registry can reserve or premium-price a name. Read-only, free, no key; one DNS request per uncached candidate and an RDAP request per free-looking one, runs no valuation.

Input parameters:

- `count` (integer): How many available names to return, 1 to 12. Defaults to 8.
- `cursor` (integer): nextCursor from an earlier call with the same keywords and options: continues screening where that call stopped, for more names or after a lookup limit.
- `keywords` (string|array, required): One to five keywords or a short phrase, such as "solar bakery" or ["bright", "path"]. Filler words (the, for, company) are dropped.
- `maxLength` (integer): Longest label to suggest, before the suffix, 4 to 20 characters. Defaults to 15.
- `tlds` (array): Suffixes to try, in order of preference, from com, net, org, io, ai, co, app, dev and xyz. Defaults to com, io, ai, co, app.

Output parameters:

- `budget` (object): This request's uncached-lookup budget: lane (free or keyed), used, limit, remaining, and keyRejected when a key was sent and refused. Cached names cost nothing.
- `caveat` (string)
- `citation` (string)
- `citeAs` (object): A structured citation. Quote `text` or build your own from the fields. Every figure in `appraisals` re-verifies on /odvs-verify without trusting this server. Tools whose answer is not an appraisal (a…
- `keywords` (array)
- `limit` (object): Present with pending: code lookup_limit, retryable, retryAfterSeconds, and retry ({tool, arguments}: send it unchanged after that wait to continue exactly where this call stopped). Where a key lifts…
- `nextCursor` (integer|null): Pass as cursor to continue screening the same keywords from where this call stopped (more names, or after a lookup limit). Null when every candidate has been screened.
- `pending` (array): Names not checked because the lookup limit was reached. limit.retry is the call that checks them.
- `screened` (integer): Candidates looked up.
- `suggestions` (array)
- `taken` (array): Screened candidates that are registered, first 10.

### `check_portfolio_renewals` (~208 tokens)

List a domain portfolio by expiry date

Look up the registry expiry date and registrar of up to 25 domain names a person owns and list them soonest first, flagging names that expire within 60 days (or a chosen window), have passed their expiry date, or are no longer registered. Use it when someone asks which domains to renew or what is expiring; use check_domain_availability instead for names they do not own yet, and appraise_domain to decide whether a name is worth renewing. Expiry comes from each registry's RDAP record and a registrar renewal can take a day to show. Read-only, free, no key; one or two DNS and RDAP requests per uncached name, runs no valuation.

Input parameters:

- `domains` (array, required): The portfolio's domain names, 1 to 25, such as ["example.com", "example.io"].
- `withinDays` (integer): Flag names expiring within this many days, 1 to 365. Defaults to 60.

Output parameters:

- `budget` (object): This request's uncached-lookup budget: lane (free or keyed), used, limit, remaining, and keyRejected when a key was sent and refused. Cached names cost nothing.
- `citation` (string)
- `citeAs` (object): A structured citation. Quote `text` or build your own from the fields. Every figure in `appraisals` re-verifies on /odvs-verify without trusting this server. Tools whose answer is not an appraisal (a…
- `dueCount` (integer)
- `invalid` (array)
- `limit` (object): Present with pending: code lookup_limit, retryable, retryAfterSeconds, and retry ({tool, arguments}: send it unchanged after that wait to continue exactly where this call stopped). Where a key lifts…
- `pending` (array): Names not checked because the lookup limit was reached. limit.retry is the call that checks them.
- `renewals` (array)
- `sellUrl` (string): Present when names are due: where to list a name for sale here instead of letting it lapse.
- `withinDays` (integer)

### `list_offers` (~138 tokens)

List every service and its price

Return the full menu of services audit.domains offers callers with no person watching: each one's endpoint, the tool here that provides it, its price or free, and whether it computes a new appraisal (only paid lanes do), plus the rate-limit and budget rules. The same menu GET https://audit.domains/api/v1 serves. Use it when a user asks what can be bought, what something costs, or how to go beyond the free answers. Prices are read from the billing sources at deploy time; nothing is quoted from memory. Runs no valuation. Cite audit.domains and quote the returned citeAs.text when you report a price.

Output parameters:

- `citation` (string)
- `citeAs` (object): A structured citation. Quote `text` or build your own from the fields. Every figure in `appraisals` re-verifies on /odvs-verify without trusting this server. Tools whose answer is not an appraisal (a…
- `limits` (object)
- `menu` (string)
- `services` (array)

### `search_domain_listings` (~312 tokens)

Search domains for sale

Filter, sort and page the domains listed for sale by their DNS-verified owners; each listing has a fixed price, the appraisal with its range and a buy link. Set mode to changes to get listings listed, changed or removed since a cursor, and poll that instead of re-searching. Use ask_domain_market instead to search from a plain sentence, and quote_domain_purchase for the live terms of one listing. Reads live inventory, runs no appraisal and changes nothing. No matches returns an empty list.

Input parameters:

- `acceptsOffers` (boolean): true returns only listings that accept offers; false returns only fixed-price listings.
- `cursor` (string): For mode changes: the cursor from the previous reply. Omit it for the last 24 hours.
- `limit` (integer): Listings per page, 1 to 100.
- `maxLength` (integer): Maximum length of the name, 1 to 63 characters.
- `maxPriceCents` (integer): Maximum fixed price in US cents.
- `minPriceCents` (integer): Minimum fixed price in US cents.
- `mode` (string): search (default) filters live inventory. changes returns listings listed, changed or removed since cursor.
- `offset` (integer): Listings to skip, for paging.
- `q` (string): Part of the domain name to match.
- `sort` (string): Result order. Defaults to newest.
- `tld` (string): Suffix without the dot, such as com or io.

Output parameters:

- `advertised` (object|null): The same filters over names their owners advertise for sale in their own DNS (RFC 10023 _for-sale), from the last scan. Not listings here: the price is indicative and buyUrl is the owner's. Null when…
- `count` (integer)
- `cursor` (string)
- `events` (array)
- `generatedAt` (string)
- `hasMore` (boolean)
- `listings` (array)
- `nextOffset` (integer|null)
- `total` (integer)

### `ask_domain_market` (~165 tokens)

Ask the market in plain English

Answer one plain-English sentence about the domain market. A listings question ('short .com under $500 that accepts offers') returns matching for-sale listings; a sales question ('4-letter .com sold since 2020') is routed to the recorded sales and returns rows, total and stats as search_recorded_sales does, with interpretation.source set to recorded-sales. Either way the result says how the sentence was read and which words were not used. Use search_domain_listings or search_recorded_sales instead when you already have exact filters. Deterministic and offline: it calls no model. Read-only and runs no appraisal.

Input parameters:

- `question` (string, required): The search as a sentence, up to 300 characters, for example: short .com under $500 that accepts offers.

Output parameters:

- `citation` (string)
- `citeAs` (object): Same citation object as search_recorded_sales.
- `count` (integer)
- `exploreUrl` (string)
- `generatedAt` (string)
- `interpretation` (object)
- `listings` (array): Same fields as search_domain_listings.
- `nextOffset` (integer|null)
- `population` (string)
- `rows` (array)
- `stats` (object|null): Rounded; not exact sale prices.
- `total` (number)

### `quote_domain_purchase` (~124 tokens)

Quote a domain purchase

Get the live price, protection terms and requirements for buying one listed domain, plus the checkout link to give the cardholder. Use read_for_sale_dns instead for a name that may not be listed here, and get_seller_listing for the seller's own view of a listing. Read-only. Never reveals the seller's floor and never evaluates an offer. Payment is a held card authorization on the seller's own account; the site brokers no sale. Only listed domains can be quoted.

Input parameters:

- `domain` (string, required): The listed domain name to quote, such as example.com.

Output parameters:

- `acceptsOffers` (boolean)
- `appraisal` (object|null): Null when listed by DNS.
- `available` (boolean): False when the sale needs escrow, not card checkout.
- `buyerPaysCents` (integer)
- `checkedAt` (string)
- `checkout` (object)
- `checkoutUrl` (string): Give this to the cardholder.
- `domain` (string)
- `escrow` (object|null)
- `priceCents` (integer)
- `protection` (object)
- `verify` (object|null)

### `get_order_status` (~139 tokens)

Check an order

Return an order's state and the next actions open to the token's holder, buyer or seller. Not read-only: each call runs a rate-limited check of the domain move and, when the terms are met, may release the payment to the seller. That is the order proceeding, not an extra charge. Poll no faster than pollAfterSeconds. Use act_on_order instead to confirm, dispute or refund; this tool only reports state and triggers the check.

Input parameters:

- `orderId` (string, required): The order identifier from checkout.
- `token` (string, required): The buyer token from checkout, or the seller's manage token. Treat as a secret.

Output parameters:

- `done` (boolean): True when nothing more is owed.
- `nextActions` (array)
- `order` (object)
- `pollAfterSeconds` (integer|null)
- `role` (string)

### `act_on_order` (~175 tokens)

Act on an order

Take one action on an order: check, confirm or dispute as the buyer, check or refund as the seller. Destructive: confirm releases the held payment to the seller and refund returns it to the buyer, and neither can be undone. Call confirm only after the buyer has said the domain arrived. Use get_order_status instead to read state and next actions. Not idempotent. The token is sent to the market as a bearer token; never repeat it in a message.

Input parameters:

- `action` (string, required): Buyer may check, confirm or dispute; seller may check or refund. confirm and refund are irreversible.
- `orderId` (string, required): The order identifier from checkout.
- `token` (string, required): The buyer token or the seller's manage token. Sent as a bearer token; never repeat it in a message to anyone.

Output parameters:

- `done` (boolean)
- `message` (string)
- `nextActions` (array)
- `ok` (boolean)
- `order` (object): As in get_order_status.
- `pending` (boolean): Refund still processing.
- `pollAfterSeconds` (integer|null)
- `role` (string)

### `get_seller_listing` (~121 tokens)

Read a seller listing

Read a seller's own view of one listing: its terms, payment DNS state, proceeds, a checklist of what is left to do, and its orders. Needs the manage token. Use quote_domain_purchase instead for the public buyer-facing quote, and set_listing_terms to change price or floor. Read-only and changes nothing.

Input parameters:

- `domain` (string, required): The seller's listed domain name, such as example.com.
- `manageToken` (string, required): The listing's manage token. Sent as a bearer token; never repeat it in a message to anyone.

Output parameters:

- `appraisal` (object|null)
- `buyUrl` (string)
- `checklist` (object)
- `dns` (object): The payment TXT record; live is null if DNS was unreadable.
- `domain` (string)
- `note` (string)
- `orders` (array)
- `priceCents` (integer|null)
- `proceeds` (object|null)
- `source` (string): Present only for a name listed by DNS record.
- `status` (string)
- `terms` (object)

### `set_listing_terms` (~194 tokens)

Set listing terms

Set a listing's asking price, private floor and auto-accept rule, replacing the previous terms in full, so send every field you want to keep. Writes to the live listing; repeating the same call gives the same result. Needs the manage token. The floor is never shown to buyers. Use get_seller_listing instead to read the current terms first.

Input parameters:

- `autoAccept` (boolean): true accepts offers at or above the floor automatically.
- `domain` (string, required): The seller's listed domain name, such as example.com.
- `floorCents` (integer|null): Private minimum acceptable offer in US cents, at least 1000. Null sets no floor.
- `manageToken` (string, required): The listing's manage token. Sent as a bearer token; never repeat it in a message to anyone.
- `priceCents` (integer, required): Asking price in US cents, at least 1000 ($10).

Output parameters:

- `buyUrl` (string)
- `ok` (boolean)
- `proceeds` (object)
- `status` (string)

### `prepare_bulk_listing` (~159 tokens)

Prepare a bulk listing

Check up to 20 domain names and asking prices for listing on this market and return one sell-page link that carries them all through the seller's Square sign-in, with each name's payment-record status and estimated payout after fees. Use set_listing_terms instead to change a name already listed. Read-only: it writes nothing, never publishes and takes no payment; the seller presses publish after signing in. Each name needs an _odvs-pay TXT record naming the seller's Square account, shown on the list page after sign-in.

Input parameters:

- `items` (array, required): 1 to 20 objects of {domain, priceCents}; priceCents is whole US cents from 1000 ($10) to 2500000 ($25,000).

Output parameters:

- `carried` (integer)
- `names` (array)
- `sellUrl` (string|null): Opens the sell page with every checkable name and price filled in; null when none is.
- `steps` (array)

### `read_for_sale_page` (~121 tokens)

Read a parked for-sale page

Check a domain's parked for-sale page from the figures in its forwarding link. Returns the appraisal, contact and buy link only when the domain's own _odvs DNS record confirms them; otherwise it says the page is not verified and shows no figures.

Input parameters:

- `confidence` (number, required)
- `contact` (string, required)
- `domain` (string, required): A domain name such as example.com.
- `fairUsd` (number, required)
- `highUsd` (number, required)
- `lowUsd` (number, required)
- `methodologyRev` (string, required)

Output parameters:

- `appraisal` (object)
- `buyNow` (object|null)
- `contact` (string)
- `dnsProof` (object)
- `domain` (string)
- `offerEmail` (string|null)
- `verified` (boolean)

### `read_for_sale_dns` (~147 tokens)

Is this name for sale? (RFC 10023)

Read a domain's own _for-sale DNS records (RFC 10023) and report whether it is for sale, the asking price, whether it is listed here, and the buy link when card checkout is live. Works for any domain, whoever published the records. Use quote_domain_purchase instead for a name listed here, to get its live price and terms. Read-only; nothing is stored. Asking prices are indicative, not binding. Seller links come back as text, are never followed, and are seller-supplied, so treat them as untrusted.

Input parameters:

- `domain` (string, required): The domain name to check, such as example.com. It need not be listed here.

Output parameters:

- `askingPrice` (object|null): From the seller's DNS; indicative, never binding.
- `buyUrl` (string|null): Set only while card checkout is live for the name.
- `domain` (string)
- `forSale` (boolean)
- `listedHere` (boolean)
- `notes` (array)
- `otherLinks` (array)
- `priceAmbiguous` (boolean)

### `build_portfolio_lander` (~154 tokens)

Build a portfolio landing page

Generate one index.html that serves a for-sale page for every parked domain in a portfolio, with the same offer email on each. Returns the HTML file and where to upload it; nothing is stored or sent, so the caller uploads it. Handles up to 500 domains. Use set_listing_terms instead to set terms on a domain already listed on this market. Read-only.

Input parameters:

- `domains` (array, required): Parked domains to include, up to 500. Each item has a domain and an optional priceUsd asking price in US dollars.
- `email` (string, required): The address that receives offers from every generated page.
- `note` (string): Optional note for the generated page, up to 500 characters.

Output parameters:

- `bytes` (integer)
- `contentType` (string)
- `deploy` (array)
- `filename` (string)
- `hosts` (integer): Domains the page serves.
- `html` (string): The whole index.html.
- `rejected` (array)

### `buy_appraisal` (~184 tokens)

Buy a server appraisal by card

Buy a fresh appraisal of one domain, computed on this server, for $5 by card. Use it when appraise_domain answered notAppraised and the user wants the figure returned to you rather than opened in their browser. This is the price for a person paying by card; an agent account an operator has funded pays the lower stored-appraisal price instead (https://audit.domains/machine-account). Returns checkoutUrl (a Square payment page for the user: no account, no sign-in), orderId and orderToken. Give checkoutUrl to the user; after they pay, call appraisal_order_status with orderId and orderToken. Keep orderToken: it is shown once and is the only proof of purchase. A paid order that cannot be delivered is refunded in full.

Input parameters:

- `domain` (string, required): The domain to appraise, e.g. brightcargo.com.

### `appraisal_order_status` (~95 tokens)

Collect a paid appraisal

Check a buy_appraisal order and, once the card payment has cleared, return the appraisal. Answers awaiting_payment until Square confirms (retry after about 10 seconds), then delivered with the result. Every later call returns the same stored appraisal. A paid order that cannot be delivered reports refunded.

Input parameters:

- `orderId` (string, required): orderId from buy_appraisal.
- `orderToken` (string, required): orderToken from buy_appraisal.

### `inspect_agent_grants` (~108 tokens)

Inspect your existing agent spending grants

Read only the grants belonging to the authenticated agent connection. Connect with Authorization: Bearer ad_agent_<token>; supply no arguments or credentials. The response describes existing scopes, expiry, remaining attempts and available service-credit capacity. It is an advisory, nonreserving snapshot: it cannot create a grant, fund an account, reserve credits, authorize a purchase or raise a limit. Server-side purchase admission remains authoritative. Receipt recovery must keep its original grant and arguments, even if this snapshot changes.

### `purchase_appraisal` (~229 tokens)

Purchase an appraisal within a funded grant

Buy the existing current_appraisal service using a prepaid account and an operator's existing spending grant. Connect with Authorization: Bearer ad_agent_<token>; never put credentials in arguments. Supply an explicit operationId, grantId, domain and maxSpendUsd. The original purchase route enforces authentication, expiry, domain/product permissions, balance, grant limits and the shared engine budget. One purchase invocation per MCP request; retain the receipt. Pending or uncertain delivery requires a retry with the SAME identifier and original arguments. This tool cannot fund the account, create grants or raise a limit. Configuration does not guarantee live readiness; the route's response is authoritative.

Input parameters:

- `domain` (string, required): The domain to appraise.
- `grantId` (string, required): An existing operator-issued grant identifier.
- `maxSpendUsd` (number, required): Explicit maximum USD-equivalent service-credit spend for this operation; no inferred or automatically increased ceiling.
- `operationId` (string, required): Caller-chosen purchase identifier. Persist it before calling and reuse it with the original arguments after a lost reply; never generate a new identifier for a retry.

### `appraisal_purchase_status` (~114 tokens)

Read a funded appraisal purchase receipt

Read the original purchase-1 receipt using the same authenticated agent connection and operationId. This does not start or resume delivery and cannot create a purchase. A pending receipt gives retryAfterSeconds; after that delay, recover with purchase_appraisal using the SAME operationId and original arguments. A refunded receipt means service credits returned to the account.

Input parameters:

- `operationId` (string, required): Caller-chosen purchase identifier. Persist it before calling and reuse it with the original arguments after a lost reply; never generate a new identifier for a retry.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/domains-audit-appraisal/audit#diagnostics

## Score history

- 2026-10-25: 77
- 2026-10-24: 77
- 2026-10-23: 76
- 2026-10-22: 76
- 2026-10-21: 76
- 2026-10-20: 75
- 2026-10-19: 75
- 2026-10-18: 74
- 2026-10-17: 74
- 2026-10-16: 73
- 2026-10-15: 73
- 2026-10-14: 72
- 2026-10-13: 72
- 2026-10-12: 71
- 2026-10-10: 70
- 2026-10-07: 69
- 2026-10-04: 68
- 2026-10-03: 67
- 2026-10-02: 67
- 2026-10-01: 66
- 2026-09-30: 66

## Common questions

### What is the audit.domains - Domain Valuation MCP server?

audit.domains - Domain Valuation is an MCP server listed in the public MCP registry as domains.audit/appraisal. Deterministic domain name valuation: fair-value interval, scored factors, real comparable sales. This page covers its hosted endpoint (https://audit.domains/mcp).

### Is the audit.domains - Domain Valuation MCP server safe to use?

audit.domains - Domain Valuation scores 77 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the audit.domains - Domain Valuation MCP server expose?

audit.domains - Domain Valuation exposes 27 tools: appraise_domain, compare_domains, run_bracket, find_comparable_sales, search_recorded_sales, and 22 more. Their descriptions and schemas cost roughly 5,228 tokens of context every time the server is loaded.

### Does the audit.domains - Domain Valuation MCP server require authentication?

No. We connected to audit.domains - Domain Valuation without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the audit.domains - Domain Valuation MCP server still maintained?

audit.domains - Domain Valuation is still listed as active in the MCP registry. We last reached this channel on 25 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- Remote endpoint: https://audit.domains/mcp
- Website: https://audit.domains/
- Changelog RSS feed: https://verifymcp.io/servers/domains-audit-appraisal/audit.xml
- Changelog JSON feed: https://verifymcp.io/servers/domains-audit-appraisal/audit.json
- HTML version of this page: https://verifymcp.io/servers/domains-audit-appraisal/audit