Add, subtract, and multiply numbers with hundreds of digits — exact to the very last digit. Free, instant, and private.
Tip: commas and spaces are ignored, so you can paste numbers like 1,234,567,890. Decimals and negative numbers are supported.
Most calculators quietly give up once numbers get big. Type a 30-digit number into your phone, multiply it by another, and the answer comes back rounded, shortened, or flat-out wrong — and nothing warns you that the digits you are reading are fiction. The Big Number Calculator above exists for exactly that gap: it adds, subtracts, and multiplies integers and decimals of essentially any length with arbitrary precision, so every single digit of the result is exact. Paste in two 200-digit numbers, hit Calculate, and you get the true product, the exact digit count, and scientific notation for good measure. It runs entirely in your browser, it is free, and nothing you type ever leaves your device.
Using the calculator takes four quick steps. First, type or paste your first number into the “First number” box. There is no practical length limit — 20 digits, 200 digits, or 2,000 digits all work. Commas and spaces are ignored, so you can paste formatted numbers like 1,234,567,890 directly. Second, choose the operation: Add, Subtract, or Multiply. Third, enter the second number. Negative numbers are allowed (just put a minus sign in front), and decimals are supported too, so values like -12345.6789 work fine. Fourth, press Calculate. The exact result appears in the blue result panel, broken across lines so even a 500-digit answer stays readable, together with the total digit count and — for very large answers — the scientific-notation form.
The Reset button restores the two built-in example numbers, which multiply to a 54-digit product — a handy demo of what ordinary calculators cannot do. One thing to know: this calculator intentionally covers only addition, subtraction, and multiplication. Those three operations are always exact in arbitrary-precision arithmetic. Division is a different story, because most divisions produce infinitely repeating decimals that must be rounded somewhere, so it is left out to keep every answer on this page provably exact.
The calculator on your phone and the one built into your spreadsheet both store numbers the same way: as double-precision floating point, the IEEE 754 standard. A double gives you 64 bits of storage, which translates to roughly 15 to 17 significant decimal digits. That is plenty for grocery bills and mortgage math, but it is a hard ceiling. The largest integer a double can represent exactly is 253, which equals 9,007,199,254,740,991 — about 9 quadrillion, or 16 digits. Go one digit beyond that and the hardware starts rounding to the nearest representable value, silently.
Try it yourself: open any standard calculator and compute 9,007,199,254,740,991 + 1, then + 1 again. Many will show the same answer twice, because the two consecutive integers map to the same floating-point value. The error is invisible — the display shows a confident-looking number with no warning that the last digits are invented. Multiplication makes it worse: multiplying two 20-digit numbers needs up to 40 digits of precision, so a double can be wrong by an astronomically large amount while looking perfectly normal.
Decimals suffer too, for a subtler reason. Binary floating point cannot represent most decimal fractions exactly — just as 1/3 cannot be written exactly in decimal. That is why 0.1 + 0.2 famously equals 0.30000000000000004 in JavaScript and most programming languages. The Big Number Calculator sidesteps all of this by never using floating point at all: it stores numbers as exact sequences of digits and does the arithmetic the way you learned it on paper, one column at a time, with no rounding at any step.
Arbitrary-precision arithmetic means the number of digits is limited only by available memory, not by a fixed-size register. Instead of cramming a number into 64 bits, the calculator keeps the full digit string — “123456789123456789123456789” stays exactly that, all 27 digits — and performs operations digit by digit, carrying exactly as you would by hand. Modern browsers provide this natively through BigInt, a built-in integer type with no upper bound, which is what powers the widget above.
Decimals are handled by a classic scaling trick. A number like 12.345 is stored as the integer 12345 together with a note that the decimal point sits 3 places from the right. To add 12.345 and 7.8, the calculator first aligns the scales — 7.8 becomes 7800 thousandths — then adds the integers 12345 + 7800 = 20145 and puts the point back 3 places to get 20.145. Multiplication is even simpler: 12.345 × 7.8 becomes 12345 × 780 = 9,629,100 with a combined scale of 4, giving 96.29100, and trailing zeros are trimmed to 96.291. Because every step is integer math on exact digits, the answer is exact — 0.1 + 0.2 genuinely equals 0.3 here, not 0.30000000000000004.
There is one honest limitation worth stating plainly: arbitrary precision is not infinite speed. Multiplying two 10,000-digit numbers is instant, but million-digit monsters will make any browser pause. For the sizes humans actually encounter — cryptography keys with a few hundred digits, combinatorics with dozens of digits, financial figures with under twenty — the calculation finishes before you lift your finger from the button.
Addition: align decimal places, then add digit by digit with carries — result = a + b
Subtraction: align decimal places, then subtract digit by digit with borrows — result = a − b
Multiplication: multiply as whole numbers, then place the decimal point at the combined number of decimal places — result = a × b
The “align decimal places” step is the whole secret. Before adding or subtracting, both numbers are scaled to the same number of fractional digits (the larger of the two counts) by appending zeros, exactly as you would line up decimal points on paper. For multiplication, the decimal places are counted, not aligned: if the first number has 3 decimal places and the second has 2, the product gets 5. No step ever discards a digit, which is why the results are exact rather than approximate.
Example 1 — multiplication beyond floating point. Multiply 123,456,789,123,456,789 by 987,654,321,987,654,321. Each input has 18 digits, so the product can have up to 36. A phone calculator would round this hopelessly. The exact product is 121,932,631,356,500,531,347,203,169,112,635,269 — 35 digits, every one of them correct. You can verify the digit count the calculator reports matches: 35.
Example 2 — the classic decimal trap. Add 0.1 and 0.2. In JavaScript, Python, and Excel, this yields 0.30000000000000004 because neither 0.1 nor 0.2 is exactly representable in binary floating point. Here, 0.1 is stored as integer 1 with scale 1, 0.2 as integer 2 with scale 1; the integer sum is 3 at scale 1, formatted back to exactly 0.3. If you are summing money, tax, or scientific measurements, that difference between “almost right” and “exactly right” is the entire point.
Example 3 — powers of two. Computing 2100 by repeated doubling gives 1,267,650,600,228,229,401,496,703,205,376 — a 31-digit number. Standard doubles top out at about 16 exact digits, so they can only approximate this. Repeated multiplication in the calculator above builds it exactly: enter 2, multiply by 2 a hundred times (or multiply large powers together — 250 × 250), and the last digits …05376 are as trustworthy as the first.
Example 4 — subtraction with borrowing across many digits. Subtract 123,456,789,123,456,789,123,456,789 from 987,654,321,987,654,321,987,654,321. The exact difference is 864,197,532,864,197,532,864,197,532. Notice the pleasing pattern — each 3-digit group subtracts cleanly — which is a nice self-check that the column arithmetic behaved. Floating-point subtraction of numbers this size would typically be off by hundreds of millions in the trailing digits.
Cryptography. The RSA encryption protecting your bank login typically uses a 2,048-bit key — the product of two secret prime numbers, each around 300 digits long, multiplied into a public modulus of about 617 digits. Key generation is literally big-number multiplication, and verifying a signature means raising huge numbers to huge powers. Security researchers and students routinely need exact arithmetic on numbers this size, which is precisely what arbitrary-precision tools are for.
Combinatorics and probability. A standard deck has 52 cards, and the number of possible shuffles is 52 factorial — 80,658,175,170,943,878,571,660,636,856,403,669,752,895,054,408,832,778,240,000,000,000,000, a 68-digit number. Every time a deck is shuffled, the ordering is very likely one no human has ever seen, and you can only state that number exactly with big-number arithmetic. Lottery odds, password-strength estimates, and genetics calculations live in the same territory.
The chessboard rice legend. Place one grain of rice on the first chess square, two on the second, four on the third, doubling each time. The total for all 64 squares is 264 − 1 = 18,446,744,073,709,551,615 — about 18.4 quintillion grains, more rice than humanity has ever grown. It is the classic demonstration of exponential growth, and it sits just past the 253 floating-point cliff, so ordinary calculators fumble its final digits.
Astronomy and physics. Physicists estimate roughly 1080 atoms in the observable universe — a 1 followed by 80 zeros. Distances in meters between galaxies, the number of possible chess positions, and particle counts in cosmology all demand exact handling of enormous magnitudes. Even national finance qualifies: debts and money supplies measured in trillions (13+ digits) already push against the edges of what spreadsheets track exactly.
Trusting a rounded display. The most common error is copying a big-number result from a standard calculator and treating the trailing digits as real. If your phone shows 1.2193263135650053e+53, everything after the first 16 digits is decoration. Always ask whether the tool you used guarantees exactness before quoting digits.
Forgetting that 0.1 + 0.2 is not 0.3 in floating point. Anyone adding money in JavaScript, Python floats, or Excel has met this. If your totals are off by a fraction of a cent in the 15th decimal place, you do not have a math problem — you have a representation problem. Exact decimal arithmetic, like this calculator uses, is the fix.
Mixing up digit count and magnitude. A 54-digit product is not “54 times bigger” than a one-digit number — it is roughly 1053 times bigger. When the result panel reports the digit count, read it as the number’s order of magnitude, which is the useful way to grasp numbers too large to visualize.
Pasting formatted numbers with stray characters. This calculator ignores commas and spaces, but currency symbols, letters, or a second decimal point will be rejected. Strip “$”, “USD”, and similar decorations before pasting, and use a single leading minus for negatives rather than parentheses.
Expecting division. This tool deliberately omits division because most divisions of big numbers produce infinitely repeating decimals. If you need a quotient, compute it elsewhere with an explicit rounding rule — and remember that the rounding rule, not the arithmetic, is then what determines your answer.
Scientific Calculator — full scientific functions for everyday-sized numbers.
Exponent Calculator — raise any base to any power, the fast route to huge numbers.
Binary Hex Calculator — convert between binary, decimal, and hexadecimal.
Percentage Calculator — exact percent calculations without float surprises.
Matrix Calculator — matrix addition, subtraction, and multiplication.
Ratio Calculator — simplify and scale ratios of any size.
Log Calculator — logarithms for taming enormous magnitudes.
Statistics Calculator — descriptive statistics on your datasets.
This page hosts the Sigma Calculator Big Number Calculator, a free browser-based tool that adds, subtracts, and multiplies integers and decimals of arbitrary length with exact arbitrary-precision arithmetic (BigInt with decimal scaling), reporting the exact result, digit count, and scientific notation. The page explains why IEEE 754 double-precision floating point fails beyond 2^53 (9,007,199,254,740,991), describes the digit-string scaling method, shows fully worked examples (including 123456789123456789 × 987654321987654321 = 121932631356500531347203169112635269 and the 0.1 + 0.2 decimal case), covers real-world uses in cryptography, combinatorics, and astronomy, lists common mistakes, and answers eight frequently asked questions. Canonical URL: https://sigmacalculator.net/math-calculators/big-number-calculator/
Cite this page as: Big Number Calculator. Sigma Calculator. https://sigmacalculator.net/math-calculators/big-number-calculator/
Last updated: October 9, 2026