How to Integrate a Crypto Payment Gateway — Three Options by Technical Complexity

<!-- Coinbase Commerce button -->
<script src="https://commerce.coinbase.com/v1/checkout.js?version=201807"></script>
<button class="buy-with-crypto"
  data-custom="Your-Order-ID"
  data-code="YOUR-CHECKOUT-CODE">
  Pay with Crypto
</button>

// Create payment request (Coinbase Commerce API example)
async function createPayment(orderId, amount, currency = 'USD') {
    const response = await fetch('https://api.commerce.coinbase.com/charges', {
        method: 'POST',
        headers: {
            'X-CC-Api-Key': process.env.COINBASE_COMMERCE_KEY,
            'X-CC-Version': '2018-03-22',
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            name: 'Order Payment',
            description: 'Order ' + orderId,
            local_price: { amount: amount.toFixed(2), currency },
            pricing_type: 'fixed_price',
            metadata: { orderId }
        })
    });
    
    const charge = await response.json();
    return charge.data.hosted_url; // Redirect user to this URL
}

// Webhook handler for payment confirmation
app.post('/webhooks/coinbase', express.raw({ type: 'application/json' }), (req, res) => {
    const signature = req.headers['x-cc-webhook-signature'];
    const payload = req.body.toString('utf8');
    
    // Verify webhook signature
    const hmac = crypto.createHmac('sha256', process.env.COINBASE_WEBHOOK_SECRET);
    const digest = hmac.update(payload).digest('hex');
    
    if (digest !== signature) {
        return res.status(401).send('Invalid signature');
    }
    
    const event = JSON.parse(payload);
    
    if (event.type === 'charge:confirmed') {
        const orderId = event.data.metadata.orderId;
        fulfillOrder(orderId); // Your order fulfillment logic
    }
    
    res.status(200).send('OK');
});

// Generate unique deposit address per order using HD wallet
const { ethers } = require('ethers');

class PaymentAddressManager {
    constructor(hdWalletMnemonic) {
        this.wallet = ethers.HDNodeWallet.fromPhrase(hdWalletMnemonic);
        this.provider = new ethers.JsonRpcProvider(process.env.RPC_URL);
    }
    
    async generateDepositAddress(orderId) {
        // Derive unique child address for each order
        const orderIndex = await this.db.orders.getIndex(orderId);
        const childWallet = this.wallet.derivePath(`m/44'/60'/0'/0/${orderIndex}`);
        
        await this.db.depositAddresses.create({
            orderId,
            address: childWallet.address,
            privateKey: childWallet.privateKey, // Encrypted at rest
            createdAt: new Date(),
            expiresAt: new Date(Date.now() + 3600000) // 1 hour expiry
        });
        
        return childWallet.address;
    }
    
    async monitorForPayment(address, expectedAmount) {
        // Poll for incoming transactions
        const filter = {
            address: USDC_CONTRACT_ADDRESS,
            topics: [
                ethers.id('Transfer(address,address,uint256)'),
                null,
                ethers.zeroPadValue(address, 32)
            ]
        };
        
        return new Promise((resolve) => {
            this.provider.on(filter, (log) => {
                const amount = ethers.toBigInt(log.data);
                if (amount >= BigInt(expectedAmount * 1e6)) { // USDC has 6 decimals
                    resolve({ confirmed: true, txHash: log.transactionHash });
                }
            });
        });
    }
}