Credit Card Number Format: Length, Prefix and Check Digit

Card numbers look interchangeable at a glance, but their credit card number format is not one shape repeated — the length changes with the network, the leading digits carry meaning, and the final digit is arithmetic rather than allocation. Knowing how the pieces fit together is what lets you tell a well-formed number from a plausible-looking one, and it explains most of the strange validation behaviour you meet in checkout forms.

The sections below break the number into its parts, describe how to read a grouped number the way it is printed, and finish with the practical details that decide whether your input handling survives contact with real users.

The three parts of a card number

Every card number is a concatenation of three fields, written without separators when it is stored:

• The issuer prefix. Historically called the bank identification number and now referred to as the issuer identification number, this leading block tells the routing system which network the card belongs to and, in most cases, which institution issued it. It is not a fixed width; both shorter and longer forms are in use, and the length is registered rather than guessed.
• The account digits. This is the part the issuer assigns. Its only requirement is that it be unique within the issuer’s range. It is not a customer number you can decode, and two consecutive account digits carry no relationship to each other.
• The check digit. One digit computed from all the others with the Luhn algorithm. It exists to catch typing mistakes and nothing else.

Read together, the picture is simple: the front of the number says where the card came from, the middle is arbitrary allocation, and the end is a typo guard.

Why are card numbers different lengths?

Length was never standardised to a single value because card numbering grew out of several national and industry schemes that were later harmonised rather than rewritten. The international standard that governs the format sets an upper bound of nineteen digits and leaves the exact length to each network and product.

In practice you meet a small set of lengths. Sixteen digits is the most common and the one people picture when they hear the word card. Fifteen digits is standard for American Express. Thirteen and fourteen digit forms exist as well, largely in older or regional products, and some networks use a longer arrangement for particular card types.

The important consequence for validation is that a rule written as exactly sixteen digits is wrong. It rejects genuine cards, and it also refuses perfectly good test data. A correct rule accepts a range, checks the prefix against that network’s expectations, and only then runs the checksum.

What does the first digit tell you?

The leading digit is an industry marker rather than a network name, and the mapping is public. It narrows down what kind of issuer you are dealing with before the rest of the prefix identifies the specific programme.

The first digit alone never identifies a network. Card ranges live inside those segments: the number four belongs to the banking segment, and a range within it is associated with one network, while a different range in the same segment belongs to another. That is why brand detection needs more than one digit, and why a detector built on the first character alone will mislabel a surprising share of inputs.

How do you read a grouped card number?

On a card and in most interfaces the digits appear in groups, and the grouping follows the network rather than a universal rule. Four groups of four is the familiar arrangement for a sixteen-digit card; American Express is conventionally shown as four, six and five, matching its fifteen digits. Some interfaces separate the first group of six to make the issuer prefix visible, and others leave the number unbroken.

For a reader, the grouping is a memory aid. For a developer it is presentation only, and the distinction causes real bugs: an input that rejects a pasted number because the paste contained spaces is rejecting the format the card itself is printed in. Store digits, display groups, and convert between the two at the edges.

Formatting is not validation

It is tempting to treat a well-known shape as proof of authenticity. It is not. Any prefix can be combined with any middle digits, and a closing digit computed to match, so a string that looks exactly like a familiar card can be completely synthetic.

Everything in this article describes structure. It says nothing about whether an account exists, whether a card is active or whether a payment will be approved, because none of those questions can be answered by examining the digits. All numbers produced by the generator on this site sit in exactly that category: correctly shaped, never issued.

For developers: cleaning input without losing information

The uncomfortable truth about card number fields is that users type them in unpredictable ways. They paste from an email with spaces, they include a trailing character from a previous field, they type a hyphen where a space belongs. Cleaning that up is necessary; doing it carelessly is how valid input gets destroyed.

A workable sequence looks like this. Trim the ends. Remove the separator characters you intend to tolerate rather than every non-digit, so that a letter produces a clear error instead of being silently deleted. Keep the result as a string for its entire life, because a numeric type will drop a leading zero and change the meaning of the value. Compare the cleaned length against the network range for the detected prefix. Run the checksum last.

Then decide how you will display what you received. A field that reformats as the user types is pleasant on a desktop keyboard and can be actively hostile on a phone, where the caret jumps and backspace behaves unexpectedly. If you group digits while typing, test the case of correcting a mistake in the middle of the string, not only at the end.

Keep the failure messages separate as well. Too short, unsupported characters, unknown prefix and failed checksum are four different problems, and a form that reports all of them as “invalid card number” makes debugging slow for the user and for you.

Checking a number in the card tool

If you need a number of a specific shape — one network, one length, one prefix — the card number generator produces them without an account and lets you pick the network explicitly or leave the choice random. The completion mode is useful when you already hold part of a value and want the unknown digits filled consistently with the rest.

Two related pages go deeper. The network comparison lists the published ranges and the lengths that go with them, and the validation walkthrough turns the ordering advice above into a concrete sequence of checks.

Next steps

Audit one existing form against the order described here — length, then characters, then prefix, then checksum — and confirm that each failure produces its own message. Then generate a small set of numbers that deliberately spans more than one length, so the next person who edits the validation rule has something to test against.