verantis-mcp
Server Details
Verified directory for machine payments (x402 & MPP): check services and wallets before agents pay.
- Status
- Healthy
- Uptime
- 99.7% over 40 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- m9labs-railscope/verantis-mcp
- GitHub Stars
- 4
- Server Listing
- verantis-mcp
TDQS
Scored across 4 tools
Each tool targets a distinct purpose: checking a specific wallet, searching the service directory, retrieving a full service record, and viewing index stats. There is no overlap or ambiguity; an agent can easily choose the right tool based on the task.
Most tools follow the verb_noun pattern (check_wallet, find_paid_service, get_service), but directory_stats is a noun_noun which breaks the convention slightly. This is a minor deviation and the names remain clear and predictable.
With only 4 tools, the server is tightly scoped to its purpose of verifying wallets and querying service directory information. Each tool earns its place, and the count is well within the ideal 3-15 range for a focused server.
The tool surface covers all essential operations for a read-only directory and reputation service: searching, retrieving details, checking a specific wallet, and getting summary stats. There are no obvious dead ends or missing actions within the stated domain.
Available Tools
4 toolscheck_walletARead-onlyInspect
Check a recipient wallet BEFORE your agent pays it — a pre-payment guard. Pass the pay-to address a service asked you to pay; returns whether Verantis knows the wallet, its EARNED reputation tier, and human-readable reasons. A wallet IS a settlement rail, so the reply names the rail it settles on ('rail': chain + protocols), its host, on-chain buyer retention (distinct buyers, repeat rate, distribution), and the host's OTHER rails ('also_settles_on'). If 'shared_wallet' is true the address fronts many services (a relay/treasury) so the reputation reflects the pool, not one service — treat with care. An unknown or low-reputation recipient is a reason to pause.
| Name | Required | Description | Default |
|---|---|---|---|
| pay_to | Yes | recipient wallet address (0x… for Base/EVM, base58 for Solana) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With readOnlyHint and openWorldHint already present, the description expands substantially on what the agent can expect: reputation tier, human-readable reasons, settlement rail, host, buyer retention, other rails, and the shared_wallet caveat. It also implicitly explains the tool's informational, non-mutating nature by framing it as a guard before payment.
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 longer than average but front-loads the core purpose and then efficiently packs relevant behavioral details. Every sentence earns its place: pre-payment use, return content, rail semantics, shared_wallet hazard, and the risk warning. It could be tightened slightly, but all content is useful.
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 one-parameter tool with no output schema, the description gives a thorough mental model of what will be returned, including reputation, human-readable reasons, settlement rail, host, customer-retention metrics, other settlement rails, and the shared_wallet meaning. It is complete for an agent to know exactly when this tool answers and how to interpret its result.
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% for the single pay_to parameter, including format for EVM and Solana addresses. The description adds crucial semantic detail beyond the schema: pay_to is the service-provided settlement address, and the tool will return wallet reputation across settlement rails. This is more than the schema alone provides.
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 opens with a clear, specific purpose: 'Check a recipient wallet BEFORE your agent pays it — a pre-payment guard.' This distinguishes it from sibling tools like get_service and find_paid_service by targeting the wallet of the service, not the service itself. It also states exactly what it returns.
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 gives explicit usage context: pass the pay-to address a service asked you to pay and do this before payment. It also gives decision guidance, such as treating shared_wallet results with care and pausing for unknown/low-reputation recipients. It does not explicitly rule out alternative tools, but the sibling tools are not relevant alternatives for wallet checks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
directory_statsARead-onlyInspect
Index-level statistics: services, verification breakdown, data freshness.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, and the description adds content details (services, verification breakdown, data freshness) beyond the annotations. It does not contradict annotations, but it omits any potential side effects, performance characteristics, or required permissions—though these are less critical for a read-only stats endpoint.
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 a single, concise sentence that front-loads the main function and lists key data categories. Every word adds value, with no redundancy or filler.
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 input parameters and no output schema, the description covers the essential information: it returns index-level stats about services, verification, and freshness. It could be enhanced by specifying the return format or exact fields, but the simplicity of the tool makes this adequate.
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?
There are no parameters in the schema, so the description has no burden to explain them. With 0 parameters, the baseline is 4, and the description appropriately focuses on what the tool returns rather than parameter details.
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 provides index-level statistics covering services, verification breakdown, and data freshness. The resource (index) and data types are specified, and it distinguishes from sibling tools that focus on individual services or wallets.
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 usage for aggregate statistics ('index-level'), which contrasts with sibling tools for specific lookups, but it does not explicitly advise when to choose this tool over alternatives or mention exclusions. The writer expects the agent to infer from the context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
find_paid_serviceARead-onlyInspect
Search Verantis's verified directory of machine-payable services (x402, MPP). Results are UNIFIED per service (host): each carries its settlement rails ('rails': base / solana / tempo), and every rail has its OWN reputation, price, and buyer retention — never blended. Pass 'chain' and 'matched_rail' marks that chain's rail so you see the reputation for the rail you'll actually pay on. 'coming_soon' lists advertised chains not yet measured. Each rail's 'wallet_scope' says if its pay-to wallet is 'dedicated' (the buyers/payments/volume are this service's own) or 'shared' (a relay/treasury fronting 'wallet_services' services, so those figures are the pool's inbound, not this service alone). Prefer verified=true before paying anyone.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | No | settlement network, e.g. base, solana, polygon, tempo | |
| limit | No | maximum number of results to return (default 10) | |
| query | Yes | what you need, e.g. 'twitter data', 'web search', 'rpc ethereum' | |
| protocol | No | restrict to one payment protocol: x402 or mpp | |
| min_score | No | minimum trust score 0-100 — set high (e.g. 85) for money-moving tasks | |
| proven_only | No | only services that have EARNED reputation over time (excludes 'new' services and 'watch' services whose on-chain payments are concentrated / not yet broadly distributed). Reputation is earned via consistent history + on-chain buyer retention; a brand-new well-behaved service is verified but new, not top-trust. | |
| max_price_usd | No | max price per call in USD | |
| require_fresh | No | live re-probe stale results before returning — use before paying real money; adds ~1s per stale service | |
| verified_only | No | only services that passed the latest live probe | |
| max_latency_ms | No | reject services slower than this (ms) | |
| exclude_concentrated | No | exclude services from operators with many listings under one registrable owner (a neutral concentration signal, not a fraud claim) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint and openWorldHint annotations, the description discloses important result-shaping behaviors: unified per host, rails each with their own reputation/price/retention, wallet_scope semantics (dedicated vs shared), and coming_soon indicating unmeasured chains. This is substantial behavioral context that an agent cannot infer from annotations or the schema.
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?
Every sentence earns its place: purpose, result structure, rail semantics, wallet_scope interpretation, and a usage warning. The description is dense with meaning but not bloated, and the most critical scoping information appears early.
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 there is no output schema, the description does a strong job of explaining key result fields: rails, wallet_scope, coming_soon, and matched_rail. However, the phrasing 'Pass chain and matched_rail marks that chain's rail' is slightly ambiguous about whether matched_rail is an input or output field, which is a minor completeness gap.
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 100% schema description coverage, the baseline is 3. The description adds value by explaining how chain interacts with the output (matched_rail) and what wallet_scope means for interpreting payments/volume, which goes beyond the schema. It does not deeply explain every parameter, but the schema already handles those.
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 opens with a clear verb and resource: 'Search Verantis's verified directory of machine-payable services (x402, MPP)'. It further clarifies the result model (unified per service, per-rail data) and naturally distinguishes itself from siblings like check_wallet and directory_stats by focusing on the search/query behavior.
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 gives clear operational guidance: pass 'chain' to see rail-specific reputation, and 'Prefer verified=true before paying anyone' to signal high-stakes selection. However, it does not explicitly contrast with alternatives like get_service, so it stops short of full when-to-use versus 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_serviceARead-onlyInspect
Full unified record for one service host: every settlement rail it accepts on, each with its own reputation, price, buyers, volume and history, plus coming-soon chains. Each rail's 'wallet_scope' marks a 'shared' pay-to wallet (buyers/volume are pooled inbound across 'wallet_services' services, not this one alone) vs 'dedicated' (this service's own). Pass the host (domain).
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes | the service host / domain to look up, e.g. api.nansen.ai |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, and the description adds valuable behavioral context beyond that: the wallet_scope distinction between 'shared' pooled-inbound wallets and 'dedicated' wallets. No behavior contradicts the annotations.
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 three sentences are front-loaded with the core purpose and then add necessary semantic detail about wallet_scope. No sentence is wasted, and the length is appropriate for the conceptual nuance being conveyed.
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 fully characterizes what the returned 'full unified record' contains, including per-rail fields and the subtle wallet_scope behavior. With one well-documented parameter and read-only annotations, nothing essential is missing 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%, and the schema already documents 'domain' as the service host/domain to look up with an example. The description only repeats 'Pass the host (domain)', adding no new parameter-level meaning beyond what the schema provides.
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 a specific resource ('full unified record for one service host') and enumerates its contents: settlement rails, reputation, price, buyers, volume, history, and coming-soon chains. This clearly distinguishes it from directory-level or wallet-level sibling tools, even without naming them.
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?
It gives clear context for use: when you need a complete record for one service host, and it explicitly instructs the caller to pass the host domain. It does not explicitly name alternatives or state when not to use this tool, but the singular-host scope is enough to guide selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
2 tool updates
- Changed
find_paid_service2 fields changed- added
Input schema / properties / limit / descriptionAdded value: +"maximum number of results to return (default 10)" - added
Input schema / properties / protocol / descriptionAdded value: +"restrict to one payment protocol: x402 or mpp"
- Changed
get_service1 field changed- added
Input schema / properties / domain / descriptionAdded value: +"the service host / domain to look up, e.g. api.nansen.ai"
4 tool updates
- First observed
check_wallet - First observed
directory_stats - First observed
find_paid_service - First observed
get_service
Related MCP Connectors
Paid x402 and MPP tools for agent discovery, payment safety, data, and DeFi.
Paid pre-execution risk verification for AI agents over MCP and x402.
Verify x402 payment endpoints before an AI agent pays: scam scan, on-chain checks, trust scores.
Pre-payment merchant trust checks for x402 agents on Base and Solana.
Related MCP Servers
- FlicenseNot gradedqualityAmaintenanceEnables agents to discover and verify paid agent services through x402 payment validation and release gate checks.-
- AlicenseAqualityBmaintenanceBefore an AI agent pays an x402 endpoint, checks whether it's safe to pay: liveness, scam/anomaly scan (payTo hijack, bait-and-switch, honeypot), and on-chain receiver verification. ~70% of x402 endpoints are dead or scams.3MIT
- AlicenseNot gradedqualityBmaintenanceMCP server for verifying agent payment integrity on x402, providing tools to check payTo mismatches, market stats, and lookup endpoints.1MIT
- FlicenseNot gradedqualityBmaintenanceEnables users to verify that an AI agent is who it claims to be by combining domain verification, agent-card checks, and a live MCP handshake, with paid requests handled via x402 on Base Sepolia testnet.-
Glama MCP Gateway
Add one secure layer between your agents and this server.