Embed payments. Keep the revenue. Skip the compliance hell.
Stripe takes 30% of your payments margin and 100% of your customer data. Xray does the inverse. We give you the full payment-facilitator stack — onboarding, KYC, settlement, payouts, 1099-K — under your brand, on your domain, with revenue share you actually understand. Plus the things Stripe still doesn't do well: smart routing, multi-processor orchestration, and a unified data layer across every transaction you process.
Built for: Software companies that want to own the payments inside their product — without spending two years and $30M building a payment-facilitator stack from scratch.
One platform. Four capabilities you'd otherwise stitch together.
Most ISVs end up with Stripe for payments, a CRM bolted on, a 1099 service, and an analytics layer they built themselves. Xray brings PFaaS, payment orchestration, data orchestration, and the platform fabric under one API.
Payment Facilitator as a Service
Be Stripe inside your software. Without being Stripe.
A traditional PayFac registration takes 18 months and ~$30M in reserves. Xray PFaaS gives you the same merchant-of-record economics, the same instant-onboard UX, and the same brand control — without any of the regulatory lift. We hold the PayFac license; you hold the customer relationship.
- ✓Instant merchant onboarding API — submerchant lives in seconds
- ✓KYC + KYB + risk underwriting handled by us, branded as you
- ✓Settlement and payouts under your name, on your schedule
- ✓Automated 1099-K reporting per submerchant
- ✓Custom pricing per submerchant via your config
- ✓Chargeback management with native API
Payment Orchestration
Multiple processors. One API. Smart routing.
Most platforms run on one processor and pray for uptime. Xray's orchestration layer routes every transaction across our 5+ sponsor banks based on card brand, geography, MCC, and real-time success rates. Cheaper on cost; higher on auth; redundant on failover. Your code talks to one API; we handle the rest.
- ✓Smart routing by card brand (Visa/MC to Processor A, Amex to B, Debit to C)
- ✓Cascade retry on soft declines — automatic re-route, transparent to your code
- ✓99.99% uptime SLA via multi-processor redundancy
- ✓Cost optimization — every transaction routes to the cheapest viable path
- ✓Real-time auth-rate analytics per processor
- ✓A/B test routing rules; switch on the fly
Data Orchestration
Every processor. One unified data layer.
You can't build a great product on top of five inconsistent processor APIs. Xray normalizes every transaction, dispute, payout, and webhook across every processor into a single canonical data model. One reporting API. One reconciliation flow. One source of truth for finance, support, BI, and your customer-facing dashboards.
- ✓Single normalized API across every processor
- ✓Unified webhook delivery (one payload shape, one signing secret)
- ✓Real-time reporting endpoint for finance + BI
- ✓Reconciliation across multiple settlement schedules
- ✓Standardized chargeback + dispute event schema
- ✓Datawarehouse export to Snowflake, BigQuery, S3
The Platform
Everything else you need — vault, recurring, vault, OLA, signing.
PFaaS, orchestration, and data are the pillars. The Platform is everything between them: tokenized customer vault, recurring billing with smart-retry and account-updater, hosted onboarding pages, embedded checkout, DocuSign-style document signing, encrypted file storage, webhook replay, fraud rules engine. All under one API.
- ✓Customer Vault — tokenize cards once, reuse forever
- ✓Recurring billing — smart-retry, Account Updater, dunning
- ✓Hosted onboarding pages — embed or iframe, all branded
- ✓Embedded checkout — drop-in form with Apple Pay / Google Pay
- ✓Document signing (FTA, MPA, custom) with audit trail
- ✓Webhook replay + delivery retry with exponential backoff
- ✓Fraud rules engine — velocity, BIN, geo, device fingerprint
- ✓Sandbox in 5 minutes — fully fungible with production API
Everything you need to build a real isvs book.
PFaaS — embedded payments without the lift
Submerchant onboarding, KYC, settlement, 1099-K — all under your brand. We hold the PayFac license; you hold the customer.
Smart routing across 5 processors
Visa goes to the cheapest. Amex goes to the best Amex rate. Debit goes to debit-optimized. Your code stays the same.
Unified data layer across every processor
One reporting API, one webhook payload, one schema. No more "we support 4 processors but each one has its own quirks."
Sandbox to production in 5 minutes
Full feature parity between sandbox and prod. Test card flows, recurring, disputes, payouts — all without contracts.
PCI-DSS Level 1 from the API down
Compliance burden stays on us. Your platform never touches a raw card number. Tokenization at the network edge.
Revenue share you can model
Buy rates in writing. Pick markup. Pass through, surcharge, mark up — your call. Daily payout to your treasury account.
6 SDKs · REST · Webhooks · GraphQL
Node, Python, Ruby, PHP, Go, .NET. Plus a REST API for everything else and webhook events for every state change.
White-label everywhere
Hosted pages, transaction emails, dispute communication, 1099 statements — all branded as YOUR product, not as Xray.
Sandbox API in 5 minutes.
Sign up, get a sandbox key, and you're charging tokenized test cards in under five minutes. No contracts, no credit card, no sales call. Full feature parity between sandbox and production.
- 200+ test cards for every flow (success, decline, 3DS challenge, dispute)
- Full webhook delivery in sandbox with replay
- Identical API surface — flip the key, ship to production
- SDKs for Node, Python, Ruby, PHP, Go, .NET
// Charge a card via the Xray Payment API
// Same code works against sandbox and production
// — only the API key changes.
import { XrayClient } from "@xraypayment/node";
const xray = new XrayClient({ apiKey: process.env.XRAY_KEY });
const charge = await xray.charges.create({
amount: 4980, // cents
currency: "USD",
source: "tok_visa_4242", // tokenized via Xray.js
submerchant: "sm_acme_co",
metadata: {
invoice_id: "INV-2026-118"
}
});
console.log(charge.status); // "succeeded"
console.log(charge.routed_via); // "processor_b" (smart routing decided)
console.log(charge.cost); // your buy rate + interchange
5 steps from interest to revenue.
Get sandbox keys (5 min)
Sign up, get a sandbox API key, hit our /api/v1/charges endpoint, see a tokenized auth come back. No contract.
Build your integration
Pick from 6 SDKs or use the REST API directly. Test against the sandbox with our 200+ test cards (success, decline, 3DS challenge, etc.).
Sign PFaaS agreement
We map your business model: marketplace, SaaS platform, embedded checkout. Buy rates, revenue share, payout schedule in writing.
Underwriting + production keys
Standard PFaaS underwriting (~5 business days for most platforms). Production keys issued; you go live on your schedule.
Onboard your customers
Use our hosted onboarding (embedded form) or our API. Each customer is a submerchant; lives in seconds; ready to charge.
What you'll actually earn.
No "trust us." Here's the math in writing.
Built for isvs, included free.
Side-by-side with what you're probably running today.
| Xray Payment | Typical gateway / Stripe | |
|---|---|---|
| Revenue economics | You set markup; daily T+1 payout | Stripe: 2.9% + $0.30 forever; their margin |
| Smart routing | Auto-route across 5+ processors | Single processor; pray for uptime |
| Branded onboarding | Fully white-labeled | "Powered by Stripe" footer on every page |
| Sandbox parity | Identical to prod, free forever | Stripe parity OK; others lacking |
| Compliance lift | PCI-DSS handled at platform | You buy your own audit |
| Custom pricing | Per-submerchant config | Flat rate or "enterprise pricing" |
| Data ownership | Your data; export anytime | Their data with API access |
| Multi-processor | Native orchestration | Manual integration with each |
| 1099-K reporting | Auto-generated per submerchant | You build it |
The reasons partners stay.
We built the platform from the database up to be multi-processor. There's no "primary" processor with bolt-ons — every transaction is orchestrated equally.
We hold the PayFac license, the PCI-DSS Level 1 audit, the BAA pool, the bank sponsorship. You ship product; we handle the cards.
Six SDKs and a sandbox API that's a literal mirror of production. You can integrate in an afternoon and test for as long as you want before signing anything.
Buy rates are in writing. Your revenue share is what you decide to take above them. No surprises, no "discretionary adjustments," no per-quarter renegotiation.
ISVs questions, straight answers.
How is PFaaS different from Stripe Connect?
Stripe Connect makes you a marketplace under Stripe — Stripe is the merchant of record, "powered by Stripe" sits in every UI, and the rate is locked. Xray PFaaS makes YOU the brand. Your platform name is on the statements, the 1099-Ks, and the dispute communication. Your buy rates are negotiated; your markup is yours.
What's the typical integration time?
A solo dev can hit our sandbox in 5 minutes and ship a basic integration in a weekend. Full PFaaS onboarding (with your custom flows, branded UIs, and underwriting) usually takes 4-8 weeks.
Do I have to use orchestration?
No — you can pin to a single processor if you want predictability. Most ISVs flip orchestration on after they hit ~$1M/month volume and start optimizing cost.
What about international cards?
Yes — multi-currency processing via our gateway with smart routing across acquirers. Higher fraud rules apply on international.
Can I migrate from Stripe?
Yes — we coordinate a card-vault migration (Stripe supports this for verified businesses). Customers see no change; tokens are remapped under our vault.
What's the SLA?
99.99% on the orchestration API; 99.95% on hosted pages. Real-time status at status.xraypayment.com.
Do I need to be a registered PayFac?
No — that's the whole point of PFaaS. We hold the registration. You hold the customer.
How are chargebacks handled?
Chargebacks against your submerchants come into a unified API endpoint. You can auto-route them to your support queue, auto-respond with evidence templates, or pass them through to the submerchant.