Airbnb's payments problem is structurally different from a typical e-commerce checkout. Every transaction has at least two sides that need to be settled correctly — a guest who pays, and a host who gets paid, often in a different currency, sometimes with the cost of a single trip split across several guests, and always with a delay: hosts are generally paid out only after a guest actually checks in, not the moment a booking is made. Multiply that by hundreds of countries, dozens of currencies, and a long tail of local payment methods guests expect to use, and payments stops being an integration problem and becomes a core piece of distributed infrastructure.
Two-sided settlement, not a single charge
A typical e-commerce payment is a single event: charge the card, done. Airbnb's payment has to represent a booking as a transaction with distinct obligations — what the guest owes, what the host is entitled to receive, and Airbnb's own service fee — that don't settle at the same time or necessarily in the same currency. Split payments compound this further: a group of guests splitting the cost of a trip means a single booking can involve multiple payment instruments, each of which can independently succeed, fail, or need to be retried, without leaving the booking in an inconsistent state. Getting this right requires treating money movement as a set of durable, auditable records rather than an implicit side effect of an API call, since any ambiguity about who owes what, in which currency, is a real financial and trust problem, not just a display bug.
Currency and localization at the core, not bolted on
Supporting a truly global marketplace meant Airbnb couldn't treat currency conversion as a display-layer formatting concern. Prices need to be shown to a guest in their local currency, charged through a payment method common in their country, while the host's payout is calculated and delivered in their own local currency and preferred method — bank transfer, a regional e-wallet, or other rails that vary widely by geography. This required deep integration with multiple payment service providers across regions rather than a single global processor, since no single provider offers universal coverage with acceptable reliability and cost everywhere Airbnb operates.
Idempotency and reconciliation as first-class concerns
Because payment operations can be retried after timeouts or partial failures, Airbnb's platform had to guarantee that retrying a payout or a charge never double-processes it — a foundational idempotency guarantee that gets harder to preserve as the system is decomposed into more services, each potentially retrying calls to the others. On top of that, reconciliation — continuously verifying that Airbnb's internal ledger agrees with what payment providers and banks actually report — has to run as an ongoing process, not a one-time check, since discrepancies at global scale are a matter of when, not if, and catching them quickly is what keeps host trust intact.
What broke when they scaled
Payments fail in ways CRUD apps do not. A card authorization can succeed at the processor and time out on the way back. A payout file can be accepted by a bank and later returned. A guest can pay in BRL while the host expects KRW, and the FX rate that was quoted at checkout is not the rate at capture. Airbnb's two-sided, delayed-settlement model means those events are separated by days, so "retry the request" without a ledger key is how you double-pay a host.
At global scale the long tail dominates. Each local rail (wallets, boleto, regional transfers) is a state machine, a reconciliation report, and KYC — not a config flag. Split stays multiply state: a partial capture cannot leave the booking undefined. Ledgers and idempotency keys are the structures that survive that explosion.
A smaller-team version of the same idea
Model money as append-only entries with a unique idempotency key per intent (charge, capture, refund, payout). Store amounts in the currency of the instrument, plus a booked FX rate if you quote one. Reconcile daily against one processor before you add a second. Delay host payout until the event you actually mean (check-in, not checkout) even if that is a cron plus a status flag. Add a second PSP only when a corridor's authorization rate or payout reliability is a measured problem.
What you can borrow
- Model a transaction as multiple parties' obligations from the start, even if you only have one payer today — retrofitting split payments or multi-party settlement onto a single-charge model is far more painful than designing for it early.
- Treat idempotency as a payments-system requirement, not an optimization — any retry logic anywhere in the call path can otherwise silently double-charge or double-pay.
- Localize payment methods and payout currencies deliberately per region rather than assuming one processor's global coverage is good enough; acceptance rates and reliability vary a lot by country.
- Build reconciliation as a continuously running system, not a manual audit — catching a mismatch between your ledger and a provider's records days late is much more expensive than catching it within hours.