KEY TAKEAWAYS
- Compare latency (p95), classification quality and throughput ceiling.
- Run the same sample list through each candidate and measure.
- Configure fallback so provider blips become answers.
- Spread load across gateways instead of past one ceiling.
- Errors in gateway selection are free: no classification, no charge.
- Watch classified rate and latency trends, not just the balance.
A "gateway" here means the upstream service that actually asks the issuer. Different gateways have different strengths, and picking one blindly is how runs end up slow or inaccurate.
The three axes that matter
- Latency: how fast a typical check returns. This drives perceived speed more than anything else.
- Classification quality: how many cards get a definitive live/dead answer versus unknown. A fast gateway that calls everything unknown is useless.
- Throughput ceiling: how many requests it tolerates before timing out. Past the ceiling, added concurrency reduces results.
Measure before choosing
Run the same sample list through each candidate gateway and record: median time to first result, total time, live/dead/unknown split, error rate and cost per classified card. Differences of 20+ percentage points in unknown rate between gateways are common — and invisible until you measure.
Use fallback, not blind retries
The strongest configuration is a primary gateway with a fallback: when the primary errors or times out, the same card is attempted on the fallback and only then classified. This converts provider blips into answers instead of errors. Configure fallback per gateway in the admin, including its own timeout.
Respect the ceiling
Every provider has a concurrency limit. Two gateways at half capacity each often outperform one gateway doubled up. If you need more throughput, spread load across gateways rather than pushing one past its limit — the admin capacity recommendation is a safe starting point.
Tune per gateway
Per-gateway settings exist because one size does not fit all: timeout, batch size, chunk size, parallel chunks and fallback are all configurable. When you change them, change one at a time and compare against a fixed sample. Our error reduction guide describes the diagnostic signals to watch.
Keep the long view
Gateways change over time. Review your per-gateway stats monthly; a provider that was best last quarter may have degraded. Your checker directory shows what is currently available.
Gateway choice is a small experiment, not a loyalty decision. Route A may classify more of your card population while route B is faster and cheaper on the ones it resolves. The only comparison that matters is cost per classified card on a representative pilot, measured on your own list.
Start with the recommended gateway for your use case, run a 50-card pilot, note the classified rate, latency and error mix, then repeat on a candidate fallback. Keep both configured; the fallback earns its place the first time the primary has a bad hour.
Key points about gateway selection
- Compare on cost per classified card, not list price
- Pilot with your own card population
- Keep a configured fallback route
- Re-evaluate after provider changes or significant volume shifts
Inside gateway selection: what happens on a check
Rate limits, formats and latency all come from the provider side, which is why per-gateway configuration exists instead of one global setting. Behind the scenes, every check follows the same chain: your input, the gateway format, the provider connection, the issuer response and the classification you see. A check sends an authorization-shaped request through a provider to the issuer and classifies the reply into one of four states: live, dead, unknown or error. Live means the issuer answered and the account is active and chargeable at that moment; it is strong evidence, not a promise about a future charge. That distinction is what keeps gateway selection decisions clean.
Running gateway selection well: the operating steps
Start with a pilot of fifty cards. It surfaces format mismatches and routing surprises while the cost of being wrong is still measured in cents. Validate checksums and expiry dates before any paid request; the free browser tools exist precisely so malformed rows never reach a provider. Run one primary gateway with a fallback route. When the primary degrades, re-run only the unclassified remainder on the fallback. Log request identifiers and outcomes, never full card numbers. Debugging rarely needs a PAN, and storing one is a liability. It sounds obvious until a real run tests it.
Interpreting outcomes in gateway selection
The four result classes are a decision matrix, not a score: live proceeds, dead recovers, unknown gets one careful retry, error returns to the queue. Conflating outcomes is the most expensive habit in this area — an error treated as a dead card discards real inventory, and an unknown treated as live inflates confidence. A live answer is evidence about the account, not a guarantee about a specific future transaction; issuer rules can change between the check and the charge. A result is only as fresh as its timestamp. High-value decisions should use checks that ran close to the moment of the decision. The habit costs nothing and removes a recurring class of mistakes.
Running gateway selection as a process
Treat provider outages as routing problems: switch routes, recover the unclassified remainder, keep the answers you already paid for. Track cost per classified card rather than cost per request; it is the only metric that reflects retries and unknown rates. Reconcile spend monthly against classified results; the difference between the two numbers is where retries hide. Keep the API key server-side and regenerable; a leaked key is a billing incident as much as a security one. It is a small rule that changes how gateway selection behaves at scale.
What gateway selection cannot promise
Where a check is used inside a payment flow, it complements authorization rather than replacing it. Verification is a signal, not a guarantee: a live result does not promise that a later charge will be approved. Results describe the account, never the person; they should inform routing and risk decisions, not identity decisions. That single habit separates routine gateway selection from expensive gateway selection.
Paying for gateway selection: the honest math
Funding is prepaid in BTC and LTC; deposits credit automatically once confirmed, and checks draw from the balance per classified result. Top up before long runs; an interrupted run is the most avoidable kind of waste. Billing follows the classification: live and dead results are billed at the gateway price, while errors are free. The API returns the balance on every response, so integrations can meter themselves. That single habit separates routine gateway selection from expensive gateway selection.
Handling keys and data in gateway selection
Log identifiers and outcomes, not card numbers. Debugging almost never requires a PAN. The dashboard shows the key once and lets you rotate it at will; rotation is cheap, leaks are not. Encrypted transport and account-scoped access are defaults; nothing about the integration requires changing them. API keys are server-side secrets: they belong in environment configuration, never in URLs, logs or client bundles. That single habit separates routine gateway selection from expensive gateway selection.
What aggregate data says about gateway selection
The platform publishes outcome distributions and latency percentiles from real traffic, refreshed monthly, precisely so expectations can be calibrated against reality. Cost per classified card is the honest metric. A cheap-per-request route with a high failure rate is the most expensive option in practice. Trends beat snapshots: a classified rate that drifts over weeks says more than any single run's result. Sample sizes matter. Small windows produce noisy percentages, which is why published aggregates carry minimum thresholds. In gateway selection work, that is the difference between a signal and a guess.