v1.0Live on Mainnet

DantePay API Reference

Accept any cryptocurrency, settle pure USDC. Full API reference and integration guide for enterprise and developer teams.

Base URL: https://www.dante-pay.com·Protocol fee: 1%·Supported chains: Solana · Base · Ethereum · Bitcoin

Introduction

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

1
Customer initiates payment
Customer connects their wallet (Phantom, MetaMask, etc.) and selects a token. DantePay displays the exact token amount based on real-time pricing.
2
DantePay routes and settles
On Solana, a single atomic transaction executes the Jupiter swap and routes USDC output programmatically. On Base/ETH/BTC, the payment routes through the platform wallet and settles to the merchant deterministically. 1% fee extracted on every transaction.
3
Webhook confirmation
DantePay fires a signed webhook to your server with the transaction hash, settled amount, and your metadata. Mark the order paid.

Quick Start

Get your first test transaction running in under 10 minutes.

1
Create an account
Sign up at dante-pay.com. Generate an API key from the dashboard (Settings → API Keys). Copy the sk_live_ key — it's shown once.
2
Create a payment intent
POST to /api/payment-intents with your API key. Get back a checkoutUrl.
3
Redirect the customer
Send the customer to the checkoutUrl. They connect their wallet and pay.
4
Handle the webhook
DantePay POSTs to your webhook URL when payment confirms. Verify the X-Dante-Signature and mark the order paid.
Minimal integration (curl)
# 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.

Request header
Authorization: Bearer sk_live_your_api_key_here
Key prefixEnvironmentDescription
sk_live_*ProductionReal blockchain transactions. Real funds move.
sk_test_*SandboxCheckout shows a "Simulate Payment" button. Webhooks fire with test data. No real funds.
WarningNever expose your API key in client-side code. All requests to /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.

Node.js — verify webhook signature
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');
});
Python — verify webhook signature
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

Solana (memecoin → USDC)
Single atomic transaction. User's wallet signs one transaction. Jupiter executes the swap across DEX liquidity pools. USDC output routes programmatically to the platform wallet in the same transaction. Settlement to merchant follows.
Base / Ethereum (USDC)
Two-step flow. Customer sends USDC to the platform wallet. Platform deterministically forwards 99% to the merchant settlement wallet.
Bitcoin
BlockCypher address forwarding splits the incoming BTC between the merchant and the platform fee address at the forwarding layer.

Payment Intent Lifecycle

StatusDescription
REQUIRES_PAYMENTIntent created. Awaiting customer payment. Expires after 15 minutes.
PAIDPayment confirmed on-chain. Webhook fired.
EXPIREDCustomer did not complete payment before the 15-minute expiry.
FAILEDOn-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.

POST
/api/payment-intents

Create a new payment intent. Returns a checkout URL.

ParameterTypeRequiredDescription
amountUsdfloatrequiredPayment amount in USD. Minimum $0.01. Maximum set by your merchant configuration (default $50,000).
descriptionstringoptionalOrder or product description. Displayed to customer at checkout. Max 255 characters.
customerEmailstringoptionalCustomer email address. Used for receipt emails.
customerNamestringoptionalCustomer display name. Max 120 characters.
successUrlstringoptionalURL to redirect the customer after successful payment.
cancelUrlstringoptionalReserved for future use.
metadataobjectoptionalArbitrary key-value pairs. Passed through in all webhooks. Use for order IDs, client references, etc.
Request
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"
    }
  }'
Response
{
  "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"
  }
}
NotePayment intents expire after 15 minutes. Create a new intent if the customer lets it expire.
GET
/api/payment-intents

List payment intents for your merchant account.

Request
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.

EventDescription
payment_intent.paidPayment confirmed on-chain. USDC routing to merchant wallet initiated.
payment_intent.expiredCustomer did not complete payment within the 15-minute window.
payment_intent.failedOn-chain verification failed. No funds moved.
testTest event fired from the dashboard. Use to verify your webhook endpoint.

Webhook headers

X-Dante-SignatureHMAC-SHA256 of the raw JSON body. Verify before processing.
X-Dante-EventEvent type string, e.g. payment_intent.paid
Content-Typeapplication/json
Webhook payload — payment_intent.paid
{
  "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"
  }
}
Full webhook handler (Node.js / Express)
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');
  }
);
WarningAlways verify the 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.

ChainCustomer pays withMerchant receivesSettlement wallet field
SolanaSOL, USDC, BONK, WIF, or any Jupiter-listed tokenUSDC (SPL)usdcSettlementWallet
BaseUSDCUSDC (ERC-20)baseSettlementWallet
EthereumUSDCUSDC (ERC-20)ethSettlementWallet
BitcoinBTCBTC (merchant share)btcSettlementWallet
TipSolana supports memecoin payments via Jupiter DEX aggregator. Any token with sufficient liquidity on Jupiter can be used as a payment token — the customer pays the token, the merchant receives USDC.

Enterprise Configuration

Enterprise

DantePay'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,000

Hard 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-chain

Each 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.

Enterprise merchant configuration example
// 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"
}
EnterpriseTransaction caps above $50,000 and multi-chain treasury routing require an enterprise account. Contact admin@dante-pay.com to configure.

Sandbox Environment

NoteSandbox credentials are only for testing. Do not use production keys in this environment. Test transactions never move real funds.

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

1
Get a test API key
Log into the DantePay merchant dashboard → Developers → API Keys → Generate Test Key. Copy the sk_test_ key.
2
Create a test payment intent
POST to /api/payment-intents with your sk_test_ key and "amountUsd": 10.00. Copy the checkoutUrl from the response.
3
Complete the simulated payment
Open the checkoutUrl in a browser. You'll see a Simulate Payment button. Click it — no wallet required.
4
Verify the webhook
Your webhook endpoint receives a payment_intent.paid event. Verify the X-Dante-Signature header using your test signing secret.
5
Check the dashboard
Log into the merchant dashboard. The test transaction appears with a [TEST] badge in your transaction history.
Test payment intent
# 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,
#   ...
# }
TipUse webhook.site for instant webhook inspection during integration. Paste your generated URL into the dashboard webhook endpoint field.

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 response format
{
  "error": "Human-readable error message describing what went wrong."
}
HTTPCauseResolution
401Invalid or missing API keyCheck your Authorization header. Key must be active and not revoked.
400Amount below minimum or above capamountUsd must be ≥ 0.01 and ≤ your merchant maxTransactionUsd.
400Payment intent expiredIntents expire after 15 minutes. Create a new payment intent.
400Not payable — wrong statusIntent has already been paid, expired, or failed. Do not retry.
400Price impact exceededSwap would exceed maxPriceImpactBps. Customer should choose a more liquid token or pay with USDC directly.
400Merchant wallet not configuredThe merchant has not set a settlement wallet for this chain. Configure in dashboard before accepting payments on that chain.
500Platform wallet not configuredContact support — platform environment variable not set.
502Jupiter quote/swap failedUpstream DEX error. Retry. If persistent, token may have no liquidity.
D
DantePay API Reference v1.0