How Push-to-Card (P2C) Works
Push-to-Card routes funds over existing card network infrastructure, treating the card as a receiving account rather than a payment source. The originating platform connects to a P2C-capable processor, which in turn submits the transaction to Visa Direct or Mastercard Send for delivery to the cardholder's issuing bank. Understanding this flow helps merchants and developers design reliable payout systems.
Initiate the payout request
BIN eligibility check
Transaction submitted to card network
Issuer credits the account
Settlement between parties
PCI Scope Note
Why Push-to-Card (P2C) Matters
Speed expectations have shifted dramatically across every payment vertical. Consumers and gig workers who once accepted next-day ACH now expect earnings access within minutes, and platforms that cannot deliver it face churn. Push-to-card has emerged as the primary infrastructure layer for instant payout use cases globally.
Three data points illustrate the scale of this shift. First, Visa Direct processed over 8.2 billion transactions in fiscal year 2024, representing roughly 45% year-over-year growth — a signal that card-push volume is still accelerating, not plateauing. Second, a 2023 industry survey found that 78% of gig workers ranked "speed of payment" as the top factor in choosing which platform to work on, above base pay rates. Third, the US Federal Reserve's own research shows that more than 60% of consumers living paycheck-to-paycheck would pay a fee for same-day access to wages — a market P2C directly addresses.
For merchants and platforms, the business case is equally clear: faster payouts reduce support tickets, increase supplier and contractor retention, and open the door to premium instant-payout products that generate fee revenue. The marginal cost of a P2C transaction (typically under $1) is often well below the cost of a single chargeback or a support call about a missing payment.
Push-to-Card (P2C) vs. Bank Payout (ACH/SEPA)
Both P2C and bank payout transfer value from a platform to a recipient, but the rails, speed, and recipient experience differ substantially. Choosing between them depends on use case, geography, and how much recipient friction you can tolerate.
| Attribute | Push-to-Card (P2C) | Bank Payout (ACH/SEPA) |
|---|---|---|
| Settlement speed | Seconds to 30 minutes | 1–3 business days (standard) |
| Recipient identifier | Card number (PAN) | IBAN or routing + account number |
| Reversibility | Generally irrevocable once credited | Reversible for a window (ACH returns) |
| Global reach | Strong in US, EU; BIN-dependent elsewhere | Very broad, but slow in cross-border |
| Typical fee | $0.25–$1.50 per transaction | $0.20–$0.75 (ACH) / varies (SEPA) |
| Card-free recipients | Not supported | Supported (bank account only) |
| Best for | Instant disbursement, gig payouts, gaming | Payroll, bulk B2B payments, low urgency |
Complementary, not competing
Types of Push-to-Card (P2C)
Not all P2C implementations are identical. The network, geography, and recipient card type create meaningful operational differences. Understanding the variants helps teams select the right integration path.
Visa Direct is the most widely deployed P2C rail globally, covering debit and eligible prepaid cards issued by Visa. It offers the broadest issuer coverage in the US and strong EU reach. Visa Direct supports both domestic and cross-border push transactions.
Mastercard Send provides equivalent functionality for Mastercard-network debit and prepaid cards. In certain markets — particularly parts of Europe and Latin America — Mastercard Send may have better issuer coverage than Visa Direct, making dual-rail support valuable for international platforms.
Domestic card-push schemes exist in several markets independent of Visa/Mastercard. RuPay in India, UnionPay in China, and various real-time national schemes support card-push mechanics through local infrastructure. These are relevant for platforms operating in those specific geographies.
Prepaid card push is a specialised variant where the recipient holds a platform-issued or partner prepaid card. This gives the platform full control over the receiving instrument and is common in earned wage access and corporate expense card programmes.
Best Practices
Executing P2C payouts reliably at scale requires discipline on both the merchant operations side and the technical integration side. Cutting corners on either creates settlement failures, compliance exposure, and poor recipient experience.
For Merchants
Run pre-payout KYC and fraud checks before every disbursement. Because P2C transactions are largely irrevocable, there is no ACH return window to fall back on. Invest in recipient verification upfront rather than trying to recover funds after the fact.
Communicate payout status in real time. Recipients on real-time payments rails expect immediate confirmation. Integrate webhook-driven status updates into your app or notification system so recipients know funds are incoming within seconds of initiation.
Monitor BIN acceptance rates by market. A card that works today may be re-categorized by its issuer and become push-ineligible. Track per-BIN success rates in your analytics and alert on drops — a sudden decline often signals an issuer policy change rather than a recipient problem.
For Developers
Implement idempotency keys on every payout API call. Network timeouts in P2C integrations can cause ambiguous states where you do not know if the payout was submitted. An idempotency key ensures retrying the call does not double-pay the recipient.
Use network tokenization instead of raw PANs wherever your processor supports it. Tokens reduce PCI DSS scope, survive card reissues (the token stays valid even when the physical card is replaced), and are the direction card networks are pushing the industry.
Build a fallback rail. When a card fails the BIN eligibility check or a payout is declined, automatically offer the recipient an ACH or SEPA alternative rather than surfacing a raw error. This keeps disbursement success rates high without requiring manual intervention.
Handle currency conversion explicitly. Cross-border P2C requires declaring the settlement currency. Leaving currency handling implicit leads to FX surprises for the recipient or unexpected conversion fees on your end.
Common Mistakes
Skipping BIN validation before submission. Sending a push transaction to a non-eligible card wastes API calls, creates error handling overhead, and degrades recipient trust. Always validate BIN eligibility as part of the pre-flight check, not after a failed submission.
Assuming P2C means instant in every market. Visa Direct and Mastercard Send quote a 30-minute SLA, but real-world speed depends on the issuer. Some issuers in emerging markets post funds only during business hours or with a delay. Communicate conservative ETAs to recipients rather than promising "instant" unconditionally.
Ignoring daily velocity limits. Card networks and issuing banks impose per-card daily receipt limits for P2C transactions (commonly in the range of $10,000–$25,000 per day in the US). Platforms paying out large sums — insurance settlements, large gig earnings — need to account for these limits or split payouts across cards and days.
Treating P2C as a wire replacement for B2B. P2C is optimised for consumer disbursement to personal debit cards. Using it as a B2B disbursement channel for vendor payments or large invoices misaligns the tool with the use case and runs into the same per-card limits noted above.
Underinvesting in reconciliation. Because P2C settles to the cardholder in near-real-time but interbank settlement is T+1 or T+2, your books can show an apparent timing mismatch. Build a reconciliation layer that distinguishes cardholder credit time from interbank settlement time to avoid phantom discrepancies in treasury reporting.
Push-to-Card (P2C) and Tagada
Tagada is a payment orchestration platform that routes and manages payouts across multiple processors and rails from a single integration. For platforms that need P2C alongside ACH, SEPA, and other payout methods, Tagada handles the routing logic, fallback sequencing, and provider selection automatically — so engineering teams build one integration rather than maintaining separate connections to each P2C provider and bank-transfer processor.