References

Beginner-friendly references for web development, with live, editable examples.

The JavaScript BigInt object

Object JavaScript All modern browsers Updated
Quick answer

A BigInt is a primitive for integers too large for the regular Number type to hold safely (beyond about 9 quadrillion). Write one with an n suffix — 9007199254740993n — or with BigInt(value). You can't mix BigInt and Number in arithmetic without converting one.

Overview

BigInt exists because the normal Number type can only represent integers exactly up to Number.MAX_SAFE_INTEGER (about 9 quadrillion, or 253−1). Beyond that, numbers lose precision — 9007199254740993 quietly becomes ...992. BigInt handles arbitrarily large integers with full precision, which matters for big IDs (like database or Twitter/X snowflake IDs), high-precision timestamps, and cryptography.

You create one in two ways: a numeric literal with an n suffix (123n, 9007199254740993n), or the BigInt() function (BigInt("123"), BigInt(123)). Arithmetic works as you'd expect — 10n * 10n is 100n — and the result is always a BigInt.

The big rule: you can't mix BigInt and Number in the same operation. 1n + 1 throws a TypeError. Convert explicitly first — 1n + BigInt(1) or Number(1n) + 1 — choosing whether you want a BigInt or Number result. Also note BigInt is integer-only (no decimals; 5n / 2n is 2n), JSON.stringify() can't serialize it (convert to a string first), and typeof a BigInt is "bigint". For everyday numbers, stick with Number.

Syntax

const big = 9007199254740993n;   // n suffix
const also = BigInt("123");      // from a string

10n * 10n        // 100n
typeof 10n       // "bigint"
1n + BigInt(1)   // 2n  (can't mix with Number directly)

Example

Live example 
<pre id="out" style="font:15px ui-monospace,monospace"></pre>
<script>
  const unsafe = 9007199254740993;   // Number loses precision
  const safe = 9007199254740993n;    // BigInt keeps it

  document.getElementById('out').textContent =
    'Number: ' + unsafe + '\n' +
    'BigInt: ' + safe + '\n' +
    '2n ** 64n = ' + (2n ** 64n);
</script>

Best practices

  • Use BigInt only when integers exceed Number.MAX_SAFE_INTEGER — for ordinary numbers, use Number.
  • Never mix BigInt and Number in one operation — convert one with BigInt() or Number() first.
  • Remember BigInt is integer-only — there are no fractional BigInts.
  • Convert to a string before JSON.stringify(), which can't serialize BigInt.

Frequently asked questions

What is a BigInt in JavaScript?
A primitive type for integers larger than the Number type can safely represent. Create one with an n suffix (123n) or BigInt(value).
Why can't I add a BigInt and a Number?
Mixing them throws a TypeError to avoid silent precision loss. Convert one first: 1n + BigInt(1) or Number(1n) + 1.
When should I use BigInt?
For very large integer IDs, high-precision counters and cryptography — anywhere values exceed about 9 quadrillion. For normal numbers, use Number.
Can BigInt have decimals?
No. It's integer-only, so 5n / 2n is 2n (the fractional part is dropped).
Array Boolean