Dopayer API Documentation

Overview

Dopayer lets customers pay with a licensed payment provider while you receive the funds instantly as USDC (Polygon) in your own wallet. Pick the integration that fits you:

How a payment works

1. Create a temporary walletYour system asks Dopayer for a unique, encrypted receiving wallet for this order and gives a callback URL.
2. Send the customer to payRedirect the customer to the payment page with the wallet, amount, email and currency.
3. The customer paysPayment is completed on the page of a licensed payment provider.
4. You get paidThe payout arrives in your wallet and Dopayer calls your callback URL with the payment details.

Base URLs

All API endpoints use GET and return JSON. Any failed request returns HTTP 400.

Payment links (no code)

The quickest way to get paid. Open the payment link generator, enter your wallet, a description and an amount, and share the link it gives you. Optionally add your own logo so customers see your brand on the checkout page.

A link looks like this:

https://dopayer.com/pay.html?wallet=0xYOUR_WALLET&amount=29.99&currency=USD&desc=Monthly%20plan&logo=https%3A%2F%2Fexample.com%2Flogo.png

Fees & payouts

Payouts are sent automatically and instantly by the temporary wallet created for each order. Percentages apply to the amount forwarded to you after the payment provider has taken its own fee.

For example, if the amount forwarded after provider fees is 100 USDC, the merchant wallet receives 98 USDC.

Payouts may arrive as USDC or USDT on Polygon (or other supported payout coins), so use a self-custodial wallet that can receive them.

1. Create wallet

Creates a unique, encrypted receiving wallet for one order. Call this once per customer order.

Parameters

Response

curl "https://api.dopayer.com/control/wallet.php?address=0xYOUR_WALLET&callback=https%3A%2F%2Fyourstore.com%2Fcallback%3Forder%3DINV-1001"

{
  "address_in": "eE5A43DAkczRwxoW3IL7sGsRh6CiMx4kkTCccr6n%2FYMTGhy9b1eeIJLTr9Lho64fJTIeOfgsnJNNc%2FarqtR1jw%3D%3D",
  "polygon_address_in": "0x756C4D5EAad2165b3841a543Cf851Eed6AAF211B",
  "callback_url": "https://yourstore.com/callback?order=INV-1001",
  "ipn_token": "ZEE2cW8zb1N0N2otZEc3eHh3MDNUU1lTMEExYmVv..."
}

2a. Process payment (single provider)

Redirects the customer straight to one payment provider that you choose.

https://payment.dopayer.com/process-payment.php?address={address_in}&amount=49.99&provider=moonpay&email=john%40example.com&currency=USD

2b. Hosted page (multi-provider)

Sends the customer to a hosted page that lists the payment options available for their location, amount and currency, so you do not have to pick a provider yourself.

Required parameters

Optional branding

https://payment.dopayer.com/pay.php?address={address_in}&amount=49.99&email=john%40example.com&currency=USD&logo=https%3A%2F%2Fexample.com%2Flogo.png&background=0F172A&theme=6366F1&button=6366F1

Full example

Create the wallet, then redirect the customer. Run this on your server so your wallet address and order logic stay under your control.

// Node.js 18+ (server side)
const MERCHANT_WALLET = '0xYOUR_WALLET';

async function createPayment(orderId, amount, customerEmail) {
  // 1) Create a unique wallet for this order.
  //    The callback must contain a value that is unique per order.
  const callback = 'https://yourstore.com/callback?order=' + orderId;

  const walletRes = await fetch(
    'https://api.dopayer.com/control/wallet.php' +
    '?address=' + MERCHANT_WALLET +
    '&callback=' + encodeURIComponent(callback)
  );
  if (!walletRes.ok) throw new Error('Could not create the wallet');
  const { address_in, ipn_token } = await walletRes.json();
  // Save ipn_token with your order (useful for the status endpoint).

  // 2) Build the payment URL.
  //    address_in is ALREADY URL-encoded: do not encode it again.
  const payUrl = 'https://payment.dopayer.com/pay.php' +
    '?address=' + address_in +
    '&amount=' + amount +
    '&email=' + encodeURIComponent(customerEmail) +
    '&currency=USD';

  return payUrl; // redirect the customer's browser to this URL
}

