Choose your integration
Pick the integration model that fits your stack, timeline, and PCI appetite.
Tonder offers several integration models to accept deposits and send withdrawals. The model you pick shapes your time to market, engineering effort, checkout UX, and compliance scope — so it's worth getting right up front.
This guide helps you understand:
- The five ways to accept payments — Hosted Checkout, Full SDK, Lite SDK, the recommended Hybrid model, and API Direct (S2S).
- Withdrawals via API Direct — pairs with any deposit model.
- The key differences — setup time, customization, and PCI scope — so you can match a model to your needs.
- Real-world use cases for platforms like iGaming and e-commerce.
Compare the models
| Model | Deposits | Withdrawals | Setup | Customization | PCI cert |
|---|---|---|---|---|---|
| Hosted Checkout | Yes | No | ~1 day | Low | No |
| Full SDK | Yes | No | 2–3 days | Medium | No |
| Lite SDK | Yes | No | 5–7 days | High | No |
| Hybrid ★ | Yes | Yes | 1–2 wks | High | No |
| API Direct (S2S) | Yes | Yes | 1–2 wks | Complete | Yes (L1) |
Withdrawals are always server-to-server via API Direct (operation_type: "withdrawal" on
/process/) — they pair with any deposit model and never run through Hosted Checkout or the SDK.
New to accepting SPEI in Mexico? Use Frictionless SPEI — available with API Direct or Hybrid.
Before you choose
Answer these questions first — they map almost one-to-one onto the models below:
- Do you have developers to write integration code? No → Hosted Checkout.
- How fast do you need to launch? Days → Hosted or Full SDK. Weeks are fine → Hybrid or API Direct.
- Is a fully custom, branded checkout UI essential? Yes → Lite SDK (or a Hybrid built on it).
- Do you hold a valid PCI DSS certification? Yes → API Direct unlocks full control. No → stay on Hosted / SDK / Hybrid.
- Do you need to send payouts, not just accept deposits? Yes → any model + Withdrawals via API Direct.
- Do you want API control over non-card methods (SPEI, OXXO, wallets) without PCI scope? Yes → Hybrid.
Pick your model
No PCI team, fastest launch
→ Hosted Checkout. Zero card data touches you.
Custom UI, no PCI scope
→ SDK (Lite for full design control, Full for speed).
Deposits + payouts
→ Hybrid. The recommended model for iGaming & fintech. (Refunds are full, once per transaction, cards only.)
Detailed decision guide
Prefer to walk the full tree? Expand the scenario that matches your goal.
Integration models at a glance
A one-line snapshot of each. Follow the link for the full implementation guide.
| Model | What it is | Best for | Setup · PCI |
|---|---|---|---|
| Hosted Checkout | A Tonder-hosted payment page reached by redirect. No card data touches you. | Launching fast with no front-end work. | ~1 day · No PCI |
| Full SDK | A pre-built checkout UI embedded in your web or mobile app. | An embedded, styleable checkout without building forms. | 2–3 days · No PCI |
| Lite SDK | You build the UI; the SDK tokenizes card data in the background. | Full brand and UX control with no PCI scope. | 5–7 days · No PCI |
| Hybrid ★ | SDK/Hosted for cards + API Direct for other methods and withdrawals. | Deposits and payouts, plus API control of non-card methods — without PCI. | 1–2 wks · No PCI |
| API Direct (S2S) | Full server-to-server control over every money flow. | Maximum control when you're already PCI certified. | 1–2 wks · PCI L1 |
Hybrid is the recommended pick for deposits + payouts without PCI. It has three valid combinations (A / B / C) depending on your card UI — see the Hybrid overview for the combinations table, refund rules, and dual-webhook handling.
Sending payouts (API Direct)
Payouts are sent via API Direct (operation_type: "withdrawal" on the unified /process/
endpoint) — player payouts, seller settlements, affiliate commissions. It's independent of how you
accept deposits, so you can add it to an existing checkout without changing it.
- With Hosted Checkout / Full SDK / Lite SDK: add Withdrawals via API Direct (≈1–2 days).
- With Hybrid or API Direct: withdrawals use the same API Direct leg you already have — no separate implementation needed.
Feature support across models
| Feature | Hosted Checkout | Full SDK | Lite SDK | Hybrid ★ | API Direct |
|---|---|---|---|---|---|
| Card payments | Yes | Yes | Yes | Yes (SDK/Hosted leg) | Yes |
| Bank transfers (SPEI) | Yes | Yes | Yes | Yes (API Direct leg) | Yes |
| Cash (OXXO / vouchers) | Yes | Yes | Yes | Yes (API Direct leg) | Yes |
| Digital wallets (MercadoPago) | Yes | Yes | Yes | Yes (API Direct leg) | Yes |
| Withdrawals | API Direct | API Direct | API Direct | Yes (API Direct leg) | Yes |
| 3D Secure | Automatic | Automatic | Automatic | Automatic (cards) | Manual control |
| Tokenization | Automatic | Automatic | Automatic | Automatic (cards) | You implement |
| Saved cards | Yes | Yes | Yes | Yes | You implement |
| Webhooks | Long format | Long format | Long · Short (2.0) | Dual (SDK + API Direct) | Short format |
| Test environment | Yes | Yes | Yes | Yes | Yes |
Every model supports all payment methods. See Payment methods for the full catalog and the Webhooks model for the format each integration emits.
Use cases
An iGaming platform accepts deposits across many methods and sends player payouts, but isn't PCI certified and wants programmatic control over SPEI transfers and cash.
Recommended: Hybrid ★
- Cards: Full SDK for an embedded card form (Tonder handles PCI).
- Other methods: API Direct for SPEI, OXXO Pay, MercadoPago — full control, no PCI required.
- Withdrawals: API Direct for automated player payouts.
- Setup: ~1–2 weeks.
Trade-off: you handle dual webhooks and different request/response shapes for cards vs. other methods.
A platform needs secure deposits to start the user journey. Pick by speed vs. control:
- Hosted Checkout — fastest, no code (~1 day).
- Full SDK / Lite SDK — embedded checkout; Full is quicker with a standard UI, Lite gives complete customization.
- API Direct — maximum control, but requires PCI certification.
All of these support deposits and card refunds.
To pay out winnings or settlements:
- API Direct — pairs with any deposit model, server-to-server (~1–2 days).
- API Direct — one integration for deposits, withdrawals, and refunds, if you're PCI certified.
For an online store the core need is accepting payments securely:
- Hosted Checkout — fastest launch, no code.
- Full SDK / Lite SDK — embedded checkout; Lite for strong branding and full UX control.
- API Direct (S2S) — full backend control, requires PCI certification.
Authentication, at a glance
- Public key — process payments, APMs, Hosted sessions. Header:
Authorization: Token {public_key}. - Secret key — card tokenization only, server-side. Never ship it to the client.
Never expose your secret key in client code, public repos, or logs. Rotate immediately if leaked.
| Service | Sandbox | Production |
|---|---|---|
| API Direct (S2S) | https://stage.tonder.io/api/v1/ | https://app.tonder.io/api/v1/ |
| Hosted Checkout | https://api-stage.tonder.io/checkout/v1/ | https://api.tonder.io/checkout/v1/ |
| Card tokenization | https://token-sandbox.tonder.io/ | https://token.tonder.io/ |
| Raw card data (PCI L1) | https://process-sandbox.tonder.io/ | https://process.tonder.io/ |
| Dashboard | https://dashboard-stage.tonder.io/ | https://dashboard.tonder.io/ |