Credit Card Test Patterns for Payment Sandboxes

Answer first: the pattern that works for payment testing is a Luhn-valid, sandbox-only card number issued by your gateway or processor, paired with fixed expiry, CVV, and postal values that trigger known outcomes. Stripe's long-published 4242 4242 4242 4242 is the common Visa example. Live card numbers, live CVV values, and production endpoints do not belong in a test plan. The criteria used here are Luhn validity, coverage of decline and authentication cases, and PCI-safe handling of sensitive authentication data.

more on this topic

Know what a test pattern actually is

A test pattern is a number that passes the same structural checks a real card passes, so your validation, routing, and error handling run the same code path they will run in production. That means a correct issuer identification prefix, a correct length for the brand, and a passing Luhn check digit. It does not mean the number is chargeable.

credit card test pattern

Two families of patterns cover almost every need. The first is the set your gateway publishes and wires to specific simulated results. The second is a number you generate yourself and keep inside a documented test range. Both are safe when they never leave a sandbox.

Credit Card Testing Methods Guide

The Luhn check and the numbering structure

The Luhn algorithm, also called the mod 10 check, is the arithmetic test most issuers and gateways apply before a request goes any further. Digits are doubled from the right, results above nine are reduced by nine, and the total must be divisible by ten. If you hand-build numbers for a test suite, compute the check digit rather than guessing it, otherwise your happy-path test fails at the first gate.

credit card test patterns

ISO/IEC 7812 defines the leading digits that identify the issuer and brand, which is why a sixteen-digit string starting with 4 behaves like a Visa in your own form validation. Match the prefix and length to the brand you are simulating, or your test proves nothing about your brand detection logic.

Option A: gateway-published test cards

Stripe, Adyen, Braintree, and similar processors document fixed numbers plus the exact expiry, CVV, and postal codes that produce approvals, specific decline codes, and authentication challenges. Using them is the fastest route to coverage of issuer declines and 3-D Secure flows.

• Pros: known outputs, documented decline codes, full coverage of authentication and fraud rules, no guesswork about issuer responses.
• Cons: tied to one processor, not portable if you switch or add a second gateway, and the lists change as processors add scenarios.

Use it when you are integrating or re-certifying against a single processor and need to exercise declines, step-up authentication, and network timeouts.

Option B: generated numbers inside a test range

You can build your own fixtures by choosing a prefix reserved for testing, such as the 4242 pattern family that processors widely accept in sandbox mode, and computing the Luhn digit. Store the fixtures in a seed file so every environment uses the same inputs.

• Pros: portable across processors, easy to version, easy to generate hundreds of rows for load and regression runs.
• Cons: no guaranteed decline behavior, and a self-made number can accidentally collide with a real issued range if you pick prefixes carelessly.

Use it when you are testing your own validation, formatting, tokenization, or database schema and do not need issuer-style responses.

Test matrix worth running every release

1. Approval with a valid brand, correct length, and correct check digit.
2. Luhn failure, which must be rejected before any network call.
3. Wrong length for the detected brand.
4. Expired card and a card expiring in the current month.
5. Soft decline and hard decline, checked separately so retry logic does not loop forever.
6. Authentication challenge, both the pass and the abandon path.
7. Duplicate submission with the same idempotency key.
8. Timeout and retry, confirming you do not double-charge.

Handling CVV and other sensitive authentication data

The CVV, printed on the card and never stored, is sensitive authentication data under PCI DSS. Once an authorization completes, it must not be retained in any form, including logs, test databases, and analytics events. Test environments are not exempt. If your sandbox captures a CVV field, mask it on ingest and confirm your log scrubbers drop it. Where possible, use your processor's hosted fields or tokenization so the value never touches your servers at all.

Common mistakes

Copying a live number into a staging database, running a test suite against production, reusing one fixture for every brand, and assuming a passing Luhn check means an approval are the four errors that show up most often in payment integrations. Fix the fixture set and the environment boundary, and the rest of the test plan gets shorter.