Agent Payment Infrastructure
The MCP Server That Gives AI Agents a Wallet
One endpoint. Every payment capability. The financial primitive of the agent economy.
Alimenter votre agent
Installation de l'éditeur. Ce n'est pas un endpoint PlugMCP.
Host a copy with our keys and logs.
Pas encore de version packagée dans le registre. Suivez le README du dépôt.
URL distante ou commande sur votre machine ? Ce qui distingue les deux installations
Exécuter sur PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
LancerWorks with Claude · LangChain · CrewAI · AutoGPT · Cursor · Windsurf · Any MCP client
"The agent economy is forming now. Developers who integrate payment rails first will define how AI agents transact. This is that infrastructure."
If this project helps you build payment-capable agents, please star the repo on GitHub because it helps other developers find it.
How to star: Open the repo, then click the ⭐ Star button in the top-right corner (free GitHub account required).
BananaCrystal provides agent payment infrastructure, which is the missing financial layer of the AI agent stack.
Traditional payment rails (banks, card networks, legacy APIs) were built for humans: human identity, human authorization, human operating hours. When AI agents try to use them they fail architecturally. Fixed fees make micropayments economically impossible, KYC requirements are difficult for agents to satisfy, and 3 to 5 day settlement windows break autonomous workflows.
This MCP server is the alternative. One configuration line gives any AI agent:
This is not a product feature. This is a new category: autonomous payments, the financial primitive of the agent economy built for machines from first principles.
1,000 transactions/day on Stripe: $109,500/year in fees alone. 1,000 transactions/day on BananaCrystal: $365/year. The agent economy runs on micropayments. The infrastructure fee must be microscopic or the economics will collapse entirely.
Step 1: Install
npm install -g @bananacrystal/mcp-server
Step 2: Get a free API key
Sign up at agents.bananacrystal.com → Account → API Keys → Create MCP key.
Fees: Transfers: 0.3% of amount · Swaps: 0.5% of amount · Read-only operations (balances, history, rates): free. Rate service (historical data, batch conversions, statistics): free with "rate" scope key.
Start with a Sandbox key for fake money, zero risk, and full functionality. Sandbox keys start with
bc_test_so you can always tell them apart from live keys. Switch to a Live key (no prefix) when ready.
Step 3: Pick your agent framework
Create a Sandbox key at agents.bananacrystal.com/account → API Keys → Create Sandbox Key.
Sandbox keys start with bc_test_. This prefix is how you and the package know it's a test key with no real money. Live keys have no prefix. The package automatically routes each key to the correct endpoint.
{
"mcpServers": {
"bananacrystal": {
"command": "bananacrystal-mcp",
"env": {
"BANANACRYSTAL_API_KEY": "bc_test_your_sandbox_key_here"
}
}
}
}
Sandbox behaviour:
/mcp/sandbox/rate/* (no auth needed)reset_sandbox_balance toolSwitch to a live key when you're ready. Same tools, same config, real money and live rates.
Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"bananacrystal": {
"command": "bananacrystal-mcp",
"env": {
"BANANACRYSTAL_API_KEY": "bc_live_your_key_here"
}
}
}
}
Restart Claude Desktop. Then ask it:
"Check my BananaCrystal balance"
"Transfer 50 USDb to 0.0.12345 as payment for the data report"
"Swap 100 USDb to NGNb at the current rate"
"Show my last 10 transactions"
Your agent now has a payment wallet.
Add to your IDE MCP config:
{
"mcpServers": {
"bananacrystal": {
"command": "bananacrystal-mcp",
"env": {
"BANANACRYSTAL_API_KEY": "bc_live_your_key_here"
}
}
}
}
Your coding agent can now pay for API calls, data feeds, and compute per use.
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_openai import ChatOpenAI
from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
import asyncio, os
async def create_payment_agent():
client = MultiServerMCPClient({
"bananacrystal": {
"command": "bananacrystal-mcp",
"env": {
"BANANACRYSTAL_API_KEY": os.getenv("BANANACRYSTAL_API_KEY")
},
"transport": "stdio"
}
})
tools = await client.get_tools()
llm = ChatOpenAI(model="gpt-4o", temperature=0)
prompt = ChatPromptTemplate.from_messages([
("system", """You are a financial operations AI agent with an
agent wallet on BananaCrystal agent payment infrastructure.
Always check balance before large transfers.
Always include a memo with every payment.
Report the transaction ID for every settled payment."""),
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad")
])
agent = create_openai_tools_agent(llm, tools, prompt)
return AgentExecutor(agent=agent, tools=tools, verbose=True)
agent = asyncio.run(create_payment_agent())
result = agent.invoke({
"input": "Check balance, then pay 12.50 USDb to vendor:data-provider-01 for today's market data report"
})
# Agent checks balance → verifies limits → requests OTP → executes transfer
# Settlement confirmed on Hedera in 3.2s · txId: 0.0.789@1711234567
from crewai import Agent, Task, Crew
from langchain_mcp_adapters.client import MultiServerMCPClient
import asyncio, os
async def setup_payment_tools():
client = MultiServerMCPClient({
"bananacrystal": {
"command": "bananacrystal-mcp",
"env": {"BANANACRYSTAL_API_KEY": os.getenv("BANANACRYSTAL_API_KEY")},
"transport": "stdio"
}
})
return await client.get_tools()
payment_tools = asyncio.run(setup_payment_tools())
treasury_agent = Agent(
role="Autonomous Treasury Manager",
goal="Monitor stablecoin balances and execute payments within defined limits",
backstory="""You are an AI-native finance agent on the BananaCrystal
agent payment infrastructure. You manage a multi-currency stablecoin
treasury, executing transfers, swaps, and vendor payments autonomously.""",
tools=payment_tools,
verbose=True
)
treasury_task = Task(
description="""Check USDb balance. If above 10,000 USDb, swap 5,000 USDb
to EURb. Then pay vendor invoice of 500 USDb to vendor:accounting-service-01.""",
agent=treasury_agent,
expected_output="Balance checked, swap executed, vendor paid. All transaction IDs logged."
)
result = Crew(agents=[treasury_agent], tasks=[treasury_task]).kickoff()
plugins:
- name: BananaCrystal Payments
package: "@bananacrystal/mcp-server"
description: >
Agent payment infrastructure with autonomous stablecoin transfers,
currency swaps, and fiat operations on the Hedera blockchain.
env:
BANANACRYSTAL_API_KEY: "${BC_API_KEY}"
Every tool an agent needs for complete autonomous payment capability. All live. All guarded.
Beyond the 40 MCP tools above, BananaCrystal backend provides a separate rate service for comprehensive currency exchange operations:
The rate service is a backend HTTP API, not an MCP tool. It's available to agents via REST endpoints (not through this MCP server's tool interface):
How to use: Create an API key with rate scope, then call these endpoints directly from your agent or backend:
# Get current rate
curl -H "x-api-key: bc_live_your_key_with_rate_scope" \
"https://agentic.bananacrystal.com/api/v1/mcp/rate/current?from=USD&to=NGN"
# Response:
{
"from": "USD",
"to": "NGN",
"rate": 1250.50,
"timestamp": "2026-04-28T17:08:24Z"
}
Note: These are backend HTTP endpoints, not MCP tools. If you need real-time rate data in your agent workflows, integrate these endpoints directly into your agent logic rather than using the MCP tool interface.
Sandbox testing: Use /mcp/sandbox/rate/* endpoints (no authentication required) to test rate operations.
Task: "Monitor USDb balance. If above 50,000, swap 20% to EURb."
Flow: get_balances → check threshold → estimate_swap_fees
→ swap_currency → audit log written to Hedera
Result: Rebalanced $42,000 in 4.2 seconds.
Human involvement: zero.
Fee: 0.5% of swap amount.
Task: "Process refund for order #84921. Customer verified. Amount: 45.00 USDb."
Flow: Verify eligibility → transfer_tokens → settlement confirmed
Result: Before: 48-hour queue, 3 staff touchpoints.
After: 2.8 second settlement. Zero staff involvement.
Task: "Verify task completion by agent:worker-03. If verified, pay 12.50 USDb."
Flow: Orchestrator verifies output → request_agent_transaction
→ agent:worker-03 receives payment atomically
This is the agent economy: agents hiring agents, paying for output.
Task: "Pay Nigerian vendor 500 USD equivalent in NGNb."
Flow: get_exchange_rate (USDb/NGNb: 1,580)
→ swap_currency (500 USDb → 790,000 NGNb)
→ transfer_tokens to vendor wallet
Traditional wire: 3–5 days, $35 fee.
BananaCrystal: 4.1 seconds, 0.3% fee.
Task: "Query the pricing data API. Pay per result."
Flow: Agent calls data provider → provider returns HTTP 402
→ agent calls transfer_tokens (0.3% of transfer amount)
→ data unlocked → agent continues workflow
1,000 queries/day = $1.00 in payments + $1.00 in fees.
Economically impossible on Stripe ($300/day in fees alone).
Task: "Show me rates and convert amounts for USD/NGN/EUR/GHS."
Flow: Agent calls rate service (no MCP needed):
GET /api/v1/mcp/rate/current?from=USD&to=NGN
→ returns {rate: 1580.50, timestamp, source}
For batch: POST /api/v1/mcp/rate/batch-convert
→ converts [USD→NGN, EUR→GHS, GBP→NGN] in one call
For analytics: GET /api/v1/mcp/rate/history
→ retrieves historical rates (high/low/average over days/weeks)
Rate service is a free query; use it alongside payment tools for complete
currency workflows. Create a "rate" scope key for access.
What this package does NOT have access to:
This MCP server is a thin authenticated client. All security enforcement executes server-side at BananaCrystal's infrastructure layer, not in this package.
API Scopes: Different API keys can have different scopes:
All MCP payment tools (40 tools) included with any API key. Rate service adds optional enhanced currency operations.
Read-only operations are always free. Fees only apply when moving money or accessing advanced rate features.
No monthly fee. No seat pricing. No lock-in.
Note: Rate service queries (historical data, statistics, batch conversions) are included in your API call tier. Create a "rate" scope key to use these operations; see Rate Service for details.
Agent payment infrastructure is the class of financial technology designed from first principles for AI agents as the primary economic actor. It provides agent wallets with programmatic identity (no human KYC), autonomous transaction authorization without per-transaction human approval, machine-speed settlement, and machine-readable audit trails.
Traditional payment infrastructure (Stripe, bank APIs, card networks) assumes a human is the accountable party behind every payment. Agent payment infrastructure assumes the payer may be an autonomous software process operating 24/7 at machine speed. These are architecturally different requirements, which is why BananaCrystal exists as a category, not just a product.
Seven architectural differences:
Spending controls are enforced at the infrastructure layer rather than in your application or agent's code, so the agent cannot override them.
You set:
A runaway agent hitting its limit receives a SpendingLimitExceeded error and stops. No funds move.
An agent wallet is a non-custodial financial account owned and operated by an AI agent instead of a human. Its identity derives from a programmatic agent ID rather than government documents or personal KYC verification. The wallet holds a real stablecoin balance, has an on-chain Hedera address, and can send and receive value autonomously within the spending limits you configure.
When you sign up at agents.bananacrystal.com/account and create an API key, an agent wallet is automatically provisioned. Your agents reference it via the API key, so they never need to know private keys or manage cryptographic identity directly.
Any framework that supports the Model Context Protocol (MCP). Confirmed integrations:
langchain-mcp-adapters packageOpenAI adopted MCP in March 2025, and Microsoft added it to Copilot Studio in May 2025. Gartner projects that 75% of API gateway vendors will support MCP by 2026. Since this is the standard, you should build on it.
150+ stablecoin currency pairs. The core flow:
Every swap settles on Hedera in under 5 seconds. No banks. No SWIFT. No weekends.
Fees: Token transfers cost 0.3% of the transfer amount. Currency swaps cost 0.5% of the swap amount. All other operations are free.
A sample of supported currencies:
Use list_available_tokens to get the live list with Hedera token IDs and current exchange rates.
Hedera is an enterprise-grade public distributed ledger chosen for three properties critical to autonomous agent payments:
Yes, it is MIT licensed. The server is a thin authenticated client that makes HTTP requests to BananaCrystal's API. You can fork it, modify it, and run it locally. A mock server is included for development without a real API key.
To run locally without an API key:
git clone https://github.com/BananaCrystal/mcp-server-bananacrystal.git
cd mcp-server-bananacrystal
npm install && npm run mock
The mock server returns realistic data so you can build integrations, write tests, and explore all 40 tools without touching production.
The agent economy is the emerging economic layer where AI agents participate as independent economic actors. They are not just tools that assist humans, but participants that earn, spend, negotiate, and operate on their own financial behalf.
It requires three new infrastructure primitives: agent wallets (programmatic identity, no human KYC), autonomous payments (programmatic spending policy, not per-transaction human approval), and machine-speed settlement (on-chain, under 5 seconds, machine-readable confirmation).
BananaCrystal is the agent payment infrastructure layer. We don't sell a product; we represent a category called AI-native finance, which is a financial system built for machines rather than adapted from one built for humans. The agent economy is forming now, and developers who integrate payment rails first will define how it works.
Do not open a public GitHub issue for security vulnerabilities. Email [email protected] with:
We will acknowledge within 24 hours and aim to resolve critical issues within 72 hours. We do not currently have a formal bug bounty program but we recognize responsible disclosures publicly and in our changelog.
Yes, and you should always start there.
Create a Sandbox key at agents.bananacrystal.com/account → API Keys → Create Sandbox Key. Sandbox keys start with bc_test_ so you can always tell them apart from live keys (which have no prefix). The package automatically routes each key to the correct endpoint.
What sandbox gives you:
reset_sandbox_balance toolAll 40 MCP tools work identically in sandbox. Additionally, rate service endpoints are available in sandbox at /mcp/sandbox/rate/* without requiring authentication, which is perfect for testing currency exchange operations.
When you're ready to go live, swap bc_test_your_key for a live key. It uses the same configuration and tools but with real money.
There is also a local mock server for contributors who want to develop without any API key at all:
git clone https://github.com/BananaCrystal/mcp-server-bananacrystal.git
cd mcp-server-bananacrystal
npm install && npm run mock
The mock server runs on http://localhost:3000 and returns realistic data for all tools.
The rate service is a separate backend HTTP API (not part of the 40 MCP tools). It provides comprehensive currency exchange operations:
Key difference: MCP tools are accessed through the MCP server interface (as described above). The rate service is accessed directly via HTTP REST endpoints.
How to use rate service:
rate scope at agents.bananacrystal.com/accountcurl -H "x-api-key: bc_live_your_key_with_rate_scope" \
"https://agentic.bananacrystal.com/api/v1/mcp/rate/current?from=USD&to=NGN"
Sandbox testing: Use /mcp/sandbox/rate/* endpoints (no authentication required).
When to use rate service vs MCP tools:
See Backend rate service section for full endpoint reference.
After installing the package globally (npm install -g @bananacrystal/mcp-server), the bananacrystal-mcp binary is available on your PATH.
Primary use: Running the MCP server
bananacrystal-mcp
# Starts the MCP server over stdio, ready for Claude Desktop or any MCP client
Check version:
bananacrystal-mcp --version
Debug mode: Verbose logging to stderr
DEBUG=true bananacrystal-mcp
Override the API endpoint (e.g. point to local mock):
BANANACRYSTAL_API_URL=http://localhost:3001 bananacrystal-mcp
Test with MCP Inspector (interactive tool explorer):
export BANANACRYSTAL_API_KEY=bc_test_your_key_here
npx @modelcontextprotocol/inspector node dist/index.js
The MCP Inspector opens a browser UI where you can call any of the 40 tools interactively. This is useful for exploring the API before wiring it into an agent.
# Clone
git clone https://github.com/BananaCrystal/mcp-server-bananacrystal.git
cd mcp-server-bananacrystal
# Install
npm install
# Start mock server: No API key needed
# All 40 MCP tools + rate service endpoints return realistic mock data
npm run mock
# Build from source
npm run build
# Run in development mode (requires real API key with appropriate scopes)
export BANANACRYSTAL_API_KEY=bc_test_your_sandbox_key
npm run dev
# Test rate service endpoints on mock server (no auth needed):
curl http://localhost:3001/api/v1/mcp/sandbox/rate/currencies
curl http://localhost:3001/api/v1/mcp/sandbox/rate/current?from=USD&to=NGN
# Test with MCP Inspector (for 40 MCP tools)
export BANANACRYSTAL_API_KEY=bc_test_your_key_here
npx @modelcontextprotocol/inspector node dist/index.js
Configure your agent to use the mock server (includes rate service):
{
"mcpServers": {
"bananacrystal": {
"command": "bananacrystal-mcp",
"env": {
"BANANACRYSTAL_API_KEY": "bc_mock_test",
"BANANACRYSTAL_API_URL": "http://localhost:3001"
}
}
}
}
bc_test_ for testing without real money. Live keys have no prefix.transfer scope for transfer_tokens, swap scope for swap_currency, rate scope for rate service)This is working as designed; limits are enforced at the infrastructure level and cannot be bypassed.
To increase limits: agents.bananacrystal.com/account → API Keys → Edit → adjust daily cap or per-transaction maximum.
If you are building a production agent, set limits conservatively first and increase after observing real usage patterns.
retry_after field in seconds, which you should respectRate service endpoints (/api/v1/mcp/rate/* and /api/v1/mcp/sandbox/rate/*) require keys with rate scope:
rate scope/mcp/sandbox/rate/*) require no authentication, so you can use them for free testingWe are building the financial infrastructure of the agent economy. This is early. Your contributions shape the category.
git clone https://github.com/BananaCrystal/mcp-server-bananacrystal.git
cd mcp-server-bananacrystal
npm install
npm run mock # develop against mock: No API key needed
npm run dev
The highest-impact contributions right now:
good first issue labelsgit checkout -b feature/your-contributionSee CONTRIBUTING.md for the full guide and GETTING_STARTED.md for a developer walkthrough.
All contributors are credited in the commit history. Significant contributions (new framework integrations, language SDKs, major examples) are highlighted in the project README.
If you build something interesting with this MCP server, open an issue tagged showcase and we will feature it.
If BananaCrystal has been useful:
Star the repo to help other developers find agent payment infrastructure when they need it. Visit github.com/BananaCrystal/mcp-server-bananacrystal to star.
Share it by posting in your AI agent community, Discord, or newsletter. The agent economy needs infrastructure, and developers building agents need to know this exists.
Open an issue if something doesn't work, if you need a framework that isn't supported, or if you have ideas. Every issue makes the project more useful for everyone.
MIT licensed · Built by BananaCrystal
Agent Payment Infrastructure · Autonomous Payments · AI-Native Finance
Give your AI agent a wallet: live FX rates, swaps and payments in 140+ local currencies.
Outils
Pas encore de liste d'outils. Les serveurs distants en obtiennent une après le premier contrôle d'état.
FAQ
Copiez sur cette page la configuration stdio pour Cursor, Claude Desktop, Claude Code ou VS Code. Elle utilise l'installation de l'éditeur, pas un proxy PlugMCP.
Aucune variable d'environnement requise n'est indiquée sur cette fiche.
MCP Server Bananacrystal s'exécute en local via stdio.
Dernière vérification : 2026-11-11. Give your AI agent a wallet: live FX rates, swaps and payments in 140+ local currencies.