How to check an NRIC or FIN number
The short answer: the last character of a Singapore NRIC or FIN is a weighted checksum of the seven digits before it. If that letter agrees with the arithmetic, the number is internally consistent; if it does not, at least one character in it is wrong.
- Write the number as nine unbroken characters. One prefix letter, seven digits, one check letter, for example
S1234567D. Spaces and dashes are not part of the number, and lowercase is fine because the input is upper-cased for you. - Paste it into the Single Checker field. The verdict appears as you type. There is no button to press and no request to wait for.
- Read the result. Valid means the check letter is the one the Mod-11 arithmetic produces for those seven digits and that prefix. Checksum Mismatch means it is not, and the checker tells you the letter it expected instead.
- Open the math breakdown under the verdict. It shows every digit multiplied by its weight, the series offset added to the total, and the remainder that selects the check letter, so you can audit the answer instead of taking it on trust.
What a match and a mismatch each mean matters as much as the verdict. A match means the arithmetic is self-consistent: the number is correctly formed, and that is what catches typos, transposed digits and numbers that were invented. A mismatch means the number is wrong somewhere — a mistyped digit, a swapped pair, or a number that was never valid in the first place.
Know what this cannot do. This is a format and arithmetic check, not a database lookup. Nothing here asks the Identity Card Office whether a number exists, whether it has been cancelled, or whose it is. Read a valid checksum as proof that a number is well formed, never as proof that a person is who they say they are.
How Singapore's NRIC checksum works
Every NRIC and FIN has the same shape: a prefix letter, seven digits, and a final check letter. The check letter is neither random nor looked up anywhere. It is what the other eight characters produce when you run one specific calculation, and you can do it with a pencil.
Step 1 — multiply each digit by its weight
The weights are fixed but position-dependent, applied from left to right across the seven digits:
W = [2, 7, 6, 5, 4, 3, 2]
The first digit counts double, the second counts seven times, and the weighting falls away towards the right. This is why S1234567D and S7654321F are both valid while sharing the same seven digits: only the order differs, so the weighting rather than the digit set decides the answer.
Step 2 — add the series offset
The prefix letter contributes a constant to the total before the modulus is taken:
- S — citizen or permanent resident, pre-2000: offset 0
- T — citizen or permanent resident, 2000 onwards: offset 4
- F — foreigner identification number, pre-2000: offset 0
- G — foreigner identification number, 2000 onwards: offset 4
- M — foreigner identification number, M series: offset 3
Step 3 — take the remainder modulo 11
Divide the total by 11 and keep what is left over. The remainder is always one of 0 to 10:
R = ((d1×2 + d2×7 + d3×6 + d4×5 + d5×4 + d6×3 + d7×2) + offset) mod 11
Step 4 — look the remainder up
The remainder selects a letter from the table belonging to that series. S and T share one table, F and G share another, and M uses a third that differs in exactly one place.
| Remainder | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
|---|---|---|---|---|---|---|---|---|---|---|---|
| S and T | J | Z | I | H | G | F | E | D | C | B | A |
| F and G | X | W | U | T | R | Q | P | N | M | L | K |
| M | X | W | U | T | R | Q | P | N | J | L | K |
Working it through by hand
- Multiply and add:
1×2 + 2×7 + 3×6 + 4×5 + 5×4 + 6×3 + 7×2 = 2 + 14 + 18 + 20 + 20 + 18 + 14 = 106. - Add the S offset of 0. The total stays 106.
- Take the remainder:
106 mod 11 = 7, because 11 × 9 = 99 and 106 − 99 = 7. The prefix and the digits are now consumed. - Look it up: remainder 7 in the S and T row is D, which is the letter
S1234567Dalready ends in. Valid.
Three numbers run through the same six steps, to show what each input changes:
| Number | Weighted sum | Offset | Total | mod 11 | Expected | Verdict |
|---|---|---|---|---|---|---|
S1234567D | 106 | +0 | 106 | 7 | D | matches D |
T1234567J | 106 | +4 | 110 | 0 | J | matches J |
S1234567A | 106 | +0 | 106 | 7 | D | given A, expected D |
F1234567N | 106 | +0 | 106 | 7 | N | matches N |
The second and fourth rows are the interesting ones. S1234567D, T1234567J and F1234567N share all seven digits and the same weighted sum of 106; only the prefix changes what happens next. Change one digit, one letter, or the prefix, and the expected check letter moves with it — which is exactly why a checksum mismatch usually means a typo rather than a fake.
The one property worth remembering: the check letter is a pure function of the prefix and the seven digits. Nothing else feeds into it — not the holder's name, not the issue date, not whether the number is still active. That is what makes it useful for catching errors, and what limits it to catching errors.
What the reverse solver does
A smudged card, a redacted photocopy, a number with one character covered up. Because the check letter is deterministic, a missing character can be recovered from the arithmetic rather than guessed at. Enter a nine-character pattern into the Reverse Solver, using ?, * or _ for anything unknown — all three are read as ?.
The solver does not attempt clever algebra. It enumerates: for every unknown digit position it tries 0 to 9, computes the weighted sum, takes the remainder, and looks up the resulting check letter. A candidate survives only if that letter matches the one you supplied. With a single unknown digit exactly one candidate survives, because 11 is prime and every weight is coprime with it, so the equation w × d = C (mod 11) has at most one solution in the digit range.
? works in three places, not only in the digits. Put it at the end and the solver reports every completion with a valid checksum. Put it first and it tries every enabled series — S, T, F, G and M — against the rest of the number, and shows which prefixes are actually consistent with the check letter you have.
Worked example. In S12?4567D the unknown digit is the third, which carries weight 6. The six known digits sum to 88, and since 88 is exactly 8 × 11 it disappears when you work modulo 11, leaving 6d congruent to 7. Because 6 × 2 = 12, which leaves remainder 1, multiplying both sides by 2 gives d congruent to 3. The one answer is S1234567D.
Where it stops being unique
More than one unknown digit is not always uniquely solvable, and the solver will not pretend otherwise. The checksum gives you one equation; two unknown digits put two variables in it, and several pairs can satisfy it. T0?2345?A comes back with nine candidates and S??34567D comes back with nine as well — every one of them arithmetically valid, and nothing on this page can tell them apart. What you get in that case is a candidate list, not an answer, and judging it is your job.
- At least three known digits. Patterns with more than four unknown digits are refused outright, so the search stays bounded instead of dumping a million candidates into the page.
- Exactly nine characters. The pattern has to be the whole number — prefix, seven digits, check letter — or the solver returns nothing.
- The count is always shown. The heading above the results reports how many solutions were found, so a single answer is visibly different from a pile of candidates.
- Deduction is arithmetic, not verification. Solving a pattern tells you which characters could have produced that checksum. It tells you nothing about who the number belongs to, or whether it was ever issued.
NRIC vs FIN: what changes
The prefix letter is not decoration. It selects the offset added before the modulus and the table that turns the remainder into a letter, and it is the only thing separating citizens and permanent residents from foreign identification numbers.
| Prefix | Who it identifies | Offset | Letter table | What the prefix encodes |
|---|---|---|---|---|
| S | Singapore citizen or permanent resident | 0 | S and T | Born before 1 January 2000 |
| T | Singapore citizen or permanent resident | 4 | S and T | Born on or after 1 January 2000 |
| F | Foreigner identification number (FIN) | 0 | F and G | Issued before 1 January 2000 |
| G | Foreigner identification number (FIN) | 4 | F and G | Issued on or after 1 January 2000 |
| M | Foreigner identification number, M series | 3 | M | The newer foreign pass series |
Three things follow from that table. The weights never change: all five series use [2, 7, 6, 5, 4, 3, 2], so the only differences between series are the offset and the lookup table. S and T share a table while F and G share a different one, which is why a check letter valid for a citizen can never be valid for a foreign identification number. And M differs from F and G at exactly one remainder: the two tables agree everywhere except remainder 9, where F and G give M and the M series gives J.
The first two digits are normally a year within the era the prefix implies. The checker reports that era next to every result, so S and F resolve to "before 1 January 2000" while T and G resolve to "on or after 1 January 2000" — which is why the same seven digits give a different answer under each prefix.
Developer test data, and the privacy argument
The Generator tab produces synthetic NRIC and FIN numbers that are arithmetically valid. Choose a series or let it pick at random, optionally pin the first two digits to a year, and every number comes back with a correctly computed check letter. You can produce up to 1,000 in a batch, copy them straight out, or download the set as .txt or .json.
The reason to reach for those instead of a real number is worth stating plainly. Seeding a test suite, a fixture file or a screenshot with an actual NRIC means copying somebody's identity document into a repository and, usually, a company wiki. Synthetic numbers exercise exactly the same validation path — same format, same weights, same Mod-11 check — without the person attached to it, without the consent problem, and without the data-protection question that follows a real fixture around forever.
Nothing you type is sent anywhere. Validation is a JavaScript function running inside this page: it reads the string you entered, does the arithmetic, and writes the result back to the screen. There is no upload, no server call and no log. Every other NRIC validator you will find posts the number to a backend, which means it exists on someone else's machine, in their access logs, for as long as their retention policy runs. Here it stays in the tab, and the only thing this page writes to your browser is your three settings toggles.
That is a deliberate choice, and it has a running cost: hosting and bandwidth come out of pocket, and keeping these tools private is precisely what that cost buys. If this page saved you from handing an identity number to a stranger's server, contributing on the support page helps pay for the next one.
NRIC validation guide
Validating well is a skill of its own — the worked arithmetic, the unreadable-character solver, and what a passing checksum cannot prove.
Frequently asked questions
Is this NRIC checker safe to use with a real identity number?
Yes. Validation runs entirely as JavaScript inside your browser, so the number is never uploaded, logged, or sent to a server, and the only thing this page stores in your browser is your three settings toggles.
It is still worth treating identity numbers as sensitive information: clear them from your clipboard history before you paste, and do not leave one sitting in the field on a shared machine.
Does a matching checksum prove the NRIC number is real?
No. A matching checksum only proves that the final letter is the correct arithmetic result for the other eight characters, which makes it an excellent typo detector.
Nothing here queries an Identity Card Office record, so it cannot tell you whether a number was ever issued, whether it has since been cancelled, or whose it is.
Why do the same seven digits give different NRICs?
Because the prefix letter feeds into the arithmetic. T and G add 4 to the weighted sum before the modulus is taken and M adds 3, and each family of series converts the remainder into a letter with its own table.
That is why S1234567D, T1234567J and F1234567N can all share the digits 1234567 and all be correct.
Can I use the generated NRIC numbers in a test suite?
Yes, and that is what the generator is for. Pick a series, optionally pin the first two digits to a year, and you get checksum-valid synthetic numbers in batches of up to 1,000, ready to copy or download as text or JSON.
They run through the same validation code path as a real number without putting somebody's identity document into your repository.
How many NRIC numbers can I check at once?
The Bulk Auditor takes one number per line, or numbers separated by commas and spaces, and reports the total tested, how many passed, how many failed, and the passing rate.
You can then export the whole audit as a CSV report or just the valid numbers as a text file, and the entire run happens in the page.
What if two digits of the NRIC are smudged or unreadable?
The reverse solver returns every candidate that satisfies the checksum, which is often more than one. A single unknown digit is always uniquely solvable, because 11 is prime and every weight is coprime with it.
Two unknown digits give one equation with several solutions, so the tool lists all of them rather than presenting a single guess as if it were certain.