Accept your first crypto payment in five minutes.

# Official TypeScript / JavaScript SDK
npm install @zettapay/sdk
# or: pnpm add @zettapay/sdk · yarn add @zettapay/sdk · bun add @zettapay/sdk

# Official Python SDK
pip install zettapay
# or: poetry add zettapay · uv add zettapay

# Official PHP SDK (Composer)
composer require zettapay/sdk

# Official Rust crate
cargo add zettapay
# or in Cargo.toml: zettapay = "0.1"

# .env — kept on your servers, never on ours
ZETTAPAY_API_KEY=sk_live_...
ZETTAPAY_WEBHOOK_SECRET=whsec_...

# Wallet addresses you control — pick any subset
MERCHANT_BTC_PUBKEY=bc1qx5...e92
MERCHANT_ETH_PUBKEY=0x7a3...4F2
MERCHANT_SOL_PUBKEY=7Np41oeYqPefeNQEHSv1UDhYrehxin3NStpSyab9YVhT

import { ZettaPay } from '@zettapay/sdk';

// Pubkey lives in your code, in env vars you control.
const zp = new ZettaPay({
  apiKey:        process.env.ZETTAPAY_API_KEY!,
  webhookSecret: process.env.ZETTAPAY_WEBHOOK_SECRET!,
  pubkeys: {
    btc: process.env.MERCHANT_BTC_PUBKEY,
    eth: process.env.MERCHANT_ETH_PUBKEY,
    sol: process.env.MERCHANT_SOL_PUBKEY,
  },
  webhookUrl: 'https://my-app.com/webhooks/zettapay',
});

await zp.register();   // idempotent: registers pubkeys with the chain listener

const invoice = await zp.invoices.create({
  amount:       '19.90',           // string for precise decimals
  currency:     'USDC',            // 'BTC' | 'ETH' | 'USDC'
  customer_ref: 'order_42',
});

// Send the customer here:
console.log(invoice.payment_url);   // https://pay.zettapay.io/inv_01HM...

import os
from zettapay import ZettaPay

# Pubkey lives in your code, in env vars you control.
zp = ZettaPay(
    api_key=os.environ["ZETTAPAY_API_KEY"],
    webhook_secret=os.environ["ZETTAPAY_WEBHOOK_SECRET"],
    pubkeys={
        "btc": os.environ.get("MERCHANT_BTC_PUBKEY"),
        "eth": os.environ.get("MERCHANT_ETH_PUBKEY"),
        "sol": os.environ.get("MERCHANT_SOL_PUBKEY"),
    },
    webhook_url="https://my-app.com/webhooks/zettapay",
)

zp.register()   # idempotent: registers pubkeys with the chain listener

invoice = zp.invoices.create(
    amount="19.90",
    currency="USDC",         # "BTC" | "ETH" | "USDC"
    customer_ref="order_42",
)

print(invoice.payment_url)   # https://pay.zettapay.io/inv_01HM...

use ZettaPay\Client;

// Pubkey lives in your code, in env vars you control.
$zp = new Client([
    'api_key'        => getenv('ZETTAPAY_API_KEY'),
    'webhook_secret' => getenv('ZETTAPAY_WEBHOOK_SECRET'),
    'pubkeys'        => [
        'btc' => getenv('MERCHANT_BTC_PUBKEY'),
        'eth' => getenv('MERCHANT_ETH_PUBKEY'),
        'sol' => getenv('MERCHANT_SOL_PUBKEY'),
    ],
    'webhook_url'    => 'https://my-app.com/webhooks/zettapay',
]);

$zp->register(); // idempotent: registers pubkeys with the chain listener

$invoice = $zp->invoices->create([
    'amount'       => '19.90',
    'currency'     => 'USDC',    // 'BTC' | 'ETH' | 'USDC'
    'customer_ref' => 'order_42',
]);

echo $invoice->payment_url; // https://pay.zettapay.io/inv_01HM...

use zettapay::{Client, ClientConfig, Pubkeys, CreateInvoice, Currency};

