dns-of-money
Server Details
Resolve, discover & pay pay: aliases for AI agents; returns a signed OFAC-screen attestation.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
Glama MCP Gateway
Connect through Glama MCP Gateway for full control over tool access and complete visibility into every call.
Full call logging
Every tool call is logged with complete inputs and outputs, so you can debug issues and audit what your agents are doing.
Tool access control
Enable or disable individual tools per connector, so you decide what your agents can and cannot do.
Managed credentials
Glama handles OAuth flows, token storage, and automatic rotation, so credentials never expire on your clients.
Usage analytics
See which tools your agents call, how often, and when, so you can understand usage patterns and catch anomalies.
Tool Definition Quality
Average 4.4/5 across 6 of 6 tools scored. Lowest: 3.9/5.
Each tool serves a unique, clearly defined purpose: availability check, resolution, agent discovery, registration info, payment requirements, and payment status. No two tools overlap in function, and descriptions clarify their distinct roles.
All tool names follow a consistent verb_noun pattern with underscores, using straightforward verbs like check, discover, get, and resolve. The get_ prefix is used uniformly for three tools, and all names are readable and predictable.
With 6 tools, the server is well-scoped for the DNS-of-money domain. Each tool covers a distinct aspect of the alias lifecycle—availability, resolution, discovery, payment requirements, and status—without unnecessary bloat or gaps.
The tool set covers the core workflows from checking alias availability to resolving payment endpoints, obtaining payment requirements, and verifying payment settlement. Registration info is provided, and the read-only nature is intentional, making the surface feel complete for its purpose.
Available Tools
6 toolscheck_alias_availableAInspect
Check whether a pay: alias can still be claimed. Returns exactly one of three states: 'available' (free to register), 'taken' (already registered), or 'reserved' (protected namespace). When available, also returns the number of founding spots remaining. Public — no API key required. Read-only: this never reserves or registers the name. Example: check_alias_available('pay:acme.user').
| Name | Required | Description | Default |
|---|---|---|---|
| alias_uri | Yes | Candidate pay: address, e.g. 'pay:acme.user'. A bare name without the 'pay:' prefix is accepted too. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description fully covers behavior: it is read-only, never reserves or registers, and is public. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, two sentences plus an example, with no extraneous information. Front-loaded with the core action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple tool (1 param, no output schema), the description is nearly complete, covering purpose, return values, side effects, and authentication. Minor omission: no mention of synchronous vs async.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with a description for the single parameter. The description adds context about return states and example, but does not significantly extend parameter semantics beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool checks if a pay alias can be claimed, specifies the three possible return states, and distinguishes it from sibling tools like resolve_alias.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions it is public and read-only, but does not explicitly state when to use vs alternatives or prerequisites. However, the context of checking availability is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
discover_agentAInspect
Get the AP2/A2A agent-commerce block for a pay: address — the DNS of Money equivalent of an A2A agent-card lookup. Use this during agent discovery before initiating a mandate flow. Returns agent capabilities only; NO payment credentials. Example: discover_agent('pay:acme.user').
| Name | Required | Description | Default |
|---|---|---|---|
| alias_uri | Yes | The pay: address to discover. E.g. 'pay:acme.user'. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Describes return type (agent capabilities only, no credentials) and implies a read-only lookup. Lacks details on error handling, idempotency, or rate limits, but adequate for a simple discovery tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences plus an example, no redundant information. Front-loaded with the main purpose. Highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity (one required param, no nested objects, no output schema) and sibling context, the description is mostly complete. It explains the tool's role and usage but could benefit from clarifying what 'agent capabilities' entails or typical error cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers the single parameter fully (100% coverage). Description adds an example and format clarification but does not significantly extend beyond schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves the AP2/A2A agent-commerce block for a pay: address, uses an analogy ('DNS of Money equivalent'), and distinguishes itself from siblings by explicitly stating no payment credentials are returned.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: 'during agent discovery before initiating a mandate flow'. Provides an example. Does not explicitly list alternatives but sibling names and context imply differentiation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_agent_registration_infoAInspect
Learn how to self-register a FREE pay:agent. alias for your agent. Returns the registration endpoint, the AgentAuthorityCredential verifiable-presentation requirements (intent binding + domain), the rate limit, and the Merkle anchor-proof endpoint. Read-only — registration itself is the credential-gated POST this tool points at. Example: get_agent_registration_info().
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description explicitly states the tool is read-only and lists exact return values: registration endpoint, requirements (intent binding+domain), rate limit, and Merkle anchor-proof endpoint. It clarifies that registration itself is a separate POST, setting proper expectations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise: two sentences and an example. It front-loads the purpose and includes critical behavioral notes without excess.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers what the tool returns and its read-only nature. Although it lacks explicit authentication requirements for the tool itself and prerequisites, it is adequate for a parameterless read-only info tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With zero parameters and 100% schema coverage, the baseline is 4. The description need not add parameter info.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns registration info needed to self-register a pay:agent alias, distinguishing it from sibling tools like check_alias_available or resolve_alias. The purpose is specific: returns endpoint, requirements, rate limit, and anchor-proof endpoint.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool should be used before the credential-gated POST for registration, noting it is read-only. However, it does not explicitly compare to siblings or provide when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_payment_requirementsAInspect
Get x402 PaymentRequirements for paying a pay: alias. Returns the 402 accepts block (scheme, network, payTo, asset, amount, invoiceId) an x402 agent needs to construct and submit the payment. currency='XRP' settles on the XRP Ledger (amount in drops); currency='USDC' settles USDC on Algorand via the GoPlausible facilitator (amount in atomic micro-USDC, feePayer in extra). The deterministic resolver chooses the rail; this tool never moves money. Example: get_payment_requirements('pay:acme.user', amount='1.5').
| Name | Required | Description | Default |
|---|---|---|---|
| amount | No | Amount to pay — decimal string in the asset's display unit (XRP). Omit it to be quoted the alias's declared price; required for an alias that declares no price. | |
| currency | No | Asset to pay in: 'XRP' (XRPL) or 'USDC' (Algorand). Defaults to XRP. | |
| alias_uri | Yes | The pay: address to pay. E.g. 'pay:acme.user'. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses that the tool never moves money and describes deterministic resolver behavior. With no annotations, it adds good context about return fields and currency-specific settlement, but lacks mention of error handling or edge cases.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured, with a clear purpose statement upfront, followed by relevant details and an example. No superfluous sentences.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers return format, currency details, amount semantics, and includes an example. Lacks error scenarios or behavior for invalid aliases, but overall sufficient for a single-purpose tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Adds significant meaning beyond the schema: explains amount omission behavior, currency-specific settlement details, and provides an example. Schema coverage is 100%, but description enhances understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves PaymentRequirements for a pay: alias, with a specific verb and resource. It distinguishes from siblings like check_alias_available or resolve_alias by focusing on payment requirements.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit usage examples and explains when to omit the amount (get quoted price) vs required. However, it does not explicitly state when to use this tool over alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_payment_statusAInspect
Check whether a payment you already attempted was recorded, BEFORE you retry and risk spending twice. Pass the request_key you sent as the Idempotency-Key header on the paid request. Returns state 'settled' (we hold a receipt — do NOT pay again) or 'not_found' (we have no record — retrying is safe). Use this when a paid call timed out or its response was lost: on rails where the facilitator broadcasts, you never learn the transaction hash unless our response reaches you, so this key is the only thing that can answer. The key is a bearer secret — whoever presents it gets the receipt.
| Name | Required | Description | Default |
|---|---|---|---|
| request_key | Yes | The exact Idempotency-Key you sent with the paid request. 32-128 characters of [A-Za-z0-9_-], generated from a CSPRNG with at least 128 bits of entropy. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses behavior: it returns 'settled' or 'not_found', explains what each means, warns 'do NOT pay again' for settled, and highlights the security implication ('bearer secret'). This goes far beyond a basic statement.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured, front-loading the core purpose and usage. Every sentence adds essential information—no fluff, no repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter tool with no output schema or annotations, the description is remarkably complete. It covers the scenario, return values, safety implications, and a subtle technical nuance about facilitator broadcasts, leaving no critical gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, providing baseline 3. The description adds meaningful context beyond the schema by emphasizing the request_key is a bearer secret and the only way to answer, which is crucial for correct and safe use.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool checks whether a payment was recorded before retrying, using a specific verb ('Check') and resource ('payment status'). It distinguishes itself from sibling tools like get_payment_requirements by focusing on post-attempt verification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use: 'Use this when a paid call timed out or its response was lost' and provides the precondition (pass the request_key). It also implicitly warns against using it without an attempted payment and explains why this is the only way to resolve ambiguity on certain rails.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
resolve_aliasAInspect
Resolve a human-readable financial alias (pay: address) to payment endpoints and routing metadata. Call this before initiating any payment to a pay: address. Returns the preferred rail, fallback endpoints, an ISO 20022 hint, and a compliance signal. Anonymous calls return status only; a free API key (no credit card) unlocks the endpoint set — which rails and currencies the alias accepts — via POST /api/v1/access-requests. You do NOT need a key to pay: get_payment_requirements returns a payable address to any caller. Example: resolve_alias('pay:acme.user').
| Name | Required | Description | Default |
|---|---|---|---|
| amount | No | Optional payment amount (decimal string) — refines rail scoring. | |
| currency | No | Optional ISO 4217 currency code. Defaults to USD. | |
| alias_uri | Yes | The pay: address to resolve. E.g. 'pay:acme.user'. | |
| preferred_rail | No | Optional rail hint (e.g. 'xrpl', 'fednow'). Advisory only. |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses behavior: what it returns (preferred rail, fallback endpoints, ISO 20022 hint, compliance signal), the difference between anonymous and keyed calls, and the need for a free API key to unlock full endpoint sets. No contradictions or omissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is informative yet efficient, with each sentence adding value. It is front-loaded with the core purpose. Slightly verbose due to additional API key details, but still well-structured and clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description details the return types and includes behavior for anonymous vs. authenticated calls. It covers edge cases and prerequisites, making the tool fully understandable for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with each parameter described. The description adds context by linking amount and currency to rail scoring and providing an example, but it does not significantly extend beyond the schema descriptions. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool resolves a human-readable alias to payment endpoints and routing metadata. It includes a specific example and distinguishes its use before initiating payments, clearly differentiating it from siblings like get_payment_requirements.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says when to use this tool: before initiating any payment to a pay: address. It also provides context for anonymous vs. keyed calls and references the sibling get_payment_requirements as an alternative that does not require a key, guiding appropriate tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Claim this connector by publishing a /.well-known/glama.json file on your server's domain with the following structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"maintainers": [{ "email": "your-email@example.com" }]
}The email address must match the email associated with your Glama account. Once published, Glama will automatically detect and verify the file within a few minutes.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!
Related MCP Servers
- Alicense-qualityBmaintenanceEnables verification of AI agent identity, authority, and integrity at transaction time, returning signed verdicts for allow, step-up, review, or block.MIT
- Alicense-qualityCmaintenanceW3C DID resolution and agent KYC for autonomous agent counterparties, enabling identity verification and trust scoring.MIT
- Alicense-qualityDmaintenanceEnables AI agents to discover and pay for x402-enabled services using natural language, with multi-chain support for Solana and EVM payments.81MIT
- FlicenseAqualityDmaintenanceEnables AI agents to make contextual, private crypto payments using ENS identity and stealth addresses, with stealth-address privacy and agent spend policy controls.131