<?php
// PHP (server side)
$merchantWallet = '0xYOUR_WALLET';
$orderId  = 'INV-1001';
$amount   = '49.99';
$email    = '[email protected]';

// 1) Create a unique wallet for this order.
$callback = 'https://yourstore.com/callback.php?order=' . $orderId;
$response = file_get_contents(
    'https://api.dopayer.com/control/wallet.php' .
    '?address=' . $merchantWallet .
    '&callback=' . urlencode($callback)
);
$wallet = json_decode($response, true);
if (empty($wallet['address_in'])) { die('Could not create the wallet'); }
// Save $wallet['ipn_token'] with your order.

// 2) Redirect the customer.
//    address_in is ALREADY URL-encoded: do not encode it again.
$payUrl = 'https://payment.dopayer.com/pay.php' .
    '?address=' . $wallet['address_in'] .
    '&amount=' . $amount .
    '&email=' . urlencode($email) .
    '&currency=USD';

header('Location: ' . $payUrl);
exit;

List providers

Returns every payment provider, its current status and its minimum order amount. Use it to decide which provider values are safe to offer.

{
  "providers": [
    {
      "id": "moonpay",
      "provider_name": "MoonPay",
      "status": "active",
      "minimum_currency": "USD",
      "minimum_amount": 20
    },
    {
      "id": "interac",
      "provider_name": "Interac",
      "status": "active",
      "minimum_currency": "CAD",
      "minimum_amount": 100
    }
  ]
}

Currency limits

Callback event

When the customer has paid, Dopayer sends a GET request to your callback URL. All of your original query parameters are included, plus the payment details below.

https://yourstore.com/callback?order=INV-1001&value_coin=105.6&coin=polygon_usdc&txid_in=0xa22a82...&txid_out=0x94c2c3...&address_in=0x32e854...&value_forwarded_coin=104.016&address_out=%7B%220x34653D...%22%3A%220.0500%22%2C%220x042beb...%22%3A%220.9250%22%7D

Use your own order reference to find the order. To work out what one wallet received, multiply value_forwarded_coin by that wallet's share in address_out.

<?php
// callback.php
$order = $_GET['order'] ?? '';
$txid  = $_GET['txid_in'] ?? '';
$paid  = $_GET['value_coin'] ?? '';

// 1. Find the order by $order.
// 2. Callbacks can arrive more than once: if $txid was already
//    processed, stop here (be idempotent).
// 3. Check that $paid matches what you expected.
// 4. Mark the order as paid.

// Optional: how much each wallet received
$shares    = json_decode($_GET['address_out'] ?? '{}', true);
$forwarded = $_GET['value_forwarded_coin'] ?? '0';
foreach ($shares as $address => $share) {
    $received = bcmul($forwarded, $share, 18);
}

// Node.js (Express)
app.get('/callback', (req, res) => {
  const { order, txid_in, value_coin } = req.query;

  // 1. Find the order by `order`.
  // 2. Callbacks can arrive more than once: if txid_in was already
  //    processed, stop here (be idempotent).
  // 3. Check that value_coin matches what you expected.
  // 4. Mark the order as paid.

  // Optional: how much each wallet received
  const shares = JSON.parse(req.query.address_out || '{}');
  for (const [address, share] of Object.entries(shares)) {
    const received = Number(req.query.value_forwarded_coin) * Number(share);
  }

  res.sendStatus(200);
});

Check payment status

Looks up a payment using the ipn_token you received in step 1.

curl "https://api.dopayer.com/control/payment-status.php?ipn_token=ZEE2cW8zb1N0N2otZEc3eHh3MDNUU1lTMEExYmVv..."

{
  "status": "paid",
  "value_coin": "117.59",
  "txid_out": "0xe85ed56174785b0bb9fcb522655f961675ad236f2aad2f5bb4fa2f074ac09726",
  "coin": "polygon_usdc"
}

status is either paid or unpaid.

Convert to USD

Some providers accept only USD. This endpoint converts an amount from another currency.

