Objects

CAIP-2 network.

The lines' net debits sum to zero at both ends of the period (double entry holds).

Decimal string in whole tokens (not base units), e.g. "30.5". Never a JSON number.

Asset code {SYMBOL}@{network}, e.g. USDT@tron:mainnet.

CAIP-2 network.

Flagged first, then explained.

Same labels as the reconciliation report, e.g. merchant:available.

Balance at from (decimal string; may be negative).

Σ debit postings in the period.

Σ credit postings in the period.

Balance at to: the balance as of that moment.

closing − opening.

The same account's movement in the previous period ([previous_from, from)).

The merchant's account-level extended public key, in the form the merchant gave it (xpub/zpub on mainnet, tpub/vpub on test networks). Merchant API only: absent from the checkout view.

p2wpkh (BIP84) or p2tr (BIP86).

0 = receive keychain.

The address index below the keychain (never hardened).

The account's output descriptor with checksum (it contains the account key). Merchant API only: absent from the checkout view.

true: keep it until the paid time ends, then cancel (no more renewals). Default false: cancel now; an open renewal invoice with nothing paid is cancelled too.

Transfers attributed to the cohort's invoices (orphaned ones included in this count).

Σ transfers still on chain.

… of which credited to the merchant.

… of which held as refundable to the payer (wrong asset, late, after cancellation).

… of which not posted yet (confirming or held for review).

Σ transfers removed by a reorg (not in any other total).

Σ unattributed deposits at your deposit addresses opened in the period and still open.

POST /v1/checkout/invoices/{id}/notify works: the server has a mail sink for payer receipts. When false that route answers 409 feature_unavailable, and the checkout hides the field.

Always checkout_invoice.

See [Invoice::price_locked_until]: the checkout shows a timer only when this is set.

What this server can do for the payer beyond showing the invoice. The checkout hides a feature whose flag is false instead of offering it and failing on submit.

A checkout-session token (cps_…), fresh on every GET /v1/checkout/invoices/{id}. Keep the first one you get for this invoice (for example in sessionStorage) and send it with notify: the first address left for an invoice can only be replaced from the same session. Absent from the payment-link mint response; the checkout then loads this view for the new invoice.

See [Invoice::pending_options]: picking one (POST …/payment_option) leases its address.

See [Invoice::select_by].

Always checkout_payment_link.

CAIP-2 id.

The asset sent on that network.

Where renewal reminders go. Optional: without it, you tell the customer yourself (the subscription.invoice_created webhook carries each invoice).

Price in major units of currency, as a decimal string.

ISO 4217 code of the price.

Assets the payer may use. Defaults to the merchant's default_assets.

Shown to the payer. At most 500 characters.

Your reference for the customer. At most 200 characters. Never shown to the payer.

Up to 20 pairs; keys at most 40 characters, values at most 500. Never shown to the payer.

The amount the payer chose, in the link's currency, as a decimal string. Required for payer_chosen links; must be omitted for fixed ones.

ISO 4217 code.

The price (fixed), as a decimal string.

Lower bound for payer_chosen amounts.

Upper bound for payer_chosen amounts.

Shown to the payer. At most 500 characters.

Accepted assets. Omit to use the merchant's defaults at the time each invoice is created.

1 to 1,000,000 payments; omit for unlimited.

RFC 3339; must be in the future.

Up to 20 pairs; keys at most 40 characters, values at most 500. Copied to every invoice.

Default true.

Price per period, a decimal string.

Default 1. At most 365 days, 52 weeks, 12 months or 1 year.

Default 0, at most 365.

Default 3, at most 30.

Default 4, 1 to 7.

IANA name, default UTC.

Whole tokens, as a decimal string. Defaults to the overpaid excess (or, for an asset the invoice did not ask for, everything received in it).

The asset code to refund in. Defaults to the asset the invoice was paid in; give another received asset (e.g. a wrong token) to refund that.

cus_…

plan_… (must be active).

Overrides the plan's trial (0 = start billing now).

Always customer.

Prepaid credit (overpayments and top-ups), per asset. Renewals consume it before invoicing.

What differs, why, and what happens next.

