PESEL Generator

Not a developer? If you’re looking to understand what PESEL is, how to get one, or how to decode an existing number, see our PESEL Checker & Decoder, a full guide to the Polish national identification number.

PESEL Format Specification

PESEL is Poland’s 11-digit national identification number ¹. For a full guide on what PESEL is, how to get one, and how it’s used in Poland, see our PESEL Checker.

The format is YYMMDDSSSGK:

No two people share a PESEL. Numbers are never reused after death ¹. The serial + gender digits allow up to 5,000 assignments per gender per day.

Century Encoding

The month field doubles as a century marker. An offset is added to the calendar month to encode which century the person was born in:

To decode: determine which range the month code falls in, subtract the offset, and you have the calendar month and century.

To encode (what this generator does): take the calendar month, add the offset for the target century, and write the result into positions 3–4.

In practice, you’ll only encounter the 1900s (01–12) and 2000s (21–32) ranges. This generator handles all five.

Checksum Algorithm

The 11th digit is a weighted modular checksum. The weights are fixed: 1, 3, 7, 9, 1, 3, 7, 9, 1, 3.

Steps:

1. Multiply each of the first 10 digits by its weight.
2. Sum the products.
3. Take the sum modulo 10.
4. Subtract from 10.
5. Take the result modulo 10. This is the check digit.

Worked example: 90080517352

Digits:   9  0  0  8  0  5  1  7  3  5
Weights:  1  3  7  9  1  3  7  9  1  3
Products: 9  0  0  72 0  15 7  63 3  15
Sum: 184
184 mod 10 = 4
10 - 4 = 6
6 mod 10 = 6

But the 11th digit is 2, not 6, so this example PESEL is invalid. If the check digit doesn’t match, the number was mistyped or fabricated. Every number this generator produces has a correct check digit.

JavaScript

function peselCheckDigit(digits) {
  const weights = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3];
  const sum = digits
    .slice(0, 10)
    .reduce((acc, d, i) => acc + d * weights[i], 0);
  return (10 - (sum % 10)) % 10;
}

function isValidPesel(pesel) {
  if (!/^\d{11}$/.test(pesel)) return false;
  const digits = [...pesel].map(Number);
  return digits[10] === peselCheckDigit(digits);
}

Python

def pesel_check_digit(digits: list[int]) -> int:
    weights = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3]
    total = sum(d * w for d, w in zip(digits[:10], weights))
    return (10 - total % 10) % 10

def is_valid_pesel(pesel: str) -> bool:
    if not pesel.isdigit() or len(pesel) != 11:
        return False
    digits = [int(d) for d in pesel]
    return digits[10] == pesel_check_digit(digits)

PHP

function isValidPesel(string $pesel): bool {
    if (!preg_match('/^\d{11}$/', $pesel)) return false;
    $weights = [1, 3, 7, 9, 1, 3, 7, 9, 1, 3];
    $digits = array_map('intval', str_split($pesel));
    $sum = 0;
    for ($i = 0; $i < 10; $i++) {
        $sum += $digits[$i] * $weights[$i];
    }
    $check = (10 - ($sum % 10)) % 10;
    return $digits[10] === $check;
}

Regex Patterns

Basic format check (11 digits, nothing else):

^\d{11}$

This matches any 11-digit string. It does NOT validate the checksum, date logic, or month encoding. Use it as a first-pass filter before running the checksum algorithm above.

Stricter structural pattern (valid date ranges, valid month codes):

^[0-9]{2}(0[1-9]|1[0-2]|2[1-9]|3[0-2]|4[1-9]|5[0-2]|6[1-9]|7[0-2]|8[1-9]|9[0-2])(0[1-9]|[12]\d|3[01])\d{5}$

This validates that positions 3–4 contain a legal month code (from any century range) and positions 5–6 contain a plausible day (01–31). It still doesn’t validate the checksum or catch impossible dates like February 30. For full validation, combine the regex with the checksum function above.

Why regex alone isn’t enough: A PESEL like 99023112345 passes both patterns: the month (02) is valid and the day (31) is within range. But February 31 doesn’t exist. And neither pattern checks whether digit 11 is the correct checksum. Always validate programmatically.

Edge Cases for Testing

If you’re building PESEL validation or processing, these are the cases that break naive implementations. Use the generator above to produce numbers matching each scenario, or use the examples below.

Post-2000 births. Month codes 21–32 trip up parsers that assume months are always 01–12. A PESEL starting with 052706 is July 6, 2005, not June with an invalid month. Make sure your date parser subtracts the century offset before interpreting the month.

Leap year dates. February 29 is valid in leap years but invalid in others. PESEL 000229xxxxx is valid (2000 was a leap year) but 010229xxxxx is not (2001 was not). Your validator should check actual calendar validity, not just range.

Century boundaries. 000121xxxxx means January 21, 1900 (month code 01, 1900s range). 002121xxxxx means January 21, 2000 (month code 21, 2000s range). Same year digits, different centuries. Test both.

Gender digit zero. Digit 10 = 0 means female (0 is even). Some implementations incorrectly treat 0 as “unset” or skip it. Zero is a valid even digit.

Check digit zero. When the modular calculation produces 10, the check digit is 0 (not 10). (10 - 0) % 10 = 0. Test this boundary.

Day boundaries. Day 01 and day 31 (where valid) are edge cases. Months with 28, 29, or 30 days should reject day 31. April, June, September, November have 30 days maximum.

PESEL vs. NIP vs. REGON

Poland uses three main identification numbers. If you’re building a system that handles Polish data, you may need to validate or generate all three.

All three use weighted checksum algorithms, but with different weight sequences. A valid PESEL is not a valid NIP and vice versa.

Frequently Asked Questions