KEY TAKEAWAYS
- Live: the card is active and chargeable.
- Dead: closed, lost or invalid — never retry.
- Unknown: no definitive answer; retry on another gateway.
- Error: the check failed technically — the card is still unclassified.
- Failed the card-checking pipeline checks say nothing about the card — fix the cause and retry.
- Unknown deserves one fallback pass, not infinite retries.
When you run a card through a checker, the gateway asks the issuer a question and returns the answer. That answer always falls into one of four states. Acting correctly on each state is the difference between a clean list and a pile of false conclusions.
LIVE
The issuer accepted the verification request and the card is considered active and chargeable. Live cards are the signal most workflows care about. Treat a live result as strong evidence, not an absolute guarantee: authorisation rules, balance and fraud controls can still decline a future charge.
DEAD
The issuer rejected the verification cleanly — the account is closed, reported lost or stolen, or the card number is invalid for that issuer. Dead results are stable: retrying the same card rarely changes the answer.
UNKNOWN
The request reached the issuer but no definitive answer came back, or the answer was ambiguous. Unknown usually means the issuer requires additional verification (such as 3-D Secure) or applies risk rules. Never treat unknown as dead — a meaningful share of unknown cards are actually live.
ERROR
The check never got a usable answer: the gateway timed out, the connection dropped, or the upstream provider returned a malformed response. Errors say nothing about the card. They are temporary and should be retried against another gateway or later in time.
Why classifications are not always identical between gateways
Different processors map issuer responses differently. One gateway may label a "do not honour" response as dead while another calls it unknown. If a card matters, verify it on a second gateway and compare. Our gateway selection guide explains how to choose and combine providers.
How to act on results
- Live: proceed, but keep a second risk signal for high-value charges.
- Dead: retire the card from your list; do not retry indefinitely.
- Unknown: park it for a retry on a different gateway.
- Error: retry later; the card is still unclassified.
If errors dominate a run, the problem is the checker or the network, not the cards. The error reduction guide covers the usual causes.
Under the hood, a check travels from the platform through a configured gateway to a provider that speaks to issuer networks, then back with a classified answer stored against your account. Each layer contributes something: the platform handles input, billing and history; the gateway defines format and price; the provider reaches the issuer; the issuer gives the actual answer.
That chain explains why results vary by route and why errors are not dead cards. A timeout on the provider leg means no answer was received, not that the card failed — which is why the platform releases the charge on errors and encourages a fallback pass for unknowns.
Key points about the card-checking pipeline
- Input → gateway → provider → issuer → classification
- Each layer can affect outcome and cost
- Errors happen on the technical leg; dead is an issuer verdict
- History stores one auditable row per check
Inside the card-checking pipeline: 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. Checks are routed through providers rather than card networks directly, so the same card can behave differently on different routes. Write it down; the card-checking pipeline workflows live and die on small consistencies.
Dead means the account is closed, blocked or invalid. It is a final answer for the current state of the card and should never be retried blindly. Error means the check itself failed technically: a timeout, a provider fault or malformed input. No classification was produced, and no charge applies. 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. It is a small rule that changes how the card-checking pipeline behaves at scale.
Running the card-checking pipeline well: the operating steps
Run one primary gateway with a fallback route. When the primary degrades, re-run only the unclassified remainder on the fallback. Decide how each outcome is handled before the run starts; a triage plan written after the results arrive is usually just a spreadsheet. Size batches to the provider ceiling. Past that line, extra concurrency converts into timeouts rather than throughput. Validate checksums and expiry dates before any paid request; the free browser tools exist precisely so malformed rows never reach a provider. That single habit separates routine the card-checking pipeline from expensive the card-checking pipeline.
Reading the card-checking pipeline results honestly
Classified rate is the share of cards that produce a definitive answer; it is the first number to compare when switching gateways. Two metrics describe any run: how many cards classify, and how long the pass takes. Everything else is commentary. Errors are free by design: no classification means no charge, so retrying after fixing the cause costs nothing but effort. A result is only as fresh as its timestamp. High-value decisions should use checks that ran close to the moment of the decision. That single habit separates routine the card-checking pipeline from expensive the card-checking pipeline.
Scaling the card-checking pipeline without surprises
Schedule recurring checks ahead of the decisions they inform, not after them. Budget verification against the cost of failure, not against zero; the comparison is what makes spend defensible. Keep one primary gateway and one fallback, and switch on evidence — error spikes and classified-rate drops — rather than on price alone. Document the route, the batch policy and the retry rules next to each production run; six months later that note is the diagnosis. It sounds obvious until a real run tests it.
Boundaries of the card-checking pipeline
A check does not move money, does not create a charge and does not touch the cardholder's credit file. Results describe the account, never the person; they should inform routing and risk decisions, not identity decisions. Operators remain responsible for the legal basis on which they hold and process card data. In the card-checking pipeline work, that is the difference between a signal and a guess.
Paying for the card-checking pipeline: the honest math
Funding is prepaid in BTC and LTC; deposits credit automatically once confirmed, and checks draw from the balance per classified result. 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. Top up before long runs; an interrupted run is the most avoidable kind of waste. That distinction is what keeps the card-checking pipeline decisions clean.
Handling keys and data in the card-checking pipeline
Log identifiers and outcomes, not card numbers. Debugging almost never requires a PAN. 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. The dashboard shows the key once and lets you rotate it at will; rotation is cheap, leaks are not. It sounds obvious until a real run tests it.
Benchmarks and distribution for the card-checking pipeline
Latency percentiles matter more than averages: the p90 and p99 tell you what a slow run actually feels like. When the classified rate moves, the cause is usually a route or provider change rather than the underlying cards. Aggregate numbers describe populations, not individual cards. Use them to size timeouts and retry budgets, never to judge one account. The reference BIN table covers hundreds of thousands of issuer ranges, and it is deliberately separate from account-status data: one describes issuers, the other describes cards. It is a small rule that changes how the card-checking pipeline behaves at scale.