Convert TB to B

A terabyte is a trillion bytes. A drive sold as 1 TB is exactly that — the space that seems to go missing is a unit disagreement, not a defect.

A byte is eight bits, though that was not always fixed — early machines used six, seven or nine. The eight-bit byte won because it holds one character of text and divides neatly in half.

Going from terabytes to bytes moves the decimal point 12 places to the right and changes nothing else. There is no factor to remember and no rounding to decide: the digits stay in the same order and only their position changes.

1,234 TB is 1234000000000000 B — same digits, moved along. That is worth knowing because it is the one kind of conversion you can check at a glance: if the digits of the answer are not the digits you started with, something other than the conversion has happened to them.

Quotas, maximum object sizes, lifecycle thresholds, partition offsets, rate limits and disk-image declarations all tend to end at the same place: a field that accepts a number of bytes and nothing else. There is no suffix to get wrong and no unit to argue about, which sounds safer than it is — the safety was in the suffix, and removing it moves the whole risk onto whoever types the digits.

That is the argument for converting deliberately rather than reaching for a familiar-looking constant. A value pasted from somewhere else carries whichever definition its author used, and a value rounded to something tidy is a decision about capacity that was made by accident. Starting from the requirement in terabytes and writing out the exact integer keeps both the number and the intention visible.

One terabyte is 1,000,000,000,000 bytes. This is not a measurement or a convention that varies by vendor; it is what the SI prefix tera means, the same tera as in terahertz, and it is the definition storage is sold and billed under. Two terabytes is 2,000,000,000,000, and 1.5 TB is 1,500,000,000,000. The conversion is a decimal point moved twelve places right, with no rounding anywhere in it.

Because it is exact, the byte figure is the one worth carrying between systems. Every other representation of the same capacity is a rendering that some tool chose — 0.909 TiB, 931 GB, 1000 GB — and each of those has been rounded on the way to the screen. A configuration that stores the byte count can be compared, summed and audited; one that stores "1 TB" is storing a phrase whose meaning depends on what reads it.

Kubernetes accepts both, and so do a growing number of tools that copied its quantity syntax: T is 10^12 bytes and Ti is 2^40, which is 1,099,511,627,776. The difference is a little under 10%, or roughly a hundred gigabytes per terabyte, and the two spellings differ by a single lower-case letter in a file that is usually reviewed by eye.

Other tools split the same way with less warning. GNU coreutils distinguishes M from MB and T from TB, so dd with bs=1T and dd with bs=1TB will use different block sizes on the same command line. Container runtimes and JVM flags generally treat a bare g or G as a power of 1,024 with no binary suffix offered at all. The rule that survives contact with all of them is to write the byte count when the field allows it, and to check the tool’s own documentation when it does not.

A drive sold as 1 TB contains 1,000,000,000,000 bytes and hands every one of them over. An operating system that divides by 1,024 three times gets 931.32 and prints GB beside it, and the difference between the two descriptions is entirely in the naming. This matters here because a quota or a partition sized from what the operating system displayed will be about 7% away from one sized from the capacity that was actually bought.

The practical consequence is a direction to work in. Take the byte count from the device itself rather than from a display: a partition tool, a block-device query or the drive’s own reported sector count will give an integer, and that integer is what a configuration should be built from. Converting the marketing figure to bytes gets you to the same place when the device is not to hand, and it is the reason the exact trillion is worth knowing by heart.

A bare integer with no separators is the form most configuration languages want and the worst form for a human to verify. The failure is silent in both directions: 100000000000 is a tenth of what was meant and 10000000000000 is ten times it, and neither looks obviously wrong in a file. A quota an order of magnitude too large does not fail at all until something fills it.

Two checks catch nearly everything. Count the digits after the leading figure in groups of three — a whole number of terabytes has twelve — and, where the format permits it, write the value as an expression or with separators so the intention is legible: some formats accept underscores, and a comment giving the terabyte figure costs nothing. Where neither is available, generating the number rather than typing it removes the class of error entirely.

The two systems bite hardest on limits, because a limit is a number nobody looks at again until it is reached. A storage quota intended as 5 TB and written with a binary suffix is 5.5 TB — half a terabyte of capacity that was never budgeted and will be consumed silently. The same error on a retention policy keeps ten per cent more data than the policy document describes, which is a compliance question rather than a capacity one.

Running the error in the other direction is more visible and less dangerous: a limit that is ten per cent smaller than intended produces failures, and failures get investigated. That asymmetry is worth knowing when auditing existing configuration. The values to check first are the generous ones, because a quota that has never been hit is indistinguishable from a quota that is wrong.

Nothing at this scale strains modern arithmetic. A signed 64-bit integer reaches 9,223,372,036,854,775,807, which is over nine million terabytes, and the value survives arithmetic and storage without special handling. JavaScript keeps integers exact to 9,007,199,254,740,991 — about 9 PB — so a terabyte-scale byte count passes through JSON and through a browser intact, which is not true of the petabyte and exabyte figures further up.

The limits that still cause trouble are older and narrower. A 32-bit signed field gives up at 2,147,483,647 bytes, so any tool or protocol carrying a size that way cannot express a terabyte at all, and what it does instead is rarely a clean error. When a byte count of this size disappears or turns negative, the field it passed through is almost always the explanation, and the conversion on this page is not.