πŸ‡ΈπŸ‡¬ 100% Free Forever • Zero Data Transmitted • No Account Needed

NRIC Validator & Reverse Solver

Fast, privacy-first Singapore NRIC & FIN verification with reverse unknown-digit deduction, full weighted-sum Mod-11 math audits, and compliant developer test data generation. Runs 100% in your browserβ€”no identity numbers ever leave your device.

Verify NRIC / FIN Checksum

Test any Singapore Citizen / PR (S, T) or Foreigner Pass / FIN (F, G, M) number. Real-time evaluation runs completely in your browser β€” zero network requests or logs.

Valid
Identity Series
-
Expected Checksum
-
Birth / Registration Era
-
Weights Dot Product
-
Digit Pos D1 D2 D3 D4 D5 D6 D7 Series Offset
Missing Digits Reverse Solver Mathematical Deduction

Have a partially redacted or smudged NRIC? Enter ?, *, or _ for unknown digits. Using modular inverse arithmetic mod 11, this engine calculates all mathematically valid candidates that produce the target checksum.

Solutions Found: 1
Bulk NRIC / FIN Batch Auditor

Audit thousands of NRICs simultaneously. Paste text, enter one per line, or drop a CSV. Instantly view validation metrics and export clean valid/invalid lists.

Compliant Synthetic NRIC Generator Test Data Only

Generate valid synthetic NRIC / FIN numbers for software testing, mock QA databases, and form validation benchmarking in compliance with privacy best practices.

Mathematical Specifications & Weights Architecture

Singapore NRIC and FIN algorithms utilize a weighted modulus-11 checksum. Each of the 7 central digits is multiplied by fixed prime-derived weights, offset by series bias, and mapped to specific check characters.

1. Weights Vector

The 7 numerical digits \(d_1, d_2, d_3, d_4, d_5, d_6, d_7\) are multiplied respectively by:

W = [2, 7, 6, 5, 4, 3, 2]

2. Series Offset Addition

An initial series offset \(O\) is added to the dot product sum:

  • S: Offset = 0
  • T: Offset = 4
  • F: Offset = 0
  • G: Offset = 4
  • M: Offset = 3
Remainder R = ( (d1×2 + d2×7 + d3×6 + d4×5 + d5×4 + d6×3 + d7×2) + Offset ) mod 11

3. Modulo 11 Remainder to Letter Map

Remainder 012345678910
S & T Map JZIHGFEDCBA
F & G Map XWUTRQPNMLK
M Map XWUTRQPNJLK

4. Why the Missing Digit Solver Is Exact

Because 11 is prime and every weight \(w \in \{2, 3, 4, 5, 6, 7\}\) is coprime with 11 (\(\gcd(w, 11) = 1\)), the linear congruence \(w \cdot d \equiv C \pmod{11}\) always has exactly one unique solution modulo 11. If that solution is between 0 and 9, the missing digit is uniquely determined. If it equals 10, no valid digit exists. Hence, an NRIC with 1 missing digit can never have ambiguous possibilities.

Engine Configuration & Developer Integration

Fine-tune verification rules, toggle strict series era validation, or copy ready-to-run code snippets for JavaScript, TypeScript, and Python.

Allow FIN M-Series Checksums
Enables M series support (offset 3, distinct check-table).
Auto-Uppercase Inputs
Automatically convert lower-case letters to standard uppercase.

Embeddable JavaScript / TypeScript Utility

nricValidator.js
export function validateNRIC(input) {
  if (!input || typeof input !== 'string') return false;
  const str = input.trim().toUpperCase();
  if (!/^[STFGM]\d{7}[A-Z]$/.test(str)) return false;

  const prefix = str[0];
  const digits = str.slice(1, 8);
  const checkChar = str[8];

  const weights = [2, 7, 6, 5, 4, 3, 2];
  let sum = (prefix === 'T' || prefix === 'G') ? 4 : (prefix === 'M' ? 3 : 0);
  for (let i = 0; i < 7; i++) {
    sum += parseInt(digits[i], 10) * weights[i];
  }

  const remainder = sum % 11;
  const stMap = ['J','Z','I','H','G','F','E','D','C','B','A'];
  const fgMap = ['X','W','U','T','R','Q','P','N','M','L','K'];
  const mMap  = ['X','W','U','T','R','Q','P','N','J','L','K'];

  const expected = (prefix === 'S' || prefix === 'T') 
    ? stMap[remainder] 
    : (prefix === 'M' ? mMap[remainder] : fgMap[remainder]);

  return checkChar === expected;
}

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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:

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 to check letter, by series family.
Remainder012345678910
S and TJZIHGFEDCBA
F and GXWUTRQPNMLK
MXWUTRQPNJLK

Working it through by hand

  1. 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.
  2. Add the S offset of 0. The total stays 106.
  3. Take the remainder: 106 mod 11 = 7, because 11 × 9 = 99 and 106 − 99 = 7. The prefix and the digits are now consumed.
  4. Look it up: remainder 7 in the S and T row is D, which is the letter S1234567D already ends in. Valid.

Three numbers run through the same six steps, to show what each input changes:

Worked examples. Only the final column differs, and that is the whole verdict.
NumberWeighted sumOffsetTotalmod 11ExpectedVerdict
S1234567D106+01067Dmatches D
T1234567J106+41100Jmatches J
S1234567A106+01067Dgiven A, expected D
F1234567N106+01067Nmatches 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.

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.

What each prefix letter means and how it changes the checksum.
PrefixWho it identifiesOffsetLetter tableWhat the prefix encodes
SSingapore citizen or permanent resident0S and TBorn before 1 January 2000
TSingapore citizen or permanent resident4S and TBorn on or after 1 January 2000
FForeigner identification number (FIN)0F and GIssued before 1 January 2000
GForeigner identification number (FIN)4F and GIssued on or after 1 January 2000
MForeigner identification number, M series3MThe 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.

One of the free, private tools on aczh.dev. Everything on this page is arithmetic in your browser: no account, no upload, and no NRIC or FIN number is ever transmitted anywhere. Last reviewed October 2026.