DantePay API Reference
Accept any cryptocurrency, settle pure USDC. Full API reference and integration guide for enterprise and developer teams.
https://www.dante-pay.com·Protocol fee: 1%·Supported chains: Solana · Base · Ethereum · BitcoinIntroduction
DantePay is a cryptocurrency payment middleware engine. Merchants accept any supported token — SOL, BTC, ETH, USDC, or any Solana-listed token — and receive pure USDC to their configured settlement wallet. DantePay acts as a programmatic pass-through: the platform routes and settles payments deterministically, with a 1% protocol fee extracted on every transaction.
DantePay is built for:
- →Enterprise platforms & aggregators
Multi-wallet treasury routing, configurable per-merchant transaction caps, programmatic integration via API.
- →Shopify merchants
One script tag. A Pay with Crypto button appears at checkout automatically.
- →Custom storefronts
Create a payment intent from your server, redirect to the checkout URL. Two API calls.
How it works — 3 steps
Quick Start
Get your first test transaction running in under 10 minutes.
# 1. Create a payment intent
curl -X POST https://www.dante-pay.com/api/payment-intents \
-H 'Authorization: Bearer sk_live_your_key_here' \
-H 'Content-Type: application/json' \
-d '{
"amountUsd": 99.99,
"description": "Order #1042",
"successUrl": "https://your-store.com/success",
"metadata": { "orderId": "1042" }
}'
# 2. Response — redirect customer to checkoutUrl
# {
# "id": "cm3abc123def",
# "status": "REQUIRES_PAYMENT",
# "checkoutUrl": "https://www.dante-pay.com/checkout/cm3abc123def",
# "expiresAt": "2026-06-02T15:15:00Z"
# }Authentication
All API requests must include an Authorization header with your API key as a Bearer token. API keys are generated from the dashboard and never expire unless manually revoked.
Authorization: Bearer sk_live_your_api_key_here
| Key prefix | Environment | Description |
|---|---|---|
| sk_live_* | Production | Real blockchain transactions. Real funds move. |
| sk_test_* | Sandbox | Checkout shows a "Simulate Payment" button. Webhooks fire with test data. No real funds. |
/api/payment-intents must originate from your server.Webhook Signature Verification — HMAC-SHA256
Every webhook DantePay sends includes an X-Dante-Signature header. This is an HMAC-SHA256 of the raw request body, signed with your webhook signing secret. Find your signing secret in the dashboard under Developers → Webhook Settings.
const crypto = require('crypto');
function verifyDanteWebhook(rawBody, signature, signingSecret) {
const expected = crypto
.createHmac('sha256', signingSecret)
.update(rawBody, 'utf8')
.digest('hex');
return crypto.timingSafeEqual(
Buffer.from(expected),
Buffer.from(signature)
);
}
// Express.js usage
app.post('/webhooks/dante', express.raw({ type: 'application/json' }), (req, res) => {
const sig = req.headers['x-dante-signature'];
if (!verifyDanteWebhook(req.body, sig, process.env.DANTE_WEBHOOK_SECRET)) {
return res.status(401).send('Invalid signature');
}
// Process event
res.status(200).send('OK');
});import hmac, hashlib
def verify_dante_webhook(raw_body: bytes, signature: str, signing_secret: str) -> bool:
expected = hmac.new(
signing_secret.encode('utf-8'),
raw_body,
hashlib.sha256
).hexdigest()
return hmac.compare_digest(expected, signature)Core Concepts
Programmatic Pass-Through Architecture
DantePay routes payments through a platform wallet that settles deterministically to the merchant's configured wallet address. The routing is non-discretionary and programmatic — funds are never manually redirected or held. The 1% protocol fee is retained by DantePay; 99% settles to the merchant.
Chain-specific settlement behavior
Payment Intent Lifecycle
| Status | Description |
|---|---|
| REQUIRES_PAYMENT | Intent created. Awaiting customer payment. Expires after 15 minutes. |
| PAID | Payment confirmed on-chain. Webhook fired. |
| EXPIRED | Customer did not complete payment before the 15-minute expiry. |
| FAILED | On-chain verification failed. No funds moved. |
Payment Intents
A Payment Intent represents a single payment session. Create one when a customer initiates checkout. It holds the payment amount, expiry, and your metadata. The customer completes payment against the intent via the checkout URL.
/api/payment-intentsCreate a new payment intent. Returns a checkout URL.
| Parameter | Type | Required | Description |
|---|---|---|---|
| amountUsd | float | required | Payment amount in USD. Minimum $0.01. Maximum set by your merchant configuration (default $50,000). |
| description | string | optional | Order or product description. Displayed to customer at checkout. Max 255 characters. |
| customerEmail | string | optional | Customer email address. Used for receipt emails. |
| customerName | string | optional | Customer display name. Max 120 characters. |
| successUrl | string | optional | URL to redirect the customer after successful payment. |
| cancelUrl | string | optional | Reserved for future use. |
| metadata | object | optional | Arbitrary key-value pairs. Passed through in all webhooks. Use for order IDs, client references, etc. |
curl -X POST https://www.dante-pay.com/api/payment-intents \
-H 'Authorization: Bearer sk_live_xxxx' \
-H 'Content-Type: application/json' \
-d '{
"amountUsd": 499.99,
"description": "Order #1042 — Premium Plan",
"customerEmail": "customer@example.com",
"successUrl": "https://your-store.com/checkout/success",
"metadata": {
"orderId": "ORD-1042",
"customerId": "cust_abc123",
"region": "us-east"
}
}'{
"id": "cm3abc123def456ghi",
"amountUsd": "499.99",
"currency": "USD",
"status": "REQUIRES_PAYMENT",
"checkoutUrl": "https://www.dante-pay.com/checkout/cm3abc123def456ghi",
"expiresAt": "2026-06-02T15:15:00.000Z",
"metadata": {
"orderId": "ORD-1042",
"customerId": "cust_abc123",
"region": "us-east"
}
}/api/payment-intentsList payment intents for your merchant account.
curl https://www.dante-pay.com/api/payment-intents?limit=20&offset=0 \ -H 'Authorization: Bearer sk_live_xxxx'
Webhooks
Configure your webhook endpoint in the dashboard under Developers → Webhook Settings. DantePay POSTs to your endpoint for every significant payment event. Respond with HTTP 200 to acknowledge receipt.
Failed deliveries are retried up to 3 times with exponential backoff: 5s → 30s → 2min. After 3 failed attempts the event is marked failed — check the dashboard Webhook Logs to debug.
| Event | Description |
|---|---|
| payment_intent.paid | Payment confirmed on-chain. USDC routing to merchant wallet initiated. |
| payment_intent.expired | Customer did not complete payment within the 15-minute window. |
| payment_intent.failed | On-chain verification failed. No funds moved. |
| test | Test event fired from the dashboard. Use to verify your webhook endpoint. |
Webhook headers
| X-Dante-Signature | HMAC-SHA256 of the raw JSON body. Verify before processing. |
| X-Dante-Event | Event type string, e.g. payment_intent.paid |
| Content-Type | application/json |
{
"event": "payment_intent.paid",
"paymentIntentId": "cm3abc123def456ghi",
"merchantId": "cm3merchant_id",
"amountUsd": "499.99",
"currency": "USD",
"status": "PAID",
"chain": "SOLANA",
"asset": "USDC",
"txHash": "5KtFjMn...blockchain_tx_hash",
"paidAt": "2026-06-02T15:04:21.000Z",
"metadata": {
"orderId": "ORD-1042",
"customerId": "cust_abc123"
}
}const crypto = require('crypto');
app.post('/webhooks/dante',
express.raw({ type: 'application/json' }),
(req, res) => {
// 1. Verify signature
const sig = req.headers['x-dante-signature'];
const expected = crypto
.createHmac('sha256', process.env.DANTE_WEBHOOK_SECRET)
.update(req.body)
.digest('hex');
if (!crypto.timingSafeEqual(Buffer.from(sig), Buffer.from(expected))) {
return res.status(401).send('Invalid signature');
}
// 2. Parse and handle
const payload = JSON.parse(req.body);
if (payload.event === 'payment_intent.paid') {
const { orderId } = payload.metadata;
// Mark order paid in your DB
db.orders.update(orderId, { status: 'paid', txHash: payload.txHash });
}
// 3. Acknowledge within 5 seconds
res.status(200).send('OK');
}
);X-Dante-Signature header before processing any webhook payload. Never fulfill an order without verification.Supported Assets
DantePay supports payments across four blockchains. The merchant always receives USDC regardless of the customer's payment token.
| Chain | Customer pays with | Merchant receives | Settlement wallet field |
|---|---|---|---|
| Solana | SOL, USDC, BONK, WIF, or any Jupiter-listed token | USDC (SPL) | usdcSettlementWallet |
| Base | USDC | USDC (ERC-20) | baseSettlementWallet |
| Ethereum | USDC | USDC (ERC-20) | ethSettlementWallet |
| Bitcoin | BTC | BTC (merchant share) | btcSettlementWallet |
Enterprise Configuration
EnterpriseDantePay's safety controls are configurable per merchant. All limits are enforced server-side and cannot be bypassed by the client or the customer. Enterprise accounts can request configuration changes via your account manager.
maxTransactionUsdDefault: $50,000Hard cap on individual transaction size. Any payment intent above this limit is rejected at creation. Enterprise clients with higher volume requirements can request an increased limit. The cap applies to the USD face value of the payment.
maxPriceImpactBpsDefault: 500 bps (5%)Server-side price impact hard block for Solana swap transactions. Before executing a Jupiter swap, DantePay fetches a fresh on-chain quote and calculates price impact in basis points. If the impact exceeds this threshold, the transaction is rejected. Note: this is price impact — not slippage. Slippage tolerance is set separately at 300 bps (3%) in the swap parameters.
settlementWalletsDefault: Per-chainEach merchant configures a settlement wallet address per chain. USDC (or BTC) settles to the configured address. Enterprise clients can configure multiple wallets for multi-chain treasury routing.
// Configure via dashboard or contact your account manager
{
"maxTransactionUsd": 500000,
"maxPriceImpactBps": 300,
"settlementWallets": {
"solana": "YOUR_SOLANA_WALLET_ADDRESS",
"base": "0xYOUR_BASE_WALLET_ADDRESS",
"ethereum": "0xYOUR_ETH_WALLET_ADDRESS",
"bitcoin": "YOUR_BITCOIN_WALLET_ADDRESS"
},
"webhookEndpointUrl": "https://api.your-platform.com/webhooks/dantepay"
}Sandbox Environment
Use sk_test_ API keys to test the full integration without blockchain transactions. The checkout page renders a Simulate Payment button instead of wallet connection. Webhooks fire with simulated transaction data identical to production payloads.
Quick start — 5 steps
# Same API — just use your sk_test_ key
curl -X POST https://www.dante-pay.com/api/payment-intents \
-H 'Authorization: Bearer sk_test_your_test_key_here' \
-H 'Content-Type: application/json' \
-d '{
"amountUsd": 10.00,
"description": "Test Order",
"successUrl": "https://your-server.com/success"
}'
# Response includes testMode: true
# {
# "id": "cm3test...",
# "checkoutUrl": "https://www.dante-pay.com/checkout/cm3test...",
# "testMode": true,
# ...
# }Error Reference
All DantePay API errors return a consistent JSON object. HTTP status follows REST conventions: 400 for client errors, 401 for auth failures, 422 for validation errors, 500 for server errors.
{
"error": "Human-readable error message describing what went wrong."
}| HTTP | Cause | Resolution |
|---|---|---|
| 401 | Invalid or missing API key | Check your Authorization header. Key must be active and not revoked. |
| 400 | Amount below minimum or above cap | amountUsd must be ≥ 0.01 and ≤ your merchant maxTransactionUsd. |
| 400 | Payment intent expired | Intents expire after 15 minutes. Create a new payment intent. |
| 400 | Not payable — wrong status | Intent has already been paid, expired, or failed. Do not retry. |
| 400 | Price impact exceeded | Swap would exceed maxPriceImpactBps. Customer should choose a more liquid token or pay with USDC directly. |
| 400 | Merchant wallet not configured | The merchant has not set a settlement wallet for this chain. Configure in dashboard before accepting payments on that chain. |
| 500 | Platform wallet not configured | Contact support — platform environment variable not set. |
| 502 | Jupiter quote/swap failed | Upstream DEX error. Retry. If persistent, token may have no liquidity. |