Non-custodial · API-first

Crypto payments that never touch our hands.

Klappay is a non-custodial crypto payments API. You create a charge, we compute a deterministic on-chain split address, your customer pays directly into it — we just detect and route it. We never hold a single cent.

See the integration

checkout.ts

import { createClient } from '@klappay/node'

const klap = createClient({
  baseUrl: 'https://api.klap.dev',
  apiKey: process.env.KLAP_API_KEY,
})

const charge = await klap.charges.create({
  amount: 49.9,
  acceptedPayments: [{ token: 'USDC', network: 'base' }],
})

const paid = await charge.waitForConfirmation()
console.log('Paid:', paid.amountReceived)

How it works

Four steps, and the money never touches a Klappay vault.

You create a charge

One API call with an amount and accepted tokens. A deterministic id is born with it.

Klappay computes the address

A split address (0xSplits v2) is derived for that exact charge — recipients frozen and immutable since creation.

The payer sends directly

Your customer sends funds straight to that on-chain address. It never passes through a Klappay-controlled account.

Klappay detects and distributes

We watch the chain, confirm the transfer, and trigger the payout to the merchant wallet — no custody at any step.

Not built like the rest of the market

Most crypto payment processors still behave like a bank: they hold your money before passing it on. Klappay holds nothing.

Klappay

Traditional processors

Custody

Klappay —Never. Funds go straight to the on-chain split address.

Others —Funds pass through the provider’s account before reaching you.

Integration

Klappay —Pure API. Your checkout, your design, your UX.

Others —Hosted widget/iframe — you adapt your product to it.

Split payments

Klappay —Native: a multi-recipient address ships with every charge.

Others —Bolted-on feature, usually gated or priced separately.

Real-time status

Klappay —SSE + webhooks + charge.waitForConfirmation() in the SDK.

Others —Manual polling or a single webhook, no native stream.

Sandbox

Klappay —Simulate any charge event without touching a real chain.

Others —Testnet-only when it exists — slow, brittle setup.

Types

Klappay —API and SDK share the same Zod schema. Never drifts.

Others —Types maintained by hand, tend to drift from the real API.

Zero to first payment in 5 steps

Real example, straight from the official Node SDK.

STEP 01 / 05

Install the SDK

One package, zero blockchain plumbing on your side.

terminal

npm install @klappay/node

Everything to integrate

Live API reference, a ready-to-import Postman collection, and full SDK docs — no account required to look around.

API reference

Interactive docs generated straight from the live OpenAPI schema — try any endpoint from the browser.

Postman collection

Ready to import, regenerated fresh from that exact instance — never drifts from the code actually running.

Node SDK docs

Client setup, charges, webhooks, sandbox testing, error handling — the full @klappay/node reference.

@klappay/types

The Zod schemas and TypeScript types both the API and SDK share. MIT-licensed, published standalone.

Built for developers

Everything you'd expect from a modern payments API.

Non-custodial by design

Every charge gets its own deterministic split address. Funds never sit in a Klappay-controlled wallet.

Type-safe SDK

The Node SDK and the API share the same Zod schemas — no hand-written types drifting out of sync.

Webhooks + realtime SSE

Get notified the moment a charge is confirmed, partially paid, or settled — push, not poll.

Sandbox testing

Simulate any charge event end-to-end, no real on-chain activity or testnet faucet required.

Multi-network, multi-token

A live capability matrix tells you which (token, network) pairs are accepted — build the picker, don’t hardcode it.

Precise settlement

Overpay, underpay, partial payments — handled as an exact decimal state machine, never floating-point guesswork.