What's New

Net-new features in v2 with no v1 equivalent

These capabilities are entirely new in v2. If you need any of them, migrating to v2 is required.

Synthetic Accounts

Subledger accounts that exist entirely within Payload, used to power embedded banking features like wallets, escrow, and instant payout funding.

• Created under the unified /accounts endpoint with type='synthetic', and paired with a synthetic PaymentMethod (transfer_type='two_way', send_only, or receive_only) that represents the account balance.
• Always start at $0. Funded via credit transactions from any account or source.
• Balance updates in real-time as transactions clear.
• Fast internal transfers between synthetic accounts without routing through external rails.
• Use cases: customer wallets, escrow, store credits, loyalty programs, instant payout funding.

Dynamic Funding (Multi-Party Splits)

Split a single payment across multiple processing accounts in one atomic API call via the transfers array on a transaction.

• Standard flow (most common): One payment split across multiple accounts (e.g., $1,000 payment routes $900 to vendor, $50 to platform fee, $50 to franchise royalty).
• Reverse flow: Multiple Processing Accounts debited, single recipient deposit. Useful for commission aggregation, consolidated payouts.
• Implemented via transfers array on payment transactions. Each transfer specifies an amount and a destination account. Negative amounts indicate debits.
• Creates corresponding Transfer objects for tracking and reconciliation.
• Use cases: multi-vendor marketplaces, revenue sharing, franchise royalties, IOLTA trust account splits, platform fee collection, commission aggregation.

Multi-Method Funding

Processing accounts can support multiple funding methods, and the default funding method can be overridden on individual transactions, invoices, billing schedules, and payment links.

• Attach multiple bank accounts (or other funding methods) to a single processing account.
• Set a default for the account, then override per object when needed — useful for routing specific revenue streams to specific destinations.
• Overrides apply at the transaction, invoice, billing schedule, or payment link level.
• Use cases: segregating funds by program or department, routing platform fees separately from merchant settlements, directing specific invoice payments to dedicated accounts.

Processing Rules

Admin-configured conditional overrides that automatically adjust pricing and funding behavior based on transaction characteristics. Evaluated by priority (100 = highest).

• Conditions: amount (eq/gt/lt/ge/le), card_brand (Visa/MC/Amex/Discover), card_type (credit/debit/prepaid), payment_method_type (card/bank_account/synthetic), source (api/keyed/googlepay/applepay/check/plaid), currency (USD/CAD), transaction_type (payment/payout).
• Effects (Pricing): trans_rate (percentage fee), trans_cost (fixed per-transaction fee), trans_fee_cap (maximum fee ceiling), conv_fee_alloc (customer fee pass-through percentage).
• Read-only via API. Configured administratively by Payload. You can query active rules via ProcessingRule.filter_by() but cannot create or modify them via API.
• Use cases: lower rates for debit cards, premium rates for Amex, longer funding delays for high-risk transactions, zero-fee ACH pricing.

Instant Payouts via RTP

Real-time payout delivery using the RTP (Real-Time Payments) network. Funds appear in recipient bank accounts within seconds.

• Funded through synthetic accounts. Pre-fund a synthetic account, then disburse instantly from that balance.
• One-time funding delay: the initial deposit to the synthetic account takes normal settlement time (next business day). After that, all payouts from the synthetic balance are instant.
• Set funding_timing='instant' on the payout transaction. Payload routes via RTP automatically.
• Automatic fallback: if the recipient's bank doesn't support RTP, Payload falls back to ACH or wire and returns the routing decision in real time in the API response.
• Use cases: gig worker instant pay, emergency vendor payments, real-time contractor settlements, earned wage access.

API-Driven Processing Account Enrollment

For advanced integrations that need full control over the onboarding experience, v2 supports creating processing accounts and submitting KYC/entity data entirely via API — no redirect to a hosted form required. v1's Enrollment Link and Processing Account Form remain available for integrations that prefer a hosted or embedded flow.

• Submit entity data (individual or business), bank account details, and beneficial ownership info directly via API. v2's expanded entity system supports individual and business entities, attachment to any account type, and international identities with country-specific tax IDs.
• Processing Account and Entity objects are created/updated in one call. KYC verification triggers automatically based on submitted data.
• You maintain full control over the onboarding UI and flow. No redirect required.
• Use cases: white-label platforms, custom onboarding UX, high-volume integrations, embedded in mobile apps.

Unified Intent API

A single Intent API that consolidates checkout links, payment forms, enrollment links, and payment method forms under a polymorphic Intent object. All user-initiated flows share a lifecycle, status model, and webhook events, replacing v1's mix of separate endpoints and object models for each surface.

• Every user-facing interaction is represented as an Intent with a consistent shape.
• Shared lifecycle states (pending, completed, cancelled, expired) across all intent types.
• Unified webhook events for tracking intent status changes, regardless of the surface that initiated them.
• Use cases: simpler integrations across multiple Payload surfaces, consistent tracking and reporting, less code to maintain when supporting several user flows.

Digital Wires

A programmable same-day, good-funds payment flow that replicates the behavior of a traditional wire in an API-driven integration. Traditional wires must be bank-initiated and can't be integrated into platforms directly; Digital Wires provide the same speed and finality guarantees through an abstraction that can be initiated via the API.

• Same-day settlement with good-funds finality, suitable for high-value or time-sensitive disbursements.
• Higher cost than ACH but faster and more reliable.
• Intelligent posting windows aligned to Eastern Time banking hours. Transactions submitted outside windows queue for the next available window.
• Use cases: large payout settlements, time-sensitive transfers, high-value transactions.

Check21 / Check Conversion

Accept digital checks and automatically convert them into the same unified transaction flow used by your fully digitized payments — same APIs, webhooks, and funding pipeline, with no separate handling for paper-originated funds.

• Customers upload images of checks (front/back) via Payment Form or API. Payload handles MICR parsing and conversion.
• Converted to ACH deposit within 1–2 business days.
• Use cases: wholesale payments, B2B invoicing, international remittances via check.

Manual Batching

Manually group and settle transactions in custom batches instead of automatic daily settlement.

• Define batch windows and trigger settlement via API. Useful for custom reconciliation workflows.
• Use cases: end-of-day settlement reporting, audit-heavy workflows, manual fund control requirements.

Net Fee Billing

Configure processing accounts to be billed for fees on a net basis — fees are deducted from settlements automatically rather than charged separately. Simplifies reconciliation and removes the need for separate fee invoicing flows.

• Use cases: platform fee collection, marketplace fee deduction, simplified reconciliation for high-volume processors.

Billing Statements via API

Programmatic access to billing statements for processing accounts. Pull statement data on demand for downstream accounting, reconciliation, or merchant-facing dashboards without scraping the dashboard or relying on emailed PDFs.

• Retrieve current and historical statements via the API.
• Use cases: white-label merchant dashboards, automated accounting integrations, custom reconciliation tooling.