// Pubkey lives in your code, in env vars you control.
let zp = Client::new(ClientConfig {
    api_key:        std::env::var("ZETTAPAY_API_KEY")?,
    webhook_secret: std::env::var("ZETTAPAY_WEBHOOK_SECRET")?,
    pubkeys: Pubkeys {
        btc: std::env::var("MERCHANT_BTC_PUBKEY").ok(),
        eth: std::env::var("MERCHANT_ETH_PUBKEY").ok(),
        sol: std::env::var("MERCHANT_SOL_PUBKEY").ok(),
    },
    webhook_url: "https://my-app.com/webhooks/zettapay".into(),
})?;

zp.register().await?;   // idempotent: registers pubkeys with the chain listener

let invoice = zp.invoices().create(CreateInvoice {
    amount:       "19.90".into(),
    currency:     Currency::USDC,    // Currency::BTC | ETH | USDC
    customer_ref: "order_42".into(),
    ..Default::default()
}).await?;

println!("{}", invoice.payment_url); // https://pay.zettapay.io/inv_01HM...

// Express handler · TypeScript
import express from 'express';
import { verifyWebhook } from '@zettapay/sdk';

const app = express();

// IMPORTANT: keep the raw body — JSON parsing destroys the signature
app.post(
  '/webhooks/zettapay',
  express.raw({ type: 'application/json' }),
  (req, res) => {
    try {
      const event = verifyWebhook({
        body:      req.body,                              // Buffer
        signature: req.header('X-ZettaPay-Signature')!,
        timestamp: req.header('X-ZettaPay-Timestamp')!,
        secret:    process.env.ZETTAPAY_WEBHOOK_SECRET!,
        toleranceSec: 300,                            // reject if older than 5 min
      });

      if (event.event === 'payment.confirmed') {
        // Idempotent by tx_hash — same hash is never delivered twice,
        // but you should still de-dupe on your side as defense in depth.
        markOrderPaid(event.customer_ref, event.tx_hash);
      }
      res.status(200).send('ok');
    } catch (err) {
      res.status(400).send('invalid signature');
    }
  },
);

# Flask handler · Python
import os
from flask import Flask, request, abort
from zettapay import verify_webhook, WebhookError

app = Flask(__name__)
SECRET = os.environ["ZETTAPAY_WEBHOOK_SECRET"]

@app.post("/webhooks/zettapay")
def on_event():
    try:
        event = verify_webhook(
            body=request.get_data(),                       # raw bytes, NOT request.json
            signature=request.headers["X-ZettaPay-Signature"],
            timestamp=request.headers["X-ZettaPay-Timestamp"],
            secret=SECRET,
            tolerance_sec=300,
        )
    except WebhookError:
        abort(400)

    if event["event"] == "payment.confirmed":
        mark_order_paid(event["customer_ref"], event["tx_hash"])

    return "ok", 200

// Slim / vanilla PHP handler
use ZettaPay\Webhook;
use ZettaPay\WebhookException;

$secret = getenv('ZETTAPAY_WEBHOOK_SECRET');
$body   = file_get_contents('php://input');   // raw body

try {
    $event = Webhook::verify(
        $body,
        $_SERVER['HTTP_X_ZETTAPAY_SIGNATURE'],
        $_SERVER['HTTP_X_ZETTAPAY_TIMESTAMP'],
        $secret,
        300,                                // tolerance seconds
    );
} catch (WebhookException $e) {
    http_response_code(400);
    exit('invalid signature');
}

if ($event['event'] === 'payment.confirmed') {
    mark_order_paid($event['customer_ref'], $event['tx_hash']);
}
echo 'ok';

// Axum handler · Rust
use axum::{extract::State, http::HeaderMap, response::IntoResponse};
use zettapay::webhook::{verify, VerifyParams};

async fn on_event(
    headers: HeaderMap,
    body: axum::body::Bytes,
) -> impl IntoResponse {
    let secret = std::env::var("ZETTAPAY_WEBHOOK_SECRET").unwrap();

    let event = match verify(VerifyParams {
        body: &body,
        signature: headers.get("X-ZettaPay-Signature").unwrap().to_str().unwrap(),
        timestamp: headers.get("X-ZettaPay-Timestamp").unwrap().to_str().unwrap(),
        secret: &secret,
        tolerance_sec: 300,
    }) {
        Ok(e)  => e,
        Err(_) => return (axum::http::StatusCode::BAD_REQUEST, "invalid"),
    };

    if event.event == "payment.confirmed" {
        mark_order_paid(&event.customer_ref, &event.tx_hash).await;
    }
    (axum::http::StatusCode::OK, "ok")
}