Integrate in 5 minutes

import { ArgusPulseClient } from '@arguspulse/sdk';

const client = new ArgusPulseClient({
  baseUrl: 'https://api.arguspulse.io',
  apiKey:  process.env.ARGUS_API_KEY!,
});

// Or use a Keycloak bearer token for user-facing flows:
// token: async () => await getFreshAccessToken()

from arguspulse import ArgusPulseClient
import os

client = ArgusPulseClient(
    base_url="https://api.arguspulse.io",
    api_key=os.environ["ARGUS_API_KEY"],
)

# Or use a bearer token:
# token=lambda: refresh_keycloak_token()

use ArgusPulse\Client;

$client = new Client([
    'baseUrl' => 'https://api.arguspulse.io',
    'apiKey'  => $_ENV['ARGUS_API_KEY'],
]);

// Or a bearer token (auto-refresh callable also supported):
// 'token' => fn() => $keycloakClient->getFreshToken()

await client.createWallet({
  network:   'BSC',
  address:   '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
  label:     'Hot wallet',
  direction: 'IncomingOnly',   // 'Both' | 'IncomingOnly' | 'OutgoingOnly'
});

from arguspulse import CreateWalletInput

client.create_wallet(CreateWalletInput(
    network="BSC",
    address="0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
    label="Hot wallet",
    direction="IncomingOnly",
))

$wallet = $client->createWallet([
    'network'   => 'BSC',
    'address'   => '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045',
    'label'     => 'Hot wallet',
    'direction' => 'IncomingOnly',
]);

import express from 'express';
import { parseVerifiedWebhook, type WebhookPayload } from '@arguspulse/sdk';

const app = express();

// IMPORTANT: capture the raw body, do NOT use express.json() on this route
app.post('/hooks/arguspulse', express.raw({ type: 'application/json' }), (req, res) => {
  try {
    const event = parseVerifiedWebhook<WebhookPayload>({
      secret:          process.env.ARGUS_WEBHOOK_SECRET!,
      rawBody:         req.body.toString('utf8'),
      signatureHeader: req.header('x-arguspulse-signature'),
      timestampHeader: req.header('x-arguspulse-timestamp'),
    });
    console.log(`Deposit ${event.amountDecimal} ${event.symbol} on ${event.network}`);
    res.sendStatus(200);
  } catch {
    res.sendStatus(401); // invalid signature or stale timestamp
  }
});

from flask import Flask, request, abort
from arguspulse import parse_verified_webhook

app = Flask(__name__)

@app.post("/hooks/arguspulse")
def webhook():
    # Get raw body BEFORE any JSON parsing
    raw_body = request.get_data(as_text=True)
    try:
        event = parse_verified_webhook(
            secret=app.config["ARGUS_WEBHOOK_SECRET"],
            raw_body=raw_body,
            signature_header=request.headers.get("X-ArgusPulse-Signature"),
            timestamp_header=request.headers.get("X-ArgusPulse-Timestamp"),
        )
    except ValueError:
        abort(401)

    print(f"Deposit {event['amountDecimal']} {event['symbol']} on {event['network']}")
    return "", 200

# FastAPI variant, see SDK README for async example

<?php
require 'vendor/autoload.php';

use ArgusPulse\ArgusPulseException;
use ArgusPulse\Webhook;

// Always read raw body BEFORE json_decode
$rawBody         = file_get_contents('php://input');
$signatureHeader = $_SERVER['HTTP_X_ARGUSPULSE_SIGNATURE'] ?? null;
$timestampHeader = $_SERVER['HTTP_X_ARGUSPULSE_TIMESTAMP'] ?? null;

try {
    $event = Webhook::parseVerifiedPayload(
        secret:           $_ENV['ARGUS_WEBHOOK_SECRET'],
        rawBody:          $rawBody,
        signatureHeader:  $signatureHeader,
        timestampHeader:  $timestampHeader,
        toleranceSeconds: 300,  // replay-attack window
    );
    error_log("Deposit {$event->amountDecimal} {$event->symbol} on {$event->network}");
    http_response_code(200);
} catch (ArgusPulseException $e) {
    http_response_code(401);  // invalid signature or stale timestamp
}

// Laravel: see SDK README for the controller + CSRF exclusion pattern

// One-time xpub setup per network
await client.setPaymentXpub('BSC', 'xpub6CUGRUon…');

// Create a session per order
const session = await client.createPayment({
  network:        'BSC',
  asset:          'USDT',
  expectedAmount: '1000000000000000000',  // base units (optional)
  reference:      'order-12345',            // idempotent
  callbackUrl:    'https://your-server.example/paid',
});

console.log('Pay to:', session.address);  // unique BIP32-derived address

from arguspulse import CreatePaymentInput

# One-time xpub setup
client.set_payment_xpub("BSC", "xpub6CUGRUon…")

# Create a session per order
session = client.create_payment(CreatePaymentInput(
    network="BSC",
    asset="USDT",
    expected_amount="1000000000000000000",
    reference="order-12345",
    callback_url="https://your-server.example/paid",
))
print("Pay to:", session.address)

// One-time xpub setup
$client->setPaymentXpub('BSC', 'xpub6CUGRUon…');

// Create a session per order
$session = $client->createPayment([
    'network'        => 'BSC',
    'asset'          => 'USDT',
    'expectedAmount' => '1000000000000000000',
    'reference'      => 'order-12345',
    'callbackUrl'    => 'https://your-server.example/paid',
]);

echo 'Pay to: ' . $session->address;  // unique BIP32-derived address