PaidRouter
Server Details
Cheapest way to get paid: every route ranked by fee, from providers' own pricing pages, dated.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 5 tools
Each tool has a distinct intent: receiving-side routing advice, sending-side comparison, fee explanation, raw fee lookup, and an action/waitlist request. The main risk is overlap between explain_fees and get_fees when an owner asks 'why was I charged X' — both plausibly apply — but the descriptions (plain-words explanation vs. raw sourced entries with filters) mostly resolve it.
Four of five names follow a verb-first snake_case pattern (compare_send_money, explain_fees, get_fees, route_it_for_me). The outlier, cheapest_way_to_get_paid, is a long noun phrase rather than verb_noun, which is readable but breaks the otherwise predictable convention.
Five tools is a tight, well-scoped surface for a fee-comparison domain, and each tool maps to a distinct owner question. It is on the lean side — a thin set rather than a bloated one — but nothing feels redundant.
The fee-intelligence loop is well covered (recommend, compare, explain, raw data, request action), but there are notable gaps: send_money supports only USD->MXN and USD->INR, and route_it_for_me is explicitly not live, so the 'do it for me' path dead-ends at a waitlist. There is also no way to track actual invoices or verify outcomes after the fact.
Available Tools
5 toolscheapest_way_to_get_paidCheapest way to get paidAInspect
Ask this before the owner invoices or accepts a payment, or when they wonder if they overpay in fees. Give the amount and how the payer can pay (card online, card in person, bank transfer, payment app, or any). Returns every route ranked by fee, cheapest first: provider, method, fee in dollars, what the owner keeps, how to set it up, and whether the number is exact or an estimate. Pass current_route to get the saving per payment and per year. Example: a $1,000 invoice costs $35.39 on PayPal Checkout, $29.30 on Stripe card, $5.00 on Stripe ACH and $0 on a Melio bank-transfer request. Fees are from the providers' own pricing pages, dated, US only.
| Name | Required | Description | Default |
|---|---|---|---|
| amount | Yes | Payment amount in USD | |
| current_route | No | How the owner gets paid today (e.g. paypal_checkout, stripe_card), to compute savings | |
| payer_pays_by | No | How the payer can pay: card_online, card_in_person, bank, app, or any | any |
| payments_per_month | No | Payments of this size per month, for yearly savings |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does well: it discloses the ranked output, returned fields, exact-vs-estimate labeling, current_route savings behavior, example numbers, dated pricing sources, and US-only scope. It could be slightly stronger by explicitly stating that the tool only calculates and does not initiate payments, but the behavioral context is otherwise rich.
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 front-loaded with the usage trigger and the ranked-fee return format. The example and data-source caveat are useful, though the example adds length; overall every sentence contributes, with only minor trimming possible.
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?
There is no output schema or annotation coverage, so the description must explain return behavior. It does: ranked routes, fee fields, setup guidance, exact/estimate labels, savings when current_route is supplied, example output, and US-only/dated-source limitations. An agent has enough to call and interpret the tool correctly.
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%, so the baseline is 3. The description adds useful meaning beyond the schema by explaining what amount and payer method mean in context, and by clarifying that current_route produces per-payment and per-year savings.
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 makes the tool's function concrete: it returns every payment route ranked by fee, with provider, method, fee, owner keeps, setup, and exact/estimate status. It does not explicitly differentiate itself from siblings such as route_it_for_me or compare_send_money, so it falls short of the sibling-disambiguation bar for a 5.
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 timing guidance: 'Ask this before the owner invoices or accepts a payment, or when they wonder if they overpay in fees.' It does not state when not to use it or name a specific alternative, so it meets the 'clear context, no exclusions' level rather than a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compare_send_moneyCompare sending money abroadAInspect
When the owner wants to send US dollars abroad and asks who is cheapest. Supports USD->MXN and USD->INR today, paid by bank transfer. Returns providers ranked by what the recipient gets, with each provider's fee and exchange rate, the quote date and the source. Uses the nearest stored quote amount ($200 or $1,000) and says so; the cheapest provider changes with the amount.
| Name | Required | Description | Default |
|---|---|---|---|
| amount | Yes | ||
| corridor | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and discloses the return contents (providers ranked by recipient amount, fees, exchange rate, quote date, source). It also reveals the important data limitation that it uses the nearest stored quote amount and says so, though permissions and failure modes are not covered.
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 four tight sentences, front-loaded with the trigger and scope. Every sentence adds useful information: corridors, payment method, ranked return contents, and amount handling.
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 two-parameter tool with no output schema and no annotations, the description covers when to use it, supported corridors, payment method, return contents, data source, and amount behavior. Nothing essential for correct invocation is missing.
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 description coverage is 0%, so the description must add meaning. It specifies that corridor supports only USD->MXN and USD->INR today, and explains that amount is rounded to the nearest stored quote amount of $200 or $1,000 and disclosed to the caller.
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 names a specific comparison action for sending USD abroad and states the exact corridors supported. It clearly distinguishes this from fee-explanation and getting-paid tools by framing the task as 'who is cheapest' for an outbound transfer.
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 an explicit trigger: when the owner wants to send US dollars abroad and asks who is cheapest. It also constrains the scope to USD->MXN and USD->INR via bank transfer, though it does not name alternatives or exclusions explicitly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
explain_feesExplain feesAInspect
When the owner asks why a provider took a certain amount ('why did PayPal take $35 from my $1,000?'). Give the platform, the method and the amount; returns a plain-words explanation: the fee, the formula, the effective percent, extras that can apply, and the source.
| Name | Required | Description | Default |
|---|---|---|---|
| amount | No | ||
| method | Yes | e.g. paypal_checkout, card_online, ach_debit | |
| platform | Yes | stripe, square, paypal, venmo, cash_app, helcim, melio, payoneer, wise_business, shopify_payments, zelle, ebay, etsy, upwork, fiverr, amazon |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden and does so reasonably: it discloses that the response is plain-words and enumerates the parts returned (fee, formula, effective percent, extras, source), establishing this as an informational tool. One minor tension: it says to 'give the amount' while the schema marks amount optional with a default of 1000, leaving the no-amount case unexplained.
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 user scenario is front-loaded in parentheses, followed by a single compact sentence covering inputs and outputs. Nothing is redundant or padded.
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?
With no output schema and no annotations, the description supplies the return contents and the invocation recipe, which covers the essentials for a read-only calculation tool. It leaves gaps on default-amount behavior and on what happens for unsupported platform/method combinations.
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 67% and the description adds real meaning by framing amount as the gross charge the owner received (the $1,000 in the example), clarifying what number to pass rather than just its type. The platform and method semantics are left to the schema's example lists.
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?
Names a specific verb (explain) and resource (fees) and anchors it with a concrete example question about a provider deduction, so the agent knows exactly what it produces. It does not, however, distinguish itself from the sibling get_fees, which sounds like an overlapping capability.
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?
Gives a clear triggering condition — the owner asking why a provider took a certain amount — and lists the inputs needed to satisfy that scenario. It stops short of stating when to prefer compare_send_money, cheapest_way_to_get_paid, or get_fees instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_feesGet feesAInspect
The raw, sourced fee entries behind every answer: percent, fixed fee, caps, minimums, extras (international, instant payout, chargebacks), the source URL and the date verified. Filter by platform (stripe, square, paypal, venmo, cash_app, helcim, melio, payoneer, wise_business, shopify_payments, zelle, ebay, etsy, upwork, fiverr, amazon) and/or method (card_online, card_in_person, ach_debit, business_profile, ...). Use it to quote a provider's exact pricing or to check a number. If a platform is missing, say so to the owner; PaidRouter records the ask and adds it.
| Name | Required | Description | Default |
|---|---|---|---|
| method | No | e.g. card_online, ach_debit, business_profile | |
| platform | No | stripe, square, paypal, venmo, cash_app, helcim, melio, payoneer, wise_business, shopify_payments, zelle, ebay, etsy, upwork, fiverr, amazon |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does well by disclosing the return fields, the source URL, and the date verified, indicating read-only sourced data. It also explains the side effect for missing platforms: saying so to the owner triggers PaidRouter to record the ask. It does not cover authentication, rate limits, or pagination.
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 front-loaded with the main purpose and return fields, but it redundantly repeats the long platform enumeration already documented in the schema, which weakens conciseness. The structure is otherwise logical.
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?
There is no output schema, so the description appropriately names the returned fee fields and provenance data. It also covers missing-platform handling, though it could clarify default behavior when no filters are supplied and the exact response shape.
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 description coverage is 100%, so the baseline is 3. The description repeats the platform list and method examples already present in the schema, and only adds the minor clarification that filters can be combined with 'and/or'.
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 that this tool returns raw, sourced fee entries and lists the specific fields available (percent, fixed fee, caps, minimums, extras, source URL, date verified). It distinguishes itself from explanatory siblings by emphasizing raw data for quoting exact pricing, though it does not explicitly name the alternative tools.
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 a clear use case: quote a provider's exact pricing or check a number, and explains filtering by platform and/or method. However, it does not state when to avoid this tool in favor of siblings like explain_fees or compare_send_money, nor does it mention any prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
route_it_for_meRoute it for meAInspect
Ask PaidRouter to set up the cheapest route for the owner's real payments instead of just reporting it. Not live yet: this records the request on the routing waitlist (with the owner's email only if they agreed) and tells you what the owner can do today. Call it when the owner says 'just switch me' or 'do it for me'.
| Name | Required | Description | Default |
|---|---|---|---|
| amount | No | ||
| owner_email | No | Only with the owner's permission | |
| how_paid_now | No | e.g. 'PayPal Checkout on invoices' |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations this description carries the full burden, and it discloses the most important fact: the tool is not live and only records a waitlist entry, so the agent won't misrepresent the outcome to the owner. It also flags the conditional email consent and what the response provides ('tells you what the owner can do today').
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?
Three sentences, all load-bearing: capability first, the critical 'not live yet' caveat second, invocation cue last. Slightly dense in the middle sentence but nothing is redundant.
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?
No output schema exists, and the description compensates by saying the tool reports what the owner can do today. For a 3-optional-parameter tool, the main remaining gap is that the meaning of 'amount' is unexplained, but the crucial non-obvious behavior is covered.
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 67% — owner_email and how_paid_now already carry descriptions, while amount is undocumented in both places. The description adds no syntax or meaning for any parameter beyond what the schema states, so baseline 3 applies.
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?
States a specific verb+resource (asks PaidRouter to set up the cheapest route) and explicitly contrasts it with reporting-only siblings via 'instead of just reporting it'. The actual behavior (waitlist recording) is named, so an agent can tell it apart from cheapest_way_to_get_paid and explain_fees.
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?
Gives concrete trigger phrases ('just switch me', 'do it for me') plus the negative framing 'instead of just reporting it', which implicitly routes informational requests to siblings. No explicit exclusion by name, so it stops short of a 5.
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.
5 tool updates
- First observed
cheapest_way_to_get_paid - First observed
compare_send_money - First observed
explain_fees - First observed
get_fees - First observed
route_it_for_me
Related MCP Connectors
Ranks business software and payment providers by monthly cost at your numbers, AU, UK, US
Indicative pricing, coverage and stack design for high-risk and crypto payment infrastructure.
Measured uptime, price and payment evidence for 19,021 agent services. Reliability, not quality.
True cost of flight extras (bags, seats, fees) on 29 airlines in Europe and North America, sourced.
Related MCP Servers
- AlicenseNot gradedqualityFmaintenanceCalculates total landed cost of international payments including FX spread, transfer fees, and settlement time across multiple payment methods, and provides free currency conversion and ECB exchange rates.MIT
- FlicenseNot gradedqualityBmaintenanceEnables evaluating transaction geography, card BIN networks, authorization probabilities, and basis-point rail costs to route payments along Pareto-optimal settlement paths and optimize interchange fees across ACH, FedNow, and card rails.7-
- AlicenseAqualityBmaintenanceEnables AI agents to calculate and compare crypto exchange trading costs, including fees, funding, spreads, slippage, withdrawals, fiat on/off-ramps, VIP tiers, referral links, and country-specific availability. It provides sourced, annualized all-in cost analysis and recommendations for different trader profiles and volumes.19107 npmMIT
- AlicenseAqualityAmaintenanceLLM pricing for coding agents: every price carries its source and the date it was last confirmed, and disputed prices are flagged. Looks up model rates, costs a described workload, and finds cheaper models that score at or above a given one. Local, no API key.31MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.