Welcome to Crypt2Merchant. This platform lets you accept credit and debit card payments from your customers. Behind the scenes, payments are converted to a digital currency called USDC and deposited to your account. You don't need to know anything about crypto — we handle all of that for you.
Download the plugin using the button below, then in your WordPress admin go to Plugins → Add New → Upload Plugin and upload the ZIP.
Download WooCommerce PluginAfter activation, go to WooCommerce → Settings → Payments. You'll see Crypt2Merchant Onramp. Click to enable it.
You only need two settings:
c2m_ that was given to you when your account was createdCustomers will see "Pay with Credit/Debit Card" at checkout. When they click it, they'll be taken to a secure payment page to complete their purchase.
Payment links let you send a customer a direct link to pay — no WooCommerce needed. Great for invoices, custom orders, or one-off payments.
Click "Payment Links" in the sidebar on the left.
Click "Generate Link" and copy the URL. Send it to your customer via email, text, or however you prefer. They click the link, pay with their card, and you're done.
Here's what each status means in plain English:
A payment session was created but the customer hasn't completed their payment yet. They may still be on the payment page, or they may have left without paying.
The customer paid, but the amount received was less than expected. This can happen if they changed the amount on the payment page. The system is waiting for the remaining balance before completing the order.
Payment has been received and is being processed. Your WooCommerce order is being updated. This usually takes just a few seconds.
Payment is complete. The funds have been received and your WooCommerce order has been marked as paid. For payment links, this means the money has arrived.
Something went wrong with the payment. The customer may have cancelled, or there was a technical issue. No money was taken.
The payment session timed out before the customer completed their payment. They'll need to start a new order.
Click any payment row to expand it and see more information:
Here's what happens when a customer pays — you don't need to do anything, it's all automatic:
The whole process typically takes 30-60 seconds after the customer completes their card payment.
USDC is a "stablecoin" — a digital currency that's always worth exactly $1 USD. It's like a digital dollar. You don't need to worry about price changes or volatility. When we say you received 20 USDC, that means you received $20.
No. Customers pay with their regular credit or debit card — Visa, Mastercard, etc. The conversion to USDC happens behind the scenes. They don't need a crypto wallet or any crypto knowledge.
$20 USD. This is a requirement from the payment processor. Orders below $20 will show an error message at checkout.
The payment processor charges a small fee (usually 3-5%) to convert from card payment to USDC. So for a $20 order, you might receive $19.00-$19.40 in USDC. This is normal and similar to credit card processing fees.
This means they sent less than expected. The funds are held safely and won't be lost. To resolve it:
Note: the minimum payment through the card processor is $20, so if the remaining balance is less than $20, the top-up link will be set to $20 (the customer will be refunded any overpayment by the system).
Occasionally the notification to your store might fail. Check the payment in this dashboard — if it shows "Paid" here, the money was received. You can expand the payment details and click "Retry Callback" to resend the notification to your store, or manually update the order in WooCommerce.
Refunds are handled directly between you and your customer, the same way you would with any other payment method. Since funds are deposited to your wallet, you can send a refund to your customer using your preferred method (bank transfer, PayPal, etc.).
Yes. Your funds are secured by smart contracts on the Polygon blockchain. These are like automated, tamper-proof bank vaults — once set up, even we can't redirect your funds. Payment destinations are locked in and can't be changed.
Contact your CardinalDelphi representative or email support. Have your Session ID ready (found by expanding any payment row in the dashboard).
Accept card payments from any website, app, or platform. Two API calls, one callback — that's it.
https://api.crypt2merchant.netAll API requests require your merchant API key in the X-Api-Key header. Your key starts with c2m_ and was provided when your account was created.
X-Api-Key: c2m_your_api_key_here Content-Type: application/json
Start a payment by creating a session. This generates a unique deposit address for this transaction and returns the details you need to redirect the customer.
Request Body
| Parameter | Type | Description | |
|---|---|---|---|
| amount_fiat | number | required | Payment amount in USD. Minimum $20. |
| currency | string | optional | Currency code. Default: USD |
| order_id | string | optional | Your internal order reference. Returned in the callback. |
| callback_url | string | optional | URL we'll hit when payment is confirmed. Must return HTTP 200. |
curl -X POST https://api.crypt2merchant.net/api/session \
-H "X-Api-Key: c2m_your_key" \
-H "Content-Type: application/json" \
-d '{
"amount_fiat": 50.00,
"currency": "USD",
"order_id": "order-123",
"callback_url": "https://yoursite.com/payment-callback"
}'
{
"session_id": "7a004150-8509-47de-b6fe-5b62267210d7",
"deposit_address": "0xC690783E29bF60DE7AEfE74Dd9b455cA8980Ce14",
"splitter_address": "0xA03f79A3B0834558a21a8dD7F3F6aeFD9931Cc53",
"amount_fiat": "50.00",
"currency": "USD"
}
Response Fields
| Field | Description |
|---|---|
| session_id | Unique payment session identifier. Use this in the checkout redirect. |
| deposit_address | The unique address for this payment. This is where USDC will be sent. Use this as the address param in the checkout URL. |
| splitter_address | Your merchant's smart contract address. |
| amount_fiat | The confirmed payment amount. |
After creating a session, redirect the customer to our hosted checkout page. They'll complete payment via card — you don't need to build any payment UI.
Query Parameters
| Parameter | Type | Description | |
|---|---|---|---|
| session_id | string | required | From the create session response. |
| address | string | required | The deposit_address from the create session response. |
| amount | number | required | Payment amount. |
| currency | string | optional | Default: USD |
| string | optional | Pre-fills customer email on the payment page. | |
| order_ref | string | optional | Displayed to the customer as their order reference. |
https://api.crypt2merchant.net/checkout ?session_id=7a004150-8509-47de-b6fe-5b62267210d7 &address=0xC690783E29bF60DE7AEfE74Dd9b455cA8980Ce14 &amount=50.00 ¤cy=USD &email=customer@email.com &order_ref=order-123
When payment is confirmed, we send a GET request to the callback_url you provided when creating the session. Your server must return HTTP 200 to acknowledge receipt.
Query Parameters (sent by us)
| Parameter | Description |
|---|---|
| session_id | The payment session that was completed. |
| txid_out | The blockchain transaction hash. Verifiable on Polygonscan. |
| value_coin | USDC amount received (may be slightly less than amount_fiat due to processing fees). |
| order_id | Your order reference, as provided when creating the session. |
Complete working examples in popular languages. Each example shows the full flow: create session, redirect, handle callback.
const express = require('express');
const app = express();
const API_KEY = 'c2m_your_key';
const API_URL = 'https://api.crypt2merchant.net';
// 1. Customer clicks "Pay" → create session and redirect
app.post('/checkout', async (req, res) => {
const response = await fetch(`${API_URL}/api/session`, {
method: 'POST',
headers: {
'X-Api-Key': API_KEY,
'Content-Type': 'application/json',
},
body: JSON.stringify({
amount_fiat: req.body.total,
currency: 'USD',
order_id: req.body.orderId,
callback_url: 'https://yoursite.com/payment-done',
}),
});
const session = await response.json();
// 2. Redirect customer to hosted payment page
res.redirect(
`${API_URL}/checkout`
+ `?session_id=${session.session_id}`
+ `&address=${session.deposit_address}`
+ `&amount=${session.amount_fiat}`
+ `¤cy=USD`
);
});
// 3. We call this URL when payment is confirmed
app.get('/payment-done', (req, res) => {
const { session_id, txid_out, value_coin, order_id } = req.query;
// TODO: Mark order as paid in your database
console.log(`Order ${order_id} paid! USDC: ${value_coin}, TX: ${txid_out}`);
res.sendStatus(200); // Must return 200
});
import requests
from flask import Flask, request, redirect
app = Flask(__name__)
API_KEY = 'c2m_your_key'
API_URL = 'https://api.crypt2merchant.net'
# 1. Customer clicks "Pay" → create session and redirect
@app.route('/checkout', methods=['POST'])
def checkout():
session = requests.post(
f'{API_URL}/api/session',
headers={'X-Api-Key': API_KEY},
json={
'amount_fiat': float(request.form['total']),
'currency': 'USD',
'order_id': request.form['order_id'],
'callback_url': 'https://yoursite.com/paid',
},
).json()
# 2. Redirect customer to hosted payment page
return redirect(
f"{API_URL}/checkout"
f"?session_id={session['session_id']}"
f"&address={session['deposit_address']}"
f"&amount={session['amount_fiat']}"
f"¤cy=USD"
)
# 3. We call this URL when payment is confirmed
@app.route('/paid')
def paid():
order_id = request.args.get('order_id')
txid = request.args.get('txid_out')
amount = request.args.get('value_coin')
# TODO: Mark order as paid in your database
print(f'Order {order_id} paid! USDC: {amount}')
return 'OK', 200 # Must return 200
<?php
// 1. Create session when customer clicks "Pay"
$ch = curl_init('https://api.crypt2merchant.net/api/session');
curl_setopt_array($ch, [
CURLOPT_POST => true,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => [
'X-Api-Key: c2m_your_key',
'Content-Type: application/json',
],
CURLOPT_POSTFIELDS => json_encode([
'amount_fiat' => 50.00,
'currency' => 'USD',
'order_id' => $_POST['order_id'],
'callback_url' => 'https://yoursite.com/callback.php',
]),
]);
$session = json_decode(curl_exec($ch), true);
curl_close($ch);
// 2. Redirect customer to hosted payment page
header('Location: https://api.crypt2merchant.net/checkout'
. '?session_id=' . $session['session_id']
. '&address=' . $session['deposit_address']
. '&amount=' . $session['amount_fiat']
. '¤cy=USD');
exit;
// --- callback.php ---
// 3. We call this URL when payment is confirmed
$session_id = $_GET['session_id'];
$txid = $_GET['txid_out'];
$amount = $_GET['value_coin'];
$order_id = $_GET['order_id'];
// TODO: Mark order as paid in your database
http_response_code(200); // Must return 200
# 1. Create a payment session
curl -X POST https://api.crypt2merchant.net/api/session \
-H "X-Api-Key: c2m_your_key" \
-H "Content-Type: application/json" \
-d '{
"amount_fiat": 50.00,
"currency": "USD",
"order_id": "order-123",
"callback_url": "https://yoursite.com/callback"
}'
# Response:
# {
# "session_id": "7a004150-...",
# "deposit_address": "0xC690783E...",
# "amount_fiat": "50.00"
# }
# 2. Redirect customer to:
# https://api.crypt2merchant.net/checkout
# ?session_id=7a004150-...
# &address=0xC690783E...
# &amount=50.00¤cy=USD
# 3. When paid, we GET your callback_url with:
# ?session_id=...&txid_out=...&value_coin=50.00&order_id=order-123
# Your server must return HTTP 200.
All error responses include an error field with a human-readable message.
| Status | Meaning |
|---|---|
| 400 | Bad request — missing or invalid parameters. |
| 401 | Unauthorized — invalid or missing API key. |
| 500 | Server error — try again or contact support. |
| 502 | Payment provider error — the card payment processor is unavailable. Try again. |
{
"error": "Positive amount_fiat required"
}