curl "https://api.dopayer.com/control/convert.php?from=EUR&value=1258.31"

{
  "status": "success",
  "value_coin": "1351.76",
  "exchange_rate": "1.07427"
}

Crypto payments

Customers can also pay in stablecoins (USDC or USDT). The coins they send are forwarded straight to your wallet in the same coin and network, with no holding period. This works with any EVM wallet, so you can use the same wallet address you already use for card payments.

Option 1: Payment links (no code)

Create a link in the payment link generator. The customer picks the coin and network, sends the payment from their wallet, and the coins arrive in your wallet.

Option 2: API

Each coin has its own set of endpoints. The {ticker} is the network and the coin, for example polygon/usdc, base/usdc, bep20/usdt, arbitrum/usdc, optimism/usdt, avax-c/usdc or erc20/usdc.

1. Create a receiving address

{
  "address_in": "0xCc99282221bd39dD985978B12407dd12FDB66162",
  "callback_url": "https://yoursite.com/paid?order=8271",
  "ipn_token": "ZEE2cW8z...%3D"
}

Unlike the card payment API, address_in here is a normal, readable address.

2. Show how much to pay

{
  "status": "success",
  "value_coin": "250.0134",
  "exchange_rate": "1.0000536"
}

If status is not success, the currency can't be converted for that coin.

3. QR code (optional)

Returns qr_code, a base64 PNG you can show with <img src="data:image/png;base64,{qr_code}">.

4. Minimum amounts

Lists every supported network and coin with its minimum amount (minimum). For a single coin use /crypto/{ticker}/aff-info.php.

Callback event

When the payment is confirmed, we send a GET request to your callback URL with your original parameters plus:

Good to know

• The merchant receives 98% of the final payout, the same split as card payments.
• If a customer sends the wrong token or uses the wrong network, the coins are still forwarded to your wallet automatically on EVM networks. They just won't match the order automatically, so you may need to check manually.
• Minimums are slightly higher than sending directly to a wallet, because each payout is split between more than one wallet.
• The merchant wallet must be a wallet that works on the selected network. The same 0x address works on all the EVM networks listed above.

Partners (sub-affiliates)

If you bring merchants to Dopayer, you can earn a share of every sale they make. Create the wallet with the partner endpoint instead of the standard one, and set your share with sub_affiliate_fee. Everything else (payment page, callback, status) works exactly as described above.

https://api.dopayer.com/set-affiliate.php?address=0xMERCHANT_WALLET&callback=https%3A%2F%2Fpartner-site.com%2Forder%3Fnumber%3D5001&merchant_fee=0.97&sub_affiliate_fee=0.01&sub_affiliate=0xPARTNER_WALLET

{
  "address_in": "wBWnsV63iw08CXjZ%2BYQwKYMRz5K4mpBRZwHuGe5PUKmpVyBLgI5PXJqvs4X11%2F6zRrqtAnyI3kYvE1J0SSUaYA%3D%3D",
  "polygon_address_in": "0x1a65e22d1A8e3001574446D6d92632D5E075073a",
  "callback_url": "https://partner-site.com/order?number=5001",
  "ipn_token": "ZEE2cW8zb1N0N2otZEc3eHh3MDNUU1lTMEExYmVv..."
}

Example split of a 100 USDC payout

Fees are set per order, so a partner can offer different rates to different merchants, as long as the two shares always total 0.98.

Notes & limits

• Create a new wallet for every order, and always include a unique value in the callback.
• Pass address_in to the payment page exactly as returned. It is already URL-encoded (this does not apply to crypto addresses, which are plain).
• The customer must be redirected to the payment page. It cannot be shown inside an iframe.
• Use a self-custodial wallet to receive payouts. Exchange deposit addresses are not recommended and can cause payout problems.
• The merchant wallet and any partner wallet must be different addresses.
• Each provider has its own minimum order amount and some accept only certain currencies. Check List providers for cards, or Crypto payments for stablecoin minimums.
• Any failed request returns HTTP 400.
• Your callback URL must be reachable from the internet so Dopayer can notify you.