Allows resolving Farcaster usernames to their verified wallet addresses, and building unsigned tip calldata for tipping creators on Farcaster via the BaseZap platform.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@basezap-mcp resolve Farcaster username @dwr"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP (Model Context Protocol) server that exposes BaseZap's tipping-agent tools to any MCP client — Claude Desktop, Cursor, Claude Code, etc.
This server is read-only / non-custodial by design: it never holds private keys, never signs anything, and never broadcasts a transaction. It only fetches platform info, computes fee quotes, and builds unsigned ERC-20 transfer calldata for a separate wallet-connected client to sign and send.
get_platform_info — chain, USDC address, platform fee (bps), fee wallet.
get_tip_quote — given a USDC amount, returns the exact creator/platform fee split.
build_tip_calldata — given a recipient address + amount, returns unsigned
calldata for both legs of a tip. Never signs or sends anything.
resolve_farcaster_username — resolves a Farcaster username to their
verified wallet address (uses BaseZap's /api/resolve-user endpoint directly).
Related MCP server: x402-bazaar-mcp
npm install --ignore-scripts
npm run build(--ignore-scripts avoids native-module build issues on some environments,
e.g. Termux/Android — harmless to use anywhere.)
npm startOr test a single tool call directly over stdio without any MCP client:
echo '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_tip_quote","arguments":{"amountUsdc":1}}}' | node build/index.jsAdd this to your claude_desktop_config.json (Settings → Developer → Edit Config):
{
"mcpServers": {
"basezap": {
"command": "node",
"args": ["/absolute/path/to/basezap-mcp/build/index.js"],
"env": {
"BASEZAP_USE_X402": "false"
}
}
}
}Replace the path with the real absolute path to build/index.js on your
machine. Restart Claude Desktop after editing the config.
By default (BASEZAP_USE_X402=false or unset), the server calls BaseZap's
free endpoint (/api/agent). Set BASEZAP_USE_X402=true to route calls
through the paid x402 endpoint instead ($0.001 USDC per call).
Important: setting BASEZAP_USE_X402=true alone does NOT make the server
pay automatically — you'll get a clear HTTP 402 Payment Required error on
every call unless you've separately set up auto-pay (see below) or are using
an MCP client/gateway that already handles x402 payment for you.
See AUTOPAY.md for a from-scratch guide to making this server pay its own
x402 fees automatically using a funded wallet. Read it carefully before
using it — it involves putting a real private key in an environment
variable, and a misconfigured auto-pay server can silently spend real money
on every tool call. It is NOT wired in by default, and you should understand
exactly what it does before enabling it.
The exact request/response shape this server relies on was confirmed live
against the real /api/agent endpoint (not assumed from documentation):
{ "tool": "get_tip_quote", "args": { "amount_usdc": 1 } }returns:
{ "total_usdc": 1, "creator_receives_usdc": 0.95, "platform_fee_usdc": 0.05, "platform_fee_bps": 500 }Note the API itself uses snake_case field names inside args — this server's
MCP tool inputs use friendly camelCase (amountUsdc) and translate
internally, so this is only relevant if you're modifying the server itself.
Given a recipient address and a USDC amount, returns UNSIGNED ERC-20 transfer calldata for both legs of a BaseZap tip (creator leg + platform fee leg). This tool never holds keys, never signs, and never broadcasts anything — the returned calldata must be signed and sent by a separate wallet-connected client.
| Name | Required | Description | Default |
|---|---|---|---|
| recipient | Yes | The recipient's wallet address, e.g. 0xabc123... | |
| amountUsdc | Yes | Total tip amount in USDC, before the fee split |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description fully bears the transparency burden. It states the tool is read-only (never signs or broadcasts), returns unsigned calldata, and describes the output as two parts (creator + platform fee). 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?
Two sentences, front-loaded with the main action and key constraints. Every phrase adds value—no fluff, jargon-only terms (UNSIGNED, ERC-20, BaseZap) are domain-appropriate.
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 builds calldata for two legs—commendable to mention. But without an output schema, the description could specify the exact format (e.g., hex string, object). The fee split details are omitted, though sibling get_tip_quote may provide them. Nearly complete but has a minor gap in output specification.
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 both parameters with descriptions (recipient with pattern, amountUsdc with exclusive minimum). The description adds value by linking them to the output context (USDC amount before fee split, recipient for calldata). The 100% schema coverage raises the baseline to 3, and the description provides moderate extra meaning.
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?
Description clearly states the tool builds unsigned ERC-20 transfer calldata for both legs of a BaseZap tip, using a verb ('builds') and resource ('calldata for BaseZap tip'). It distinguishes from sibling tools like get_tip_quote (which provides quotes) and get_platform_info (which returns platform details).
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 warns that the tool never keys/signs/broadcasts, requiring external signing—a clear usage constraint. However, it does not specify when to prefer this tool over alternatives (e.g., after quoting with get_tip_quote) or mention prerequisites like wallet connectivity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Returns BaseZap's static platform configuration: chain, USDC contract address, platform fee (basis points), and the platform fee wallet address. Read-only, no arguments needed.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility. It explicitly states 'Read-only,' which is the key behavioral trait, and notes no arguments are needed, reducing ambiguity. It could further disclose whether the data is cached or if authentication is required, but for static platform config the description is sufficiently transparent.
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: the first lists the purpose and return data, the second confirms read-only and no arguments. Every word contributes meaning, there is no repetition or fluff. Perfectly structured for quick parsing.
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 tool's simplicity (no parameters, no output schema, low complexity), the description is fully complete. It covers purpose, behavior, input requirements, and expected output content. No additional information is needed for correct tool 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?
There are zero parameters, and the schema coverage is 100%. The description adds value by explicitly stating 'no arguments needed,' clarifying there is no input required. It also previews the output fields (chain, USDC address, fee, wallet), compensating for the lack of an output 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 returns BaseZap's static platform configuration, listing specific fields (chain, USDC contract, platform fee, fee wallet). It ends with 'Read-only, no arguments needed,' which reinforces its purpose. The sibling tools involve tipping and username resolution, so this tool is distinct and easily differentiated.
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 explains what the tool does and notes it takes no arguments, giving basic usage guidance. However, it does not provide explicit when-to-use or when-not-to-use scenarios, nor does it reference alternatives among the sibling tools. For a simple read-only config tool, this is minimally adequate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Given a USDC tip amount, returns the exact fee split: how much the creator/recipient receives vs. how much goes to BaseZap's platform fee wallet. Does not send anything — quote only.
| Name | Required | Description | Default |
|---|---|---|---|
| amountUsdc | Yes | Tip amount in USDC, e.g. 1 for $1.00 |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full burden. It transparently states that the tool is read-only and does not trigger any side effects ('Does not send anything'). It also discloses the exact output (fee split between creator/recipient and platform wallet). While it does not mention authentication or rate limiting, the disclosed behaviors are sufficient for a simple quote 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?
The description consists of two sentences with zero wasted words. The first sentence immediately states the core function and output. The second clarifies what it does not do. The structure is front-loaded and perfectly concise.
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 a single parameter and no output schema, the description fully explains the input (USDC amount) and the output (fee split details). It also clarifies the tool's non-execution behavior. There are no gaps—the AI agent can confidently decide whether to invoke this tool and understand its return value.
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 coverage is 100%, with a clear parameter description and a constraint (exclusiveMinimum). The tool description does not add any new meaning beyond what the schema already provides (e.g., it restates 'USDC tip amount'). Following the rubric, baseline 3 is appropriate when schema coverage is high and the description adds no extra semantic 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 uses a specific verb ('returns') and a precise resource ('exact fee split'). It clearly distinguishes this tool from the sibling 'build_tip_calldata' by explicitly stating 'Does not send anything — quote only.' The purpose is unambiguous and well-differentiated.
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 implicitly tells the AI when to use this tool (to get a fee quote before sending a tip) and when not to use it (because it does not send anything). However, it does not explicitly name the alternative tool 'build_tip_calldata' or provide an explicit when-not-to-use condition, leaving the decision slightly less guided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Resolves a Farcaster username (with or without @) to their profile info and verified wallet address on Base. Useful for looking up a tip recipient's address before calling build_tip_calldata.
| Name | Required | Description | Default |
|---|---|---|---|
| username | Yes | A Farcaster username, e.g. 'afifarioss' or '@afifarioss' |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description bears full responsibility for behavioral disclosure. It states the tool resolves a username to profile info and verified wallet address, implying a read operation. However, it does not mention error behavior (e.g., for nonexistent usernames), rate limits, authentication needs, or the structure of the returned profile info. This is adequate for a simple lookup but leaves gaps.
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 concise sentences: the first states the core functionality, the second provides a usage context linking to a sibling tool. No extraneous words, no repetition of schema details, and the structure is front-loaded with the main 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 tool's simplicity (1 param, no output schema), the description covers the essential purpose and a concrete use case. It mentions the key output elements (profile info and wallet address on Base). However, it does not describe the return format or error conditions, which a lacking output schema makes more necessary. Minor gap, but still largely complete for the context.
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% for a single parameter, with the schema already providing type, constraints, and an example. The description adds the note about accepting usernames 'with or without @', which aligns with the schema example. The additional context about the resolution output (profile info and wallet address) gives purpose to the parameter but does not deeply expand semantics beyond what the schema conveys.
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 ('Resolves a Farcaster username') and the specific resource (username to profile info and verified wallet address on Base). It distinguishes itself from siblings by explicitly linking to build_tip_calldata as a downstream use case. The verb 'Resolves' is specific and the resource is well-defined.
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 provides a clear when-to-use scenario: 'Useful for looking up a tip recipient's address before calling build_tip_calldata.' This establishes context and a workflow. However, it does not explicitly state when not to use the tool or mention alternative siblings for resolution.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0build_tip_calldataget_platform_infoget_tip_quoteresolve_farcaster_usernameEach tool has a clearly distinct purpose: platform info, tip quote, calldata building, and username resolution. There is no overlap or ambiguity.
All tools follow a consistent verb_noun pattern in snake_case: get_platform_info, get_tip_quote, build_tip_calldata, resolve_farcaster_username. No mixing of conventions.
Four tools is well-scoped for a focused tipping service. Each tool earns its place, covering the essential operations without unnecessary bloat.
The tool surface covers the full workflow for preparing a tip: platform config, fee quote, address resolution, and calldata generation. The omission of signing and broadcasting is intentional and not a gap.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Monetize any MCP server: x402 paywall, pay-per-call billing in USDC on Base, agent marketplace.
Agent-commerce MCP server for x402/USDC payments and affiliate splits on Base.
Public read-only MCP server for HODLXXI agent identity, trust, receipts, and verification.
SqueezeOS MCP for live machine discovery and x402-paid USDC APIs on Base.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/afifarioss/basezap-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