The amount involved (decimal string in the section's asset; may be negative).

Stable machine-readable reason, e.g. parameter_invalid, api_key_invalid.

Human-readable explanation. Do not parse it.

The request parameter the error is about, if any (e.g. amount, assets[1]).

Link to the documentation for code.

The request id, also returned in the x-request-id header. Quote it to support.

Always list.

The asset the fees are for.

Network family: tron, bsc, ethereum, base, arbitrum or polygon.

The mainnet the entry describes (CAIP-2).

The exchange's own name for the network, exactly as its withdrawal screen shows it. null unless verified: show generic wording instead.

Whether the exchange supports withdrawals of this asset on this network (null: unknown).

When the served values were last checked against source_url (YYYY-MM-DD).

The exchange's own page the values were checked against.

Decimal string in major units, e.g. "30.00". Never a JSON number.

ISO 4217 code.

0xff on EVM chains, 0x41 on TRON.

The merchant's registered destination. Compare it with your own pinned copy.

The zero address when fee_bps is 0.

Processor fee in basis points, at most 500 (enforced by the contract).

Base units the forwarder keeps after a flush (warm-slot dust), as a decimal string.

The slot id (bytes32, 0x-hex).

The expected salt (bytes32, 0x-hex). Recompute it; it is here for debugging only.

Always invoice.

The price, as the merchant set it.

The merchant's own customer reference. Never shown to the payer.

Up to 20 merchant key/value pairs. Never shown to the payer.

End of the detection window. Payments after it are late.

End of the price lock, when the invoice offers a volatile asset (BTC). A volatile-asset payment after it is repriced at arrival (within the late band it is still accepted). Absent for stablecoin-only invoices, which have no lock.

The payment link (plink_…) a payer created this invoice from, or null.

Offered options that have no deposit address yet. A payment-link invoice leases an address only when the payer picks a network (POST /v1/checkout/invoices/{id}/payment_option); until then its options are listed here, and each pick moves its network's options to payment_options. Always empty for invoices created through /v1/invoices, which get every address at creation.

Payment-link invoices only: if the payer has not picked a network by then, the invoice expires early (it never held a deposit address). null once a network was picked, and for every invoice created through /v1/invoices.

Per-invoice sequence number, starting at 1, strictly increasing.

invoice.{status}, e.g. invoice.confirming.

Always list.

Pass as cursor to get the next page. null on the last page.

Σ received by paid (and paid late) invoices.

Σ received by overpaid invoices (the excess is in refundable until refunded).

Σ received by invoices that were not paid in full (partially paid, expired, cancelled).

Σ received by invoices still in progress (awaiting, detected, confirming, under review).

Σ the invoices hold as refundable to payers, less refunds marked in the ledger.

Σ refunds recorded as sent.

Σ refunds created and not yet sent (awaiting claim, ready to send, in review).

Σ open suspense (same as chain.suspense).

Always ledger_balances.

Start of the period (inclusive): opening balances are as of this moment.

End of the period (exclusive): closing balances are as of this moment.

Start of the previous period, which ends at from and is as long as this one.

False on a server without a ledger (the in-memory demo): balances are then derived from the invoices, each dated at its creation.

processor:{network}:{role}, merchant:{pending|available|reserved}, payer_refundable, suspense:{network}, fees:{kind} or fx:{pair}.

Σ debit postings (decimal string).

Σ credit postings (decimal string).

The balance on the account's normal side: positive = what the account normally holds.

CAIP-2 network.

Asset code when the token is one we support, else null.

Whole tokens, when the asset is known.

Where it went, in the network's display form.

It went to this invoice's deposit address on that network.

Your payout transaction (0x + 64 hex digits; TRON hashes without 0x are accepted too).

Always merchant_settings.

Shown to payers on the checkout.

The last four characters of the webhook signing secret, to tell secrets apart.

Assets offered when an invoice does not list its own.

Every asset this mode can accept.

Shortfall still counted as paid, in basis points of the amount due.

Always payer_notice.

The address, masked (p***@example.com). The full address is never returned.

Where to send the receipt (and any refund link).

The payer's language for the emails (en, ru, vi, ...). Default en.

The checkout view's session_token for this invoice (the first one this page got). Once an address is set, only the same session may replace it.

Always payment.

Always payment_link.

Computed: whether a payer can use the link now.

The merchant's switch. false stops new invoices; invoices already created are unaffected.

The public part of the link's URL.

{checkout}/?link={slug} when this server knows its checkout origin, else null. The checkout needs your publishable key too: share {url}&key=cp_…_pk_….

ISO 4217 code of every amount on the link.

The price, as a decimal string (fixed links only).

The smallest amount a payer may choose (payer_chosen links only).

The largest amount a payer may choose (payer_chosen links only).

Shown to the payer and copied to each invoice.

Accepted assets. null = the merchant's default_assets when an invoice is created.

How many payments the link takes. null = unlimited.

Invoices created from this link on which a payment was seen.

Open, unpaid invoices of this link. Each holds a unit until it is paid (then it counts in quantity_used), expires or is cancelled. Minting stops while quantity_used + quantity_reserved is at the limit.

Every invoice created from this link, paid or not.

After this, the link creates no more invoices.

Up to 20 merchant key/value pairs, copied to each invoice. Never shown to the payer.

Always list.

Pass as cursor to get the next page. null on the last page.

Always list.

Pass as cursor to get the next page. null on the last page.

Asset code, e.g. USDT@tron:mainnet.

Ticker as payers know it.

CAIP-2 network id.

The network named the way exchanges name it.

Exactly how much must arrive, in whole tokens.

The deposit address, in the network's display form.

A wallet URI (EIP-681 on EVM networks) when one exists for the network.

0x-hex transaction hash, or on Solana the transaction's base58 signature (informational: a hash never credits anything).

Asset code, e.g. USDT@tron:mainnet. Pass it to POST /v1/checkout/invoices/{id}/payment_option.

CAIP-2 network id.

Exactly how much must arrive, in whole tokens.

Always plan.

The price of one period.

Periods are interval_count × interval long (e.g. 3 months).

Free days before the first period (0 = none).

Days after a renewal's due date before the subscription becomes past_due.

Payment attempts per period (the renewal invoice counts as the first); when every one closes unpaid, the subscription is cancelled.

Asset codes renewal invoices offer; null = the merchant's defaults at renewal time.

IANA time zone the periods are counted in (month ends, DST).

Archived plans take no new subscriptions; existing ones keep renewing.

Always reconciliation.

Start of the period (inclusive): invoices created at or after it.

End of the period (exclusive).

The worst status of any asset (balanced when there is nothing to reconcile).

False on a server without a ledger (the in-memory demo): ledger lines are then empty.

Always refund.

How much to send, in whole tokens. The same amount on whichever network the payer picks.

Networks the payer may choose from (CAIP-2).

The claim capability. Give the payer claim_url (or build a link with this token); whoever holds it can choose the payout address. Empty on the dashboard for roles that may not manage refunds.

{checkout origin}/?claim={claim_token} when the API knows the checkout origin, else null.

The merchant's payout transaction, once recorded.

Always refund_claim.

awaiting_claim until the payer submits; in_review means the merchant must look first.

Always list.

CAIP-2 network the payer chose.

The asset to send on that network, e.g. USDT@tron:mainnet.

The payer's address, in the network's display form.

Must equal the deposit address and one of the merchant's pinned receive addresses.

Why, for your records and the webhook (1 to 500 characters).

ofac_sdn or issuer_blacklist.

Which list version or contract was consulted, e.g. the SDN extract's fetch date.

Why a check did not apply or could not run.

One of the invoice's pending_options[].asset (or payment_options[].asset, which changes nothing).

The payment option to pay: an asset code (USDT@tron:nile), or a symbol (USDT) together with network. Defaults to the invoice's first payment option.

CAIP-2 network (tron:nile). Optional when asset is a full asset code (then it must match).

Whole tokens to "send", as a decimal string. Defaults to the option's amount due. Send more to test an overpayment, less for an underpayment.

Finality levels the payment passes through, in order: pending, included, safe, final. Default ["included", "final"]. The in-memory demo server runs its own confirmation timer instead.

Σ received in this asset.

One of the claim's networks[].network.

Your address on that network. For an exchange account, your deposit address for this asset on exactly this network.

Always subscription.

The period the subscription is in now (the trial, while in trial).

Everything up to here is paid for.

When the next unpaid period is due; null once cancelled or while paused.

Attempts made for the next unpaid period (0 until its renewal invoice exists).

The newest invoice this subscription created.

CAIP-2 network.

Log / output index within the transaction.

Always tx_lookup.

The hash as looked up (0x + 64 lowercase hex digits), or a Solana signature (base58).

The network the transaction was found on.

Networks that were searched (CAIP-2).

false deactivates the link: no new invoices; existing ones are unaffected.

null = the merchant's defaults.

null = unlimited.

null = never expires.

Replaces the metadata.

https:// URL of your webhook endpoint, or null to stop deliveries.

Always wallet_binding.

CAIP-2 network.

The bound wallet address (display form). Only a transfer from it is attributed.

Where to send: the merchant's registered destination on this network (display form). The checkout checks it against the destination the deposit addresses commit to, and against the merchant's pins, before building the transfer.

The token contract (display form); null for the network's native coin.

The token's decimals.

Send exactly this, in whole tokens (decimal string). The amount due plus the uniqueness suffix.

The same amount in base units (decimal string): what goes into the transfer call.

The invoice's amount due in this asset (whole tokens). amount − amount_due is the suffix.

A transfer arriving after this is not attributed by this binding.

The payment option to pay: its asset code, SYMBOL@network (one of the invoice's options).

The connected wallet's address on that network, in its display form (0x… or T…). The transfer must come from exactly this address.

Always webhook_delivery.

The invoice the event is about (inv_…). Every invoice and refund event has one; payment_link.* events, and subscription events that are not about an invoice, have null.

1 for the first attempt of this delivery.

The first 1 KiB of the endpoint's response body.

The delivery this one replays, if it is a replay.

Always list.

Pass as cursor to get the next page. null on the last page.

Always webhook_secret.