KEY TAKEAWAYS
- Throughput ≈ concurrency × 3600 ÷ latency, capped per gateway.
- Past the ceiling, more concurrency means more timeouts.
- Size time budgets with p95, not median.
- Deduplicate and stream to maximize useful work.
- A 50-card pilot removes most hourly checking throughput surprises for cents.
- Every hourly checking throughput result class should map to a defined workflow action.
There is no single answer: throughput is arithmetic (concurrency × 3600 ÷ latency) bounded by the gateway's ceiling. The good news is you can estimate it precisely.
The formula
If checks run in parallel and each takes L seconds, hourly throughput ≈ concurrency × 3600 ÷ L, until the provider starts timing out. A 5-second median with 20 in flight is roughly 14,400/hour.
The ceiling
Every gateway has a maximum; past it, extra concurrency converts into timeouts instead of throughput. Rolling concurrency windows keep load near the safe maximum — see throughput planning.
Planning table
Our live benchmarks feed a per-concurrency table on the throughput page — check it before sizing large runs.
Practical planning
Deduplicate first, check a sample to measure current latency, estimate with p95 (not median), and stream results so work can start immediately.
The ceiling is set by the provider and your configured concurrency, not by the web interface. Each gateway exposes chunk size and parallel chunks, and those limits exist because providers tolerate a specific parallel load before they begin timing out requests. The safe answer is the recommended configuration, not the maximum the form accepts.
For planning, measure your own classified rate on a pilot batch, multiply by achieved concurrency, and subtract a margin for unknowns and retries. The throughput page walks through that math with live platform numbers.
Key points about hourly checking throughput
- Throughput ≈ achieved concurrency × per-check time, minus retry overhead.
- Provider ceilings are per route; raising concurrency past them trades speed for errors.
- Pilot batches are the cheapest way to estimate hourly capacity.
- Schedule large audits off-peak when provider latency is most stable.
What each hourly checking throughput outcome commits you to
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 honest reading of unknown is "no answer yet". The card is neither good nor bad, and the remedy is a different route, not a repeat of the same one. Errors are free by design: no classification means no charge, so retrying after fixing the cause costs nothing but effort. Keep it in mind whenever hourly checking throughput results are reviewed.
Putting hourly checking throughput to work
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. Watch two numbers over time: the classified rate and the error rate. Together they explain almost every surprise in monthly spend. Validate checksums and expiry dates before any paid request; the free browser tools exist precisely so malformed rows never reach a provider. For recurring workloads, schedule the run before the moment the answer is needed — ahead of a billing cycle, a payout batch or an onboarding window. That distinction is what keeps hourly checking throughput decisions clean.
Using hourly checking throughput on the right side of the line
Verification is at its best when it is boring: a routine status step inside an existing, authorised process. High-value decisions deserve fresh checks; stale results drift as accounts change. When a proposed use cannot be explained to a compliance reviewer in one sentence, it is probably not a fit. The habit costs nothing and removes a recurring class of mistakes.
How hourly checking throughput actually works
The platform keeps one history row per request with status, cost and before/after balance, which makes the whole loop auditable at the individual check level. Error means the check itself failed technically: a timeout, a provider fault or malformed input. No classification was produced, and no charge applies. A verification answer reflects the issuer's view at the moment of the request; nothing about it changes the card, the account or the cardholder. Nothing in the check moves money: the request asks a question, the issuer answers, and the platform records one of four outcomes against your account. It sounds obvious until a real run tests it.
What aggregate data says about hourly checking throughput
Sample sizes matter. Small windows produce noisy percentages, which is why published aggregates carry minimum thresholds. 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. That distinction is what keeps hourly checking throughput decisions clean.
Keeping hourly checking throughput predictable
Keep one primary gateway and one fallback, and switch on evidence — error spikes and classified-rate drops — rather than on price alone. Schedule recurring checks ahead of the decisions they inform, not after them. Alert on classified-rate drops, not just on errors; silent degradation is the expensive kind. Treat provider outages as routing problems: switch routes, recover the unclassified remainder, keep the answers you already paid for. That single habit separates routine hourly checking throughput from expensive hourly checking throughput.
Where hourly checking throughput goes wrong
Re-checking live cards during hourly checking throughput spends balance without changing any decision. Chasing every unknown in hourly checking throughput with unlimited retries costs more than classifying the rest of the list. Running hourly checking throughput without a written triage rule turns a clean batch into manual archaeology.
- Treating an error as a dead card in hourly checking throughput throws away cards that were never classified, and errors are the cheapest outcomes to recover.
- Skipping format validation before hourly checking throughput turns simple input mistakes into provider rejects that look like card problems.
- Letting duplicates through the input during hourly checking throughput pays twice for the same answer.
- Using BIN reference data as account status in hourly checking throughput confuses two different questions and produces confident, wrong decisions.
Using hourly checking throughput on the right side of the line
Results describe the account, never the person; they should inform routing and risk decisions, not identity decisions. High-value decisions deserve fresh checks; stale results drift as accounts change. Verification is a signal, not a guarantee: a live result does not promise that a later charge will be approved. That distinction is what keeps hourly checking throughput decisions clean.