Tollbooth Swap API
Server Details
Token swaps and honeypot/rug checks for AI agents on 8 chains, paid per-call in USDC via x402.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
- Repository
- soundsparkaudiolab/tollboothswap-mcp
- GitHub Stars
- 1
- Server Listing
- tollboothswap-mcp
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.3/5 across 6 of 6 tools scored.
Each tool targets a distinct function: quoting, swap building, token safety, receipts, service info, and token resolution. There is no overlap between tools, and the split between free and paid actions is clear.
All tool names follow a consistent verb_noun snake_case pattern (build_swap, check_token, get_quote, get_receipt, get_service_info, resolve_token). The naming is predictable and uniform.
Six tools is a well-scoped count for a swap API, covering the essential user workflow without excessive granularity or missing core functions.
The tool surface covers the main swap journey: resolve token, check safety, get quote, build swap, and fetch receipts, plus service metadata. A minor gap is the lack of swap status or cancellation endpoints, but these are not core to this service's purpose.
Available Tools
6 toolsbuild_swapBuild swap transactionAInspect
Build an unsigned swap transaction for the taker wallet to sign and submit. Costs an x402 toll in USDC (paid automatically when the x-tollbooth-payer-key header is set). Returns the transaction, quote, and a signed receipt.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | Yes | Chain to operate on | |
| taker | Yes | Wallet address that will sign and send the swap | |
| amount | Yes | Sell amount as an integer string in the input token's base units | |
| safeMode | No | Screen both tokens first; refuses the build if either is critical-risk (honeypot etc.) | |
| inputToken | Yes | Token being sold: mint address (solana) or ERC-20 address (EVM chains) | |
| outputToken | Yes | Token being bought: mint address (solana) or ERC-20 address (EVM chains) | |
| slippageBps | No | Max slippage in bps (default 100) |
Output Schema
| Name | Required | Description |
|---|---|---|
| next | No | Suggested follow-up calls |
| chain | No | |
| error | No | Present when the request failed or payment is required |
| quote | No | Quote the transaction was built from |
| safety | No | Safety reports when safeMode was requested |
| accepts | No | x402 payment options when unpaid |
| receipt | No | Signed receipt for this build |
| transaction | No | Unsigned transaction for the taker to sign |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already convey that this is a non-read-only, non-destructive, non-idempotent operation. The description adds meaningful behavioral context by disclosing the x402 toll in USDC, automatic payment via header, and that the transaction is unsigned, which impacts how an agent should handle post-conditions. This goes beyond the structured 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 description is a succinct two-sentence structure: first sentence states the primary action, second adds cost and return details. It is front-loaded, with no filler or redundant repetition of schema information.
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 tool is moderately complex (7 parameters, output schema present), and the description covers the key behavioral requirements: building an unsigned transaction, the toll cost, and the return contents. With the rich schema and output schema, the description is sufficient for correct tool invocation, though it doesn't mention potential failure scenarios or prerequisites.
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 input schema already documents all parameters (chain, taker, amount, safeMode, inputToken, outputToken, slippageBps). The description does not add per-parameter semantics beyond the schema, so it meets the baseline but provides no extra value.
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's function: 'Build an unsigned swap transaction for the taker wallet to sign and submit.' This is a specific verb+resource and distinguishes build_swap from sibling tools like get_quote and get_receipt, which have different purposes.
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 constructing a swap transaction but does not explicitly reference alternatives or when-not-to-use. For example, it doesn't say 'use this after getting a quote' or 'if you only need a price, use get_quote.' Thus, guidance is implicit rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_tokenCheck token safetyAIdempotentInspect
Token safety screen before trading: honeypot, rug-pull, freeze/mint authority, transfer hooks, sell tax, blacklists. Returns verdict (ok/warn/critical/unknown), risk score, and findings. Costs an x402 toll.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | Yes | Chain to operate on | |
| token | Yes | Token to screen: mint address (solana) or ERC-20 address (EVM chains) |
Output Schema
| Name | Required | Description |
|---|---|---|
| next | No | Suggested follow-up calls |
| chain | No | |
| error | No | Present when the request failed or payment is required |
| token | No | |
| source | No | Data source used for the screen |
| accepts | No | x402 payment options when unpaid |
| verdict | No | ok, warn, critical, or unknown |
| findings | No | Individual risk findings |
| riskScore | No | 0 (safe) to 100 (critical) |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the x402 toll cost, which is not present in the annotations, and outlines the return structure (verdict, risk score, findings). This adds meaningful behavioral context beyond the idempotent and readOnly hints. There is no contradiction with 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?
Two sentences carry all necessary information: purpose, checks performed, return values, and cost. The purpose is front-loaded and every clause earns its place.
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 only two parameters, a full output schema, and annotations, the description covers purpose, return values, cost, and the checks performed. No significant gaps remain.
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?
The input schema already provides complete descriptions for both 'chain' and 'token' (100% coverage). The tool description does not add further parameter-level meaning, so it earns the baseline score of 3.
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 token safety before trading, enumerating specific checks (honeypot, rug-pull, freeze/mint authority, etc.). This distinguishes it from siblings like get_quote and build_swap, which focus on pricing and swapping.
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 phrase 'before trading' provides clear context on when to use the tool. Mentioning the x402 toll implies users should invoke it judiciously. However, it does not explicitly name alternatives or exclusion criteria, 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.
get_quoteGet swap quoteARead-onlyIdempotentInspect
Get a free indicative swap quote (output amount includes Tollbooth's fee). Use before build_swap to decide whether to trade.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | Yes | Chain to operate on | |
| amount | Yes | Sell amount as an integer string in the input token's base units | |
| inputToken | Yes | Token being sold: mint address (solana) or ERC-20 address (EVM chains) | |
| outputToken | Yes | Token being bought: mint address (solana) or ERC-20 address (EVM chains) | |
| slippageBps | No | Max slippage in bps (default 100) |
Output Schema
| Name | Required | Description |
|---|---|---|
| next | No | How to build the swap transaction |
| chain | No | |
| feeBps | No | Tollbooth fee in basis points |
| inputToken | No | |
| inputAmount | No | Sell amount in base units |
| outputToken | No | |
| slippageBps | No | |
| outputAmount | No | Estimated buy amount in base units, after fees |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, and idempotentHint. The description adds valuable context beyond these: the output includes Tollbooth's fee, and the quote is 'indicative' (non-binding). This provides useful behavioral nuance without contradicting 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?
Two sentences, no wasted words. The description front-loads the core purpose and immediately follows with usage guidance. Every sentence earns its place.
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 full parameter schema coverage, clear annotations, and an output schema present, the description completes the picture by adding usage context and fee transparency. It is sufficient for an AI agent to select and invoke this 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?
The schema covers 100% of parameters with detailed descriptions, so the description is not required to explain parameters. It does add context about the output ('output amount includes Tollbooth's fee') but does not extend parameter semantics beyond the 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 the tool's function: 'Get a free indicative swap quote' with a specific verb and resource. It also differentiates from sibling build_swap by being an 'indicative' quote and explicitly mentions 'Use before build_swap', distinguishing it from the execution tool.
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 'Use before build_swap to decide whether to trade', providing clear when-to-use guidance. It implies alternatives (build_swap for actual execution) and clarifies this is an informational step, not a trade.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_receiptGet signed receiptARead-onlyIdempotentInspect
Fetch a signed Tollbooth receipt by id and verify its signature.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Receipt id returned by build_swap |
Output Schema
| Name | Required | Description |
|---|---|---|
| id | No | Receipt id |
| error | No | Present when the receipt was not found |
| valid | No | Whether the signature verified |
| receipt | No | Receipt payload |
| signature | No | Server signature over the receipt |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly and idempotent hints. The description adds the behavior of signature verification, which is relevant context beyond what annotations provide. 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?
Single sentence with no filler. Clearly front-loaded with the primary action and resource.
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 one-parameter read-only tool with output schema, the description is sufficient. It covers the main purpose and verification aspect, though it doesn't mention failure modes, which the output schema could cover.
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 param description already explains that id is a receipt id from build_swap. The tool description adds no additional meaning beyond what the schema provides, 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?
The description clearly states the action (Fetch), resource (signed Tollbooth receipt), and distinguishes it from siblings by focusing on receipts and signature verification. This is specific and unambiguous.
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 context of usage is clear: the id comes from build_swap, implying this is used after creating a swap. While it doesn't explicitly say when not to use it, the workflow hint provides sufficient guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_service_infoGet service infoARead-onlyIdempotentInspect
Get Tollbooth service metadata: supported chains, swap fee, x402 toll pricing.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| name | No | Service name |
| payment | No | x402 payment networks and pricing |
| endpoints | No | HTTP endpoints exposed by the service |
| description | No | What the service does |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, covering safety and idempotency. The description adds value by disclosing exactly what metadata is returned (supported chains, swap fee, x402 toll pricing), which is beyond the structured annotations. No contradiction exists.
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, well-structured sentence that front-loads the action and resource, then lists key content. Every element adds information, with no fluff or redundancy.
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 zero-parameter metadata retrieval tool with an output schema and strong annotations, the description fully covers the necessary context. It specifies the tool's scope and content without needing to describe return formats, which the output schema handles.
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?
The tool has zero parameters, so the baseline is 4 per the rubric. The description is not required to explain parameter semantics since there are none, and the schema trivially covers 100%.
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 verb 'Get' and the resource 'Tollbooth service metadata', then lists specific content: supported chains, swap fee, x402 toll pricing. This is specific enough to distinguish from sibling tools like get_quote or get_receipt, which focus on trade operations.
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 when to use the tool—whenever service-level metadata is needed—but it does not explicitly mention alternatives or exclusions. Given the zero-parameter, self-contained nature of the tool, the implied usage is acceptable, but explicit guidance is absent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
resolve_tokenResolve token symbolARead-onlyIdempotentInspect
Resolve a token ticker symbol (e.g. PEPE, WIF, USDC) to contract addresses on a chain, free. Curated majors return one verified match; others return live DEX matches ranked by liquidity.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | Yes | Chain to operate on | |
| symbol | Yes | Ticker symbol to resolve, e.g. USDC, PEPE, WIF |
Output Schema
| Name | Required | Description |
|---|---|---|
| next | No | Suggested follow-up calls |
| chain | No | Chain searched |
| symbol | No | Symbol searched |
| matches | No | Matching tokens, best first |
Tool Definition Quality
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, and idempotentHint, covering safety. The description adds valuable behavioral detail: it is free, curated majors yield one verified match, and others return live DEX matches ranked by liquidity. This goes beyond annotations to explain result variability, aiding expectation-setting.
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 two sentences long, with the primary purpose stated in the first sentence. Every clause earns its place, providing examples and behavioral expectations without fluff. It is efficiently structured and easy to parse.
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 tool has an output schema, so return values are documented elsewhere. The description covers the core functionality, the free aspect, and the two resolution modes (curated vs. live DEX). Given the simple parameter set and annotations, this is a complete description.
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?
Both parameters have descriptions in the schema, so schema coverage is 100%. The description provides example symbols (PEPE, WIF, USDC) and reiterates the chain context, but adds little beyond the schema. It meets the baseline for well-documented parameters without compensating for any gaps.
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 uses the specific verb 'resolve' and clearly states the resource (token ticker symbol) and outcome (contract addresses on a chain). It distinguishes itself from sibling tools like check_token or get_quote by focusing on symbol-to-address resolution. The mention of curated vs. live DEX matches further clarifies its unique scope.
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 is for converting a ticker symbol to contract addresses, which is a distinct use case among siblings. However, it does not explicitly mention when to avoid using it or reference alternative tools. The context is clear enough for an agent to select it for symbol resolution tasks.
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
AlicenseAqualityAmaintenancePre-trade DeFi intelligence for AI agents. 20 paid x402 endpoints, USDC on Base.Last updated23721MIT- FlicenseAqualityCmaintenancePay-per-call tools for AI agents including trust checks, due diligence, market data, and human-verified approvals, settled in USDC on Base via the x402 protocol.Last updated16
- Alicense-qualityCmaintenanceMulti-chain x402 payment gateway enabling AI agents to pay per HTTP call with real on-chain settlement across 5 mainnet chains, providing 18 paid endpoints for utilities, data, and security.Last updatedMIT
- Flicense-qualityCmaintenancePay-per-use AI security and research tools for autonomous agents on Base, enabling honeypot detection, risk assessment, wallet analysis, and yield optimization via the x402 protocol.Last updated
Your Connectors
Sign in to create a connector for this server.