DNS of Money: Agent Quickstart

Give your AI agent a payment address book with verifiable compliance built in.

DNS of Money resolves a human-readable pay: name to deterministic payment endpoints. Your agent pays from its own wallet over x402. You can also buy a signed sanctions screen of a counterparty before you pay it.

DNS of Money serves deterministic, verifiable tools. We resolve, verify, screen and record. We never hold your funds. Your agent makes the decisions and owns the keys.

Base URL: https://api.dnsofmoney.com
MCP endpoint: https://api.dnsofmoney.com/mcp/rpc
Install page: https://dnsofmoney.com/mcp/

Install

This is a remote streamable-HTTP MCP server. There is no package to install and no local process. For Claude Code:

claude mcp add --transport http dnsofmoney https://api.dnsofmoney.com/mcp/rpc

For any MCP client that uses a config file:

{
  "mcpServers": {
    "dnsofmoney": {
      "type": "http",
      "url": "https://api.dnsofmoney.com/mcp/rpc"
    }
  }
}

To send an API key:

claude mcp add --transport http dnsofmoney https://api.dnsofmoney.com/mcp/rpc \
  --header "X-API-Key: YOUR_KEY"

The official MCP registry lists this server as io.github.sparkmastergrape/dns-of-money.

MCP tools

All six tools are read-only.

Tool	What it does
`resolve_alias`	Resolves a `pay:` name to its preferred rail, fallback endpoints and ISO 20022 hint. The caller's tier controls the fields you get.
`check_alias_available`	Returns `available`, `taken` or `reserved` for a name.
`discover_agent`	Returns the AP2/A2A agent-commerce block for a name. It returns capabilities only, never credentials.
`get_payment_requirements`	Returns the x402 `accepts` block for a name, so an agent can quote a payment. It needs no key.
`get_payment_status`	Checks whether an attempted payment was recorded. Call it before you retry, so you do not pay twice.
`get_agent_registration_info`	Explains how to register a free `pay:agent.<label>` name.

Paid HTTP resources

No resource below needs an API key to read the price. A bare GET returns 402 Payment Required with the challenge.

Resource	What you get	API key to settle
`GET /api/v1/x402/screen/{target}`	A signed OFAC and resolution screen of a `pay:` name or a raw address	No
`GET /api/v1/x402/resolve/{alias}`	The full resolve of a name (tier 2 view)	No
`GET /api/v1/x402/presend?target=...&chain=...`	Signed pre-send evidence about an address: lookalike collisions, contract status, activity, cross-chain consistency and a sanctions verdict	No
`GET /api/v1/x402/pay/{alias}`	Pays a name and returns a signed resolve, settlement and screen attestation	Yes

The fee for screen, resolve and presend is 0.01 USDC or 0.01 XRP. The server sets the fee. pay uses the name's declared price, or the amount you send if the name declares none.

resolve returns 404 for a name that does not resolve, and you pay nothing. presend takes optional repeated payee parameters, which are addresses you paid before. We do not store them.

A risky target is a finding inside a 200 response. A 402 on these routes always means that payment is required.

Rails

A bare GET on screen, resolve or pay advertises five rails. Your agent picks one it holds funds on. To request one rail, add ?currency=.

`currency`	Asset	Network	Fees
`XRP`	XRP	`xrpl:0`	The payer pays the ledger fee
`USDC`	USDC	Algorand mainnet	The facilitator co-signs the fee leg
`USDC-BASE`	USDC	`eip155:8453` (Base)	The facilitator pays gas
`USDT0-XLAYER`	USD₮0	`eip155:196` (X Layer)	See the 402 challenge
`USDC-SOL`	USDC	Solana mainnet	The facilitator is the fee payer

External agents have paid on Base and on Solana with zero native gas token.

Solana fee-payer addresses rotate for each invoice. Read extra.feePayer from each 402 challenge, and do not cache it. Each accept also has its own invoiceId.

presend is a single-rail route. Its fee is USDC-BASE by default.

API keys and tiers

An API key is free. Request one, then click the link in the verification email. The server issues the key when you click.

curl -X POST https://api.dnsofmoney.com/api/v1/access-requests \
  -H 'Content-Type: application/json' \
  -d '{"name":"Your Name","email":"you@example.com","use_case":"agent payments"}'

GET /.well-known/api-access describes this flow in JSON.

The key sets how much resolve_alias and /resolve return:

Tier	Caller	You get
0	No key	Name, status, IDs and resolve time
1	`starter` key	Plus display name, entity type and preferred rail
2	`developer`, `business` or `enterprise` key, or a paid resolve	Plus endpoints and compliance
3	`system` or `agent` key	Plus routing metadata and `agent_commerce`

The free key has the developer plan, which is tier 2.

You never need a key to read a price. get_payment_requirements returns a payable address to any caller.

Rate limits

Caller	Limit
No key, per client IP	60 requests per minute
`starter`, `developer`	60 requests per minute
`enterprise`	1200 requests per minute
Any caller, per IP	10 requests per second at the edge

Responses carry X-RateLimit-Limit, X-RateLimit-Remaining and X-RateLimit-Reset. Back off when X-RateLimit-Remaining is low. A plan with a monthly quota also gets X-Quota-* headers.

Try it

These calls need no key and cost nothing.

curl https://api.dnsofmoney.com/.well-known/x402
curl https://api.dnsofmoney.com/mcp/tools
curl -i https://api.dnsofmoney.com/api/v1/x402/screen/pay:dnsofmoney

Call a tool over REST:

curl -s -X POST https://api.dnsofmoney.com/mcp/tools/call \
  -H 'Content-Type: application/json' \
  -d '{"tool":"resolve_alias","arguments":{"alias_uri":"pay:dnsofmoney"}}'

The /mcp/tools views and /mcp/rpc use the same dispatch. REST is easier to debug. JSON-RPC is what MCP clients speak.

Pay over x402

GET the resource with no payment. The server returns 402 and a JSON body with accepts[].
Pick one accept. Keep its network, payTo, amount and invoiceId.
Pay with your own wallet. On XRPL, submit the payment first. On Algorand, Base, X Layer and Solana, sign the x402 payload with an x402 client.
Send the same GET again with the proof in X-PAYMENT or PAYMENT-SIGNATURE.
Read the deliverable from the 200 body and the receipt from PAYMENT-RESPONSE.

Amounts are in base units: drops for XRP, and 6 decimals for USDC and USD₮0.

The XRPL proof is a base64 JSON envelope around a validated transaction hash. Echo the accept you chose in accepted, so the server knows which rail you paid on:

# X-PAYMENT = base64( {"x402Version":2,"accepted":<the-chosen-accept>,
#                      "payload":{"txHash":"<HASH>","payer":"<rYourAddress>"}} )
curl "https://api.dnsofmoney.com/api/v1/x402/screen/pay:dnsofmoney" \
  -H "Idempotency-Key: <128-bit-random-value>" \
  -H "X-PAYMENT: <base64-envelope>"

For the other rails, use a client library:

x402 for Base and Solana
x402-avm for Algorand
The Go SDK, where your wallet signs through a Signer

Retry safely

Send a random Idempotency-Key of 128 bits or more with each paid request, and keep it. If the result is unclear, call get_payment_status with that value as request_key before you pay again.

settled: we hold a receipt. Do not pay again.
not_found: we have no record. A retry is safe.

The key is a bearer secret. Anyone who presents it gets the receipt, so keep it private.

The deliverable

screen returns a W3C Verifiable Credential, CounterpartyScreenCredential, signed by did:web:dnsofmoney.com. pay returns a fas1.resolve-verify-screen attestation:

{
  "success": true,
  "settled": true,
  "transaction_id": "...",
  "attestation": {
    "type": "fas1.resolve-verify-screen",
    "alias": "pay:dnsofmoney",
    "resolved":   { "rail": "crypto", "payTo": "r...", "network": "xrpl:0", "asset": "XRP" },
    "settlement": { "txid": "...", "invoiceId": "...", "amount": "0.01", "currency": "XRP" },
    "screen": {
      "payee": { "address": "r...", "verdict": "CLEAR" },
      "payer": { "address": "r...", "verdict": "CLEAR" },
      "verdict": "CLEAR"
    },
    "issued_at": "..."
  }
}

The screen verdict is the worst result of the two parties: CLEAR, REVIEW, BLOCKED or UNKNOWN. We report a BLOCKED verdict. We do not stop a transaction that already settled on-chain, so your own policy must act on the verdict.

Verify the signature

The proof uses Data Integrity with the eddsa-jcs-2022 cryptosuite. It covers the full binding, so a relay cannot change a field or replay the result against another payment.

Get the issuer document: GET https://dnsofmoney.com/.well-known/did.json.
Find the key at proof.verificationMethod.
Verify the proof with a2a-protocol-core (PyPI and npm), or with any W3C Data Integrity library.

Register a free agent name

An agent can register its own pay:agent.<label> name. Registration needs an AgentAuthorityCredential and a Verifiable Presentation bound to the request. The limit is 10 names for each controlling principal in 24 hours.

Guide: https://api.dnsofmoney.com/agents
MCP tool: get_agent_registration_info
Register: POST /api/v1/agents/register
Anchor proof: GET /api/v1/agents/anchor-proof/{alias}

Agent protocols

A2A: the agent card is at GET /.well-known/agent-card.json.
x402 discovery: the manifest is at GET /.well-known/x402.
AP2: settle on XRPL to a pay: name, then POST /api/v1/ap2/purchase with the transaction hash. The response has signed Cart and Payment mandates. We confirm your XRPL transaction read-only. A request with requires_refundability=true is rejected, because XRPL settlement is final.

curl -X POST https://api.dnsofmoney.com/api/v1/ap2/purchase \
  -H 'Content-Type: application/json' \
  -d '{"intent":{"natural_language_description":"pay invoice","intent_expiry":"2030-01-01T00:00:00Z"},
       "alias":"pay:dnsofmoney","amount":"0.01","currency":"XRP","tx_hash":"<settled-hash>"}'

SDKs and examples

Language	Install
TypeScript	`npm install dnsofmoney`
Go	`go get github.com/dnsofmoney/dns-of-money-go`
Python	Source in `sdk/python`

Examples for curl, Python and TypeScript are in examples/. The FAS-1 specification, which defines pay: resolution, is in docs/FAS-1-spec.md (CC BY 4.0).

Guarantees

Deterministic. The same rule engine resolves every caller. No model selects or scores a rail.
No custody. These tools resolve, verify, screen and record. They never hold your funds.
Verifiable. A paid deliverable is signed by did:web:dnsofmoney.com and bound to a final on-chain settlement.
No credential leakage. discover_agent returns capabilities only.