What's the difference between KB and KiB?

KB = 1000 bytes (decimal SI). KiB = 1024 bytes (binary IEC). Drive manufacturers use KB; Linux and macOS use KiB. 1 KB ≠ 1 KiB — the gap grows with size (1 TB vs 1 TiB differs by ~10%).

Why does my OS show a different size than the label?

Manufacturers count in decimal (1 TB = 10^12 bytes). Most operating systems display in binary (1 TiB = 2^40 bytes), which is ~9% larger. A 'missing' 90 GB on a 1 TB drive is usually just this unit mismatch, not a defect.

Does it support bits vs bytes?

Yes — toggle to Mb / Gb for network speeds. 100 Mbps ≠ 100 MB/s; it's 12.5 MB/s. A small b means bits, big B means bytes. Easy to mix up on speed-test sites.

SI 1000 · IEC 1024 · KB ↔ MiB · live

Convert bytes to human-readable sizes

Type a byte count — see SI (KB, MB, GB, TB) and IEC (KiB, MiB, GiB, TiB) representations side-by-side. Disambiguate disk vs RAM marketing.

Byte Size Converter

Input

1,500,000

bytes

Best SI

1.5 MB

rounded

Best IEC

1.4305 MiB

rounded

Mode

live

client

input · SI (×1000)

B1,500,000

KB1,500

MB1.5

GB0.0015

TB0

PB0

EB0

output · IEC (×1024)

B1,500,000

KiB1,464.8438

MiB1.4305

GiB0.0014

TiB0

PiB0

EiB0

Quick Start

SI vs IEC — what's the difference?

SI uses powers of 1000 (1 KB = 1000 B), the way disk vendors market capacity. IEC uses powers of 1024 (1 KiB = 1024 B), the way operating systems and RAM are sized.

01
Type bytes
The raw byte count from your tool (ls -l, du, stat, …).
Parsing is strict-but-tolerant — comments and trailing commas are accepted on input where the source format historically permits them; output stays canonical.
instricttolerantliveparse
in · sourcebytes · live
```
1500000000
```
loaded · parsedtarget · ready
02
SI rollups
Divide by 1000^k for KB, MB, GB.
Conversion preserves type information where the target supports it (numbers stay numeric, booleans stay boolean) so the destination parser never has to re-coerce.
sitype-preservinglosslesslivememoised
÷ · options1000 · live
```
1.5 GB
```
options applied · liveround-trip
03
IEC rollups
Divide by 1024^k for KiB, MiB, GiB.
Re-encoding is idempotent: running output back through the same converter produces the same bytes, which keeps round-trips git-friendly.
iecidempotentround-tripdiff-cleandeterministic
÷ · converted1024 · ready
```
1.397 GiB
```
converted · livediff-clean
04
Pick the right one
Disk = SI; RAM and most OS tools = IEC.
Copy writes via navigator.clipboard.writeText; downloads use the target’s native MIME so editors apply the right syntax highlighting on open.
pickclipboardtarget MIMEblobclient-side
✓ · copiedready · done
```
1.5 GB ≈ 1.397 GiB
```
shipped · ready to shipsuccess

Pro tips

Converting between formats, safely

Pick the strictest source format

Lossy formats hide bugs. Choose JSON or YAML as your source-of-truth, convert downstream as needed.

Round-trip in CI

If your converter is idempotent, your CI can verify A → B → A equals the original. Catches subtle data loss.

Numbers vs strings differ

YAML/TOML have a number type; CSV doesn’t. Quote IDs in CSV to keep leading-zero values intact.

Watch character encoding

Source format may be Latin-1 / Windows-1252; target should be UTF-8. Convert encoding before structure.

Preserve comments where you can

YAML and TOML support comments. Don’t silently drop them — they often encode intent.

Schema-aware beats blind

Use a schema to guide conversion. Field types, required-ness, and defaults survive better with structure.

Use Cases

When to humanise bytes

Storage, transfer, capacity.

Capacity planning

Translate ticket sizes to GB before procurement. Type information survives: numbers stay numeric, booleans stay boolean, strings stay strings. The destination parser doesn't have to re-coerce, which avoids the "'true' becomes "true"" bug class.

round-trip safe

Disk vs OS

Explain why a 1 TB drive shows 931 GiB. Run output back through the inverse converter to verify idempotent round-trips in CI. A → B → A should produce byte-identical input — if it doesn't, you've found data loss.

type-preserving

Bandwidth

Reconcile Mbps vs MiB/s for video bitrates. Comments and metadata survive where the target format supports them (YAML, TOML, HCL). The tool doesn't silently drop intent-encoded annotations, which keeps your config self-documenting.

schema-aware

Logs

Quickly spot which log line means MB vs MiB. Pair with a schema (JSON Schema, OpenAPI, Zod, Pydantic) to catch shape drift on either side. Catch breaking changes at conversion time rather than at runtime in production.

lossless

S3 quotas

AWS uses GiB internally — convert before invoicing. Output respects target-format conventions: quoting in CSV, indent in YAML, brackets in JSON. Existing parsers don't need patches, and the result drops into legacy pipelines unchanged.

diff-clean

Documentation

Pick one convention and stick with it. Encoding-aware: handles UTF-8 vs UTF-16 vs Latin-1 / Windows-1252 transparently. The character-set surprise that breaks "works on my machine" doesn't apply here.

spec-grade

FAQ

Frequently asked questions

Why so many KB definitions?

Historical drift. SI is the standards-correct choice; OS vendors still mix conventions.

Negative bytes?

Filtered out — the input must be non-negative.

Scientific notation?

Yes — 1.5e9 is valid.

Rounding?

Up to 4 fraction digits — copy from the row of the unit you want.

Is anything sent to a server?

No. Conversion runs locally.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!