# Fiat → USDC Onramp MCP Server (`jan.turon/zkp2p-onramp-mcp`) Actor Turn cash in a bank app into USDC on Base via the ZKP2P peer-to-peer onramp — no exchange account, no KYC queue, no custodian holding funds in between. - **URL**: https://apify.com/jan.turon/zkp2p-onramp-mcp.md - **Developed by:** [Jan Turoň](https://apify.com/jan.turon) (community) - **Categories:** AI, Developer tools - **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing Pay per usage This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage ## What's an Apify Actor? Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README Fiat → USDC Onramp MCP Server is a hosted **MCP server** that lets any AI agent convert fiat money (EUR, USD, GBP) into **USDC on Base** using the [ZKP2P](https://zkp2p.xyz) peer-to-peer onramp — no exchange account, no KYC queue, and no custodian ever holding the funds. Think of it as a **fiat-to-crypto onramp API for AI agents**: your agent pays through everyday apps like **Wise, Venmo, or Revolut**, and USDC lands directly in its own wallet. It's also one of the **cheapest ways to buy USDC**: peer-to-peer liquidity means the all-in cost is typically **around 1%** (competitive LP spread plus a flat 0.35% service fee) — compared to roughly **4–6%** on card-based onramps like Coinbase Onramp or MoonPay, with none of their multi-day bank-transfer holds. ### What does Fiat → USDC Onramp MCP Server do? It connects any MCP-compatible client — Claude, Cursor, an [`awal`](https://github.com/coinbase/awal) smart-wallet agent, or your own agent framework — to the ZKP2P onramp network and walks it through a complete fiat → USDC conversion: 1. 💱 **Quote** — find the best live rate from real liquidity providers 2. 🔒 **Lock** — build the unsigned transaction that reserves the deal on-chain 3. 💸 **Pay** — your agent pays the counterparty in their payment app and captures encrypted payment evidence client-side 4. ✅ **Settle** — build the final unsigned transaction that releases USDC to the recipient wallet The server is a **stateless calldata factory**: it never holds a private key, never touches your fiat, and never custodies USDC. Every state-changing step returns unsigned calldata that your agent's own wallet signs and broadcasts. Want to try the same onramp yourself first, without an agent? The protocol also has a human-friendly web app — [app.peer.xyz](https://app.peer.xyz/referrals?referralCode=9OVMHQ) — where you can do a fiat → USDC conversion in the browser before wiring it into your agent. ### Why use this onramp for AI agents? - 🤖 **Built for agents, not humans clicking buttons.** Every step is one structured MCP tool call, so it drops straight into any agent's tool loop. - 🏦 **Works with money apps people already have.** Wise, Venmo, Revolut — no new exchange account, no verification queue. - 🔐 **Non-custodial by design.** The server only prepares transactions and relays proofs; your agent's wallet signs everything itself. - 💰 **Very cheap.** ZKP2P has no fixed protocol fee — liquidity providers compete on rate, with typical spreads of **0.5–1%**, a fraction of the 4–6% card-funded onramps charge, with no multi-day holds. - ⚡ **Serverless and always ready.** Runs on Apify Standby infrastructure — a stable HTTPS endpoint that scales with your traffic and bills only for what you use. - 📈 **Monetizable.** If you fork or self-host it, bake in your own ZKP2P referrer address and earn a cut of every onramp your deployment facilitates. ### What can you build with it? - **Agent wallet top-ups** — fund an AI agent's on-chain wallet from a bank account so it can pay for APIs, data, or other agents in USDC (x402, agentic commerce). - **Automated treasury management** — keep a fleet of on-chain bots topped up without a human in the loop. - **Fiat last-mile for agentic commerce** — any flow that ends with "convert fiat to stablecoins" without a person sitting in a browser tab. ### What MCP tools does this Actor provide? | Tool | What it does | |------|--------------| | `onramp_quote` | Get the best available fiat → USDC rate for a given amount and payment platform (read-only) | | `build_signal_intent` | Build the unsigned transaction that locks a quote in with a liquidity provider | | `decode_intent_hash` | Extract the intent confirmation ID from a mined transaction receipt | | `build_fulfill_intent` | Verify the fiat payment via ZKP2P's secure-enclave (TEE) attestation service and build the final unsigned transaction that releases USDC to the recipient | ### How to connect an AI agent to the MCP server The Actor runs in **Standby mode**, so it's a plain HTTPS endpoint. You authenticate with your Apify API token (find it in [Apify Console → Settings → API & Integrations](https://console.apify.com/settings/integrations)). **Endpoint:** `POST https://jan-turon--zkp2p-onramp-mcp.apify.actor/mcp` (MCP Streamable HTTP transport) **Auth:** `Authorization: Bearer ` #### Claude Code ```bash claude mcp add zkp2p-onramp \ --transport http https://jan-turon--zkp2p-onramp-mcp.apify.actor/mcp \ --header "Authorization: Bearer " ```` #### Claude Desktop, Cursor, or any MCP client ```json { "mcpServers": { "zkp2p-onramp": { "url": "https://jan-turon--zkp2p-onramp-mcp.apify.actor/mcp", "headers": { "Authorization": "Bearer " } } } } ``` #### Command line (mcpc) ```bash npm install -g @apify/mcpc mcpc connect https://jan-turon--zkp2p-onramp-mcp.apify.actor/mcp \ --header "Authorization: Bearer " --session zkp2p mcpc tools call onramp_quote --session zkp2p \ --arg paymentPlatforms='["wise"]' --arg fiatCurrency=EUR \ --arg amount=500000000 --arg recipient=0xYourWallet ``` #### Raw HTTP (curl) ```bash curl -X POST "https://jan-turon--zkp2p-onramp-mcp.apify.actor/mcp" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -H "Accept: application/json, text/event-stream" \ -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' ``` A plain `GET /` (no MCP handshake) returns a JSON health/discovery document listing the available tools. ### How does the onramp flow work end to end? 1. Call `onramp_quote` — the server queries ZKP2P liquidity providers and returns the best rate plus the deposit details needed for the next step. 2. Call `build_signal_intent` — the server returns unsigned `{chainId, to, data, value}` calldata; your agent's wallet signs and broadcasts it, locking the provider's USDC in escrow. The response also includes a **`payment` object** with the payee's handle, the exact fiat amount to send, and a **payment deep link** where the platform supports one (e.g. `revolut.me/`, `venmo.com/u/`). 3. Call `decode_intent_hash` with the mined receipt's logs to get the `intentHash`. 4. Your agent pays the counterparty using those payment instructions and captures **payment evidence client-side** (session material encrypted end-to-end to ZKP2P's attestation enclave — e.g. via the Peer extension tooling). 5. Call `build_fulfill_intent` — ZKP2P's TEE attestation service verifies the payment inside a secure hardware enclave, and the server returns the final unsigned calldata; once signed and mined, USDC is released from escrow to the recipient wallet. At no point does the server see a private key, hold fiat, or custody USDC. ### Example output `build_signal_intent` and `build_fulfill_intent` return ready-to-sign transaction requests — and `build_signal_intent` adds payment instructions your agent can act on directly: ```json { "chainId": 8453, "to": "0x888888359E981B5225CA48fbCdCeff702FC3b888", "data": "0xa3b2fc84…", "value": "0", "payment": { "platform": "revolut", "payee": "lp-revtag", "payUrl": "https://revolut.me/lp-revtag", "fiatAmount": "88.30", "fiatCurrency": "EUR", "instructions": "Send exactly 88.30 EUR to \"lp-revtag\" via revolut (payment page: https://revolut.me/lp-revtag). …" } } ``` `onramp_quote` returns the best liquidity-provider quote including the conversion rate, deposit ID, payment platform details, and payee information your agent needs for the payment step. ### Try it without an MCP client Standby mode is the primary interface, but you can also just press **Start** in Apify Console: a regular run performs a one-off, **read-only demo** — it fetches the best onramp quotes for the input you set (platforms, fiat currency, USDC amount) and stores them in the run's dataset, complete with the `payment` instructions object. No transaction is built or sent, so it's a safe way to check live rates and see the output shape before wiring up an agent. ### How much does it cost? You pay only for the Apify compute the Actor uses while serving your requests — it runs in **Standby mode**, so there's no idle server to rent and no subscription for the Actor itself. Tool calls are lightweight (quote lookups and calldata encoding), so a full onramp flow costs a fraction of a cent in platform usage. Apify's [free plan](https://apify.com/pricing) includes enough credit to run it. On the conversion itself, ZKP2P charges **no fixed protocol fee**. Liquidity providers set their own competitive rates — typical spreads are 0.5–1% — and a flat **0.35% service fee** is included in every quote, so what you see is what you pay. That puts the all-in cost at **roughly 1%**, usually far below card-based onramps (~4–6% all-in), and USDC settles as soon as the fulfill transaction confirms, with no multi-day holds. | | This MCP server (ZKP2P) | Card onramps (Coinbase, MoonPay) | |---|---|---| | Typical all-in fee | **~1%** (0.5–1% spread + 0.35% service fee) | ~4–6% | | Settlement | As soon as the fulfill tx confirms | Instant (card) or 7–10 day hold (ACH) | | Account / KYC | None | Exchange account + KYC | ### Is it safe? The security model - 🔑 **Never holds a private key, fiat balance, or USDC balance.** Every state-changing step returns unsigned calldata — your agent's own wallet decides whether to sign it. - 🧾 **Payment evidence is captured on the client and end-to-end encrypted** to ZKP2P's attestation enclave (TEE) — the server relays it but can never read it. - 🌐 **Stateless by design.** Each request spins up a fresh MCP server instance; nothing about your flow is kept in server memory between calls. - 🔍 **Open flow.** Contract addresses are resolved from the current ZKP2P deployment via the official `@zkp2p/sdk`, and every returned transaction shows its target — your agent can verify it before signing. ### FAQ #### Which payment apps and currencies are supported? The full ZKP2P platform set: **Wise, Venmo, Revolut, Cash App, Mercado Pago, Zelle, PayPal, Monzo, Chime, Luxon, and N26** — Wise, Venmo, and Revolut are the flagship platforms, covering EUR, USD, and GBP flows. Pass the platforms you want in `onramp_quote` and the server returns the best available match. #### Does my agent need a crypto exchange account or KYC? No. ZKP2P is peer-to-peer: your agent pays a liquidity provider directly through a regular payment app and proves the payment cryptographically. There's no exchange account, no KYC queue, and no withdrawal hold. #### What is ZKP2P? [ZKP2P](https://zkp2p.xyz) is a trust-minimized peer-to-peer onramp protocol. Liquidity providers escrow USDC on-chain; buyers pay them in fiat through everyday payment apps, and the payment is cryptographically attested inside a secure hardware enclave (TEE), which releases the escrowed USDC. You can try it manually in the [Peer web app](https://app.peer.xyz/referrals?referralCode=9OVMHQ) — the same flow this MCP server automates for agents. #### How is this different from Coinbase Onramp or `awal fund`? `awal fund` uses Coinbase Onramp: card purchases carry a ~3.99% card fee plus a 0.5–2% spread (roughly 4–6% all-in), and ACH purchases are held for 7–10 days before funds can leave Coinbase. Through this server you pay the ZKP2P LP spread (typically 0.5–1%) plus a flat 0.35% service fee — around 1% all-in — and USDC is released as soon as the fulfill step confirms on-chain. #### Can I run it against testnet first? The server targets Base mainnet contracts. Before moving real funds, do a small end-to-end run (e.g. a minimal EUR amount) and have your agent verify the decoded calldata targets the documented Orchestrator address. #### Something's not working — where do I report it? Open an issue on the **Issues tab** of this Actor in Apify Console. Include the tool name, the (redacted) input you sent, and the error returned. ### Disclaimer This Actor prepares transactions for a decentralized protocol; it does not provide financial services, hold customer funds, or execute trades on anyone's behalf. Cryptocurrency conversions carry market and counterparty risk — verify quotes and calldata before signing, comply with the payment platforms' terms of service, and make sure peer-to-peer crypto purchases are legal in your jurisdiction. # Actor input Schema ## `paymentPlatforms` (type: `array`): Payment platforms to quote. Only platforms supported by ZKP2P are allowed. ## `fiatCurrency` (type: `string`): ISO code of the fiat currency you would pay with, e.g. EUR, USD, GBP. ## `usdcAmount` (type: `string`): How much USDC to receive, in human units — e.g. "100" = 100 USDC. ## `recipient` (type: `string`): Base address that would receive the USDC. Only used to price the quote — nothing is sent, so any valid address works. Optional: leave empty and the server prices the quote against a default address. ## Actor input object example ```json { "paymentPlatforms": [ "revolut", "wise" ], "fiatCurrency": "EUR", "usdcAmount": "100" } ``` # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = {}; // Run the Actor and wait for it to finish const run = await client.actor("jan.turon/zkp2p-onramp-mcp").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = {} # Run the Actor and wait for it to finish run = client.actor("jan.turon/zkp2p-onramp-mcp").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{}' | apify call jan.turon/zkp2p-onramp-mcp --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=jan.turon/zkp2p-onramp-mcp", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Fiat → USDC Onramp MCP Server", "description": "Turn cash in a bank app into USDC on Base via the ZKP2P peer-to-peer onramp — no exchange account, no KYC queue, no custodian holding funds in between.", "version": "0.1", "x-build-id": "U4HcKshTXsKTHdd0n" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/jan.turon~zkp2p-onramp-mcp/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-jan.turon-zkp2p-onramp-mcp", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/jan.turon~zkp2p-onramp-mcp/runs": { "post": { "operationId": "runs-sync-jan.turon-zkp2p-onramp-mcp", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/jan.turon~zkp2p-onramp-mcp/run-sync": { "post": { "operationId": "run-sync-jan.turon-zkp2p-onramp-mcp", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": { "paymentPlatforms": { "title": "Payment platforms", "uniqueItems": true, "type": "array", "description": "Payment platforms to quote. Only platforms supported by ZKP2P are allowed.", "items": { "type": "string", "enum": [ "wise", "venmo", "revolut", "cashapp", "mercadopago", "zelle", "paypal", "monzo", "chime", "luxon", "n26" ], "enumTitles": [ "Wise", "Venmo", "Revolut", "Cash App", "Mercado Pago", "Zelle", "PayPal", "Monzo", "Chime", "Luxon", "N26" ] }, "default": [ "revolut", "wise" ] }, "fiatCurrency": { "title": "Fiat currency", "type": "string", "description": "ISO code of the fiat currency you would pay with, e.g. EUR, USD, GBP.", "default": "EUR" }, "usdcAmount": { "title": "USDC amount", "type": "string", "description": "How much USDC to receive, in human units — e.g. \"100\" = 100 USDC.", "default": "100" }, "recipient": { "title": "Recipient address (optional)", "pattern": "^0x[0-9a-fA-F]{40}$", "type": "string", "description": "Base address that would receive the USDC. Only used to price the quote — nothing is sent, so any valid address works. Optional: leave empty and the server prices the quote against a default address." } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```