PPulze

Merchant docs

Design your Pulze integration before approval: payment links, recurring mandates, multi-token checkout, credit top-ups, agent billing, webhooks, SDK, and MCP.

Builder access is open. You can use all documentation and prepare your integration now. API keys and payment execution unlock after Pulze verifies the merchant; no credential or customer charge is available from documentation access alone.

Payment links

Create a link from the dashboard. Your customer opens it, connects a wallet, signs once, and Pulze records the payment or subscription against your merchant account.

Unified crypto payments

Customers can pay using bits of crypto left across supported wallets/tokens. The system routes them programmatically into one payment and settles to your preferred stablecoin.

Recurring payments

The customer signs the subscription approval once. When the billing period is due, Pulze can execute the authorized pull without asking the customer for a second approval.

Club memberships

Football teams and social clubs can create a monthly membership link. Members connect a wallet, sign dues once, then Pulze asks the wallet to add the club coin or membership NFT.

API keys and SDK

Build against the typed SDK interfaces for server-side subscriptions, invoices, reporting, webhooks, and checkout. Generate credentials after account approval.

MCP and agent billing

Connect approved AI agents to bounded usage reporting and saved-mandate charging. Human review modes, merchant limits, audit logs, and kill switches remain in the payment path.

Credits and usage businesses

Let customers enter a top-up amount once, save a mandate, and add credits later without repeating wallet setup. Usage businesses can meter first and bill within approved caps.

Webhooks and reconciliation

Consume signed lifecycle events for payments, subscriptions, refunds, disputes, payouts, and credit notes. Treat transaction confirmation as the source of payment truth.

Choose your integration

  • No-code commerce: create and share payment or subscription links.
  • SaaS and memberships: schedule recurring charges under one customer mandate.
  • Usage and compute: report metered usage, review it, then charge within caps.
  • Wallet credits: let customers choose an amount and repeat top-ups later.
  • Marketplaces and families: coordinate split invoices and recurring shares.
  • Agentic commerce: give an agent a narrowly scoped key with human controls.

    • Club membership flow

    1. Create a Club membership link with monthly dues.
    2. Add the fan coin or NFT contract details.
    3. Send the link to members by WhatsApp, email, QR, or social media.
    4. Member connects wallet and signs the dues authorization.
    5. Pulze records the agreement and subscription metadata.
    6. Wallet prompts the member to add the club asset after activation.

    Wallets treat payment authorization and asset import as separate confirmations. Pulze combines them into one guided membership flow, but the wallet may still show an add-asset prompt for member safety.

    Quick API

    Prepare this server-side integration now. Add the issued key only after verification.

    import { PulzeClient } from '@pulze/sdk';

const pulze = new PulzeClient({
  baseUrl: 'https://api.pulze.app/api/v1',
  apiKey: process.env.PULZE_API_KEY
});

await pulze.subscriptions.create({
  sub,
  signature,
  email: 'customer@example.com',
  chain: 'ethereum'
});

    TypeScript SDK

    Use the typed client from your server. Keep issued credentials out of browsers, repositories, logs, prompts, and client bundles.

    npm install @pulze/sdk ethers

const pulze = new PulzeClient({
  baseUrl: 'https://api.pulze.guru/api/v1',
  apiKey: process.env.PULZE_API_KEY
});

    MCP discovery

    Run the MCP server without a key to inspect public payment links and route quotes. Authenticated agent tools unlock only after verification and scoped-key issuance.

    PULZE_API_URL=https://api.pulze.guru \
node packages/mcp/src/server.mjs

# Add PULZE_MCP_API_KEY only after approval.

    API authentication and schema

    Store the issued key as PULZE_API_KEY on your server and send it in X-API-Key. It is not a Bearer token. Interactive dashboard sessions use Bearer authentication separately.

    OpenAPI referenceCompatibility URL
    POST /api/v1/merchants/{merchantId}/payment-links
X-API-Key: pk_live_...
Content-Type: application/json

{
  "amount": "100000000",
  "title": "Monthly plan",
  "period": 2592000,
  "maxCycles": 0,
  "trialDays": 0,
  "customerEmail": "customer@example.com",
  "taxBehavior": "EXCLUSIVE"
}

    Amount uses six-decimal smallest units: $100.00 is 100000000. Omit period for one-time checkout. A positive period creates recurring billing; zero max cycles means the subscription remains active until cancelled.

    # Python
from decimal import Decimal
import requests

usd6 = str(int(Decimal("100.00") * 1_000_000))
response = requests.post(
    f"https://api.pulze.guru/api/v1/merchants/{merchant_id}/payment-links",
    headers={"X-API-Key": PULZE_API_KEY},
    json={"amount": usd6, "title": "Monthly plan", "period": 2592000},
    timeout=20,
)
response.raise_for_status()

    Signed webhook contract

    Register an HTTPS endpoint in merchant Settings. Pulze shows its signing secret once, supports test delivery and replay, and retries failed deliveries with backoff.

    Pulze-Event: payment.confirmed
Pulze-Delivery: delivery_id
Pulze-Timestamp: 1780000000
Pulze-Signature-Version: v1
Pulze-Signature: v1=<hex hmac sha256>

signature = HMAC_SHA256(
  PULZE_WEBHOOK_SECRET,
  Pulze-Timestamp + "." + rawRequestBody
)

{
  "id": "delivery_id",
  "type": "payment.confirmed",
  "createdAt": "ISO-8601 timestamp",
  "data": { "paymentId": "...", "status": "CONFIRMED", "txHash": "0x..." }
}

    Verify against the untouched raw request body before parsing JSON. Reject stale timestamps and deduplicate by the outer delivery id. Core events are payment.confirmed, subscription.created, dispute.opened, dispute.resolved, refund.approved, refund.completed, and refund.failed.

  • payment.confirmed: paymentId, paymentLinkId, subscriptionId, payer address/email, chain, tokens, gross/subtotal/tax/fee/net amounts, status, txHash, payment type.
  • subscription.created: subscriptionId, paymentLinkId, payer address/email, chain, token, amount per cycle, period, max/executed cycles, total paid, status, next payment date.
  • dispute events: disputeId, paymentId, status/outcome, frozen amount, reason, and whether a refund is required.
  • refund events: refund/payment/dispute ids where applicable, amount, token, chain, status, txHash, and failure reason.

    • Builder-to-launch checklist

    1. Complete merchant signup and payout wallet.
    2. Choose the API, SDK, MCP, or no-code integration pattern.
    3. Map payment, refund, dispute, and payout webhook handling.
    4. Complete Pulze account verification.
    5. Generate credentials and run the controlled integration test.
    6. Enable customer payments only after the launch review passes.