← Back to blog

Crypto Payments for Marketplaces: One Account, Every Vendor's Wallet

· 5 min read
marketplace channels api guide

If you run a marketplace — or any platform where multiple sellers receive payments — crypto creates a specific headache: every vendor needs their own payout destination. Most payment processors force you to create a separate merchant account per vendor, manage separate API keys, and reconcile across all of them.

MutoPay takes a different approach. One merchant account, one API key, and a channel per vendor. Each channel routes payments to that vendor’s wallet, on their preferred chain, with their preferred token. You manage everything through a single API.

Not running a marketplace? For a single app or site accepting payments for yourself, you do not need a master key. Create one channel in the dashboard (Settings → Channels), copy its ep_… API key and webhook secret, and you’re done. See How to accept crypto payments for the minimal setup. The master key below is only needed when your backend provisions channels programmatically for third parties.

The model

A channel is an isolated payment lane under your account. It has its own:

  • API key (for creating payments attributed to that vendor)
  • Settlement destination (chain, token, wallet address)
  • Webhook URL (so each vendor’s backend can be notified independently)

A master API key lets you create and configure channels programmatically — no browser login required. Your backend provisions vendors automatically.

The result: when a buyer pays on Vendor A’s storefront, the funds go directly to Vendor A’s wallet. Vendor B’s payments go to Vendor B’s wallet. You never touch the funds.

Setup: three API calls per vendor

When a new vendor signs up on your platform and provides their wallet address, your backend makes three calls:

1. Create a channel

curl -X POST https://mutopay.com/api/merchant/channels \
  -H "Authorization: Bearer msk_<your_master_key>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Vendor: Acme Widgets",
    "webhook_url": "https://acme-widgets.com/webhooks/mutopay"
  }'

Response includes the channel ID and a channel API key (ep_...). Store both — the key is shown once.

2. Set the vendor’s settlement destination

curl -X PUT https://mutopay.com/api/merchant/channels/ch_abc123/settlement \
  -H "Authorization: Bearer msk_<your_master_key>" \
  -H "Content-Type: application/json" \
  -d '{
    "preferred_token": "USDC",
    "preferred_chain_id": "137",
    "wallet_address": "0xVendorWalletAddress..."
  }'

Now any payment created through this channel settles to that vendor’s wallet on Polygon in USDC.

3. Create payments using the channel’s API key

curl -X POST https://mutopay.com/api/payments \
  -H "X-API-Key: ep_<channel_api_key>" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 49.99,
    "currency": "USD",
    "external_id": "order_5821",
    "description": "Acme Widgets — Order #5821"
  }'

The payment is automatically attributed to the channel. The buyer sees the payment page, pays with whatever token they hold, and the funds arrive in the vendor’s wallet as USDC.

What this gives you

No per-vendor accounts. You don’t register each vendor as a separate merchant. One account, N channels.

No custody. Funds go directly to the vendor’s wallet. You never hold, escrow, or forward crypto. This sidesteps most regulatory complexity around money transmission.

Independent keys. If a vendor’s integration is compromised, you revoke that one channel key. Nothing else is affected.

Per-vendor webhooks. Each channel can have its own webhook URL. Vendor A’s backend gets notified about Vendor A’s payments. Or point all webhooks to your platform’s single endpoint and route by channel_id in the payload.

Mixed chains and tokens. Vendor A settles in USDC on Polygon. Vendor B wants USDT on Arbitrum. Vendor C prefers their TON wallet. Each channel is independent.

Automating vendor onboarding

A typical flow:

  1. Vendor signs up on your platform, enters their wallet address and preferred chain
  2. Your backend calls POST /api/merchant/channels to create a channel
  3. Your backend calls PUT /api/merchant/channels/:id/settlement with their wallet details
  4. You store the channel ID and API key in your database, associated with that vendor
  5. When creating orders for this vendor, use their channel API key in X-API-Key

To offboard a vendor:

curl -X POST https://mutopay.com/api/merchant/channels/ch_abc123/revoke \
  -H "Authorization: Bearer msk_<your_master_key>"

Their API key stops working immediately. Existing completed payments are unaffected.

What MutoPay doesn’t do

To set expectations: MutoPay routes payments to a destination wallet. It does not split a single payment across multiple wallets, hold funds in escrow, or enforce a commission structure. If your marketplace takes a cut, you handle that in your application logic — either by adjusting the amount before creating the payment, or by settling to your own wallet and distributing separately.

Who this is for

  • Multi-vendor marketplaces (handmade goods, digital products, services)
  • SaaS platforms that onboard sub-merchants (Shopify-style, white-label storefronts)
  • Agencies managing payments for multiple clients
  • WooCommerce multi-vendor setups (Dokan, WCFM) where each vendor has a separate wallet
  • Freelance platforms where each freelancer receives payouts directly

Getting started

  1. Sign in to your MutoPay dashboard
  2. Go to Settings and generate a master API key
  3. Use the API docs to start creating channels programmatically

The full channel management API — create, update settlement, rotate keys, revoke, test webhooks — is documented at mutopay.com/api/docs.