Convert MB to kB

A megabyte is a million bytes. Storage manufacturers have always used this decimal meaning, which is why their capacities look larger than what a computer reports.

A kilobyte is 1,000 bytes when a standards body defines it and 1,024 when an operating system does. This page uses 1,000; the kibibyte is the unit that means 1,024.

Going from megabytes to kilobytes moves the decimal point 3 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 MB is 1234000 kB — 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.

Upload caps are stated in kilobytes far more often than the files they govern are. Government portals, university application systems, job boards, ad platforms and older content-management systems all tend to write a limit like 500 kB or 2,048 kB, while the file on the reader’s desk is described by the operating system in megabytes. The conversion exists to put the two numbers in the same unit so that the comparison can be made at all.

The reason those limits are so often in kilobytes is that they were written when the number was a comfortable size. A 500 kB cap is a decision about a document scan; the same rule expressed as 0.5 MB reads as though it were negotiable. The unit is a signal about the intended file as much as a measurement, and it is usually a sign that whatever is on the other side expects something small and plain.

Multiplying by 1,000 is the whole conversion when both sides use the decimal kilobyte. The complication is that a validator written in a language whose file-size helper divides by 1,024 is measuring in kibibytes and calling them KB. A 2,000 kB file measures 1,953 in those units, and a 2,048 kB limit is really 2,097,152 bytes rather than 2,048,000.

The gap is 2.4%, which is invisible except at the margin — and the margin is exactly where anybody doing this conversion is standing. A file at 99% of the stated limit will be accepted or rejected depending on which kilobyte the server counts in, and nothing on the page will say. Leaving 5% of headroom costs nothing and makes the question moot, which is a better answer than guessing what the developer used.

A byte is eight bits, and the two are separated in writing by nothing more than the case of a single letter: MB is a megabyte, Mb is a megabit. Network capacity is sold in bits — a 100 Mbit/s line carries 100,000,000 bits a second — while every file anybody transfers over it is measured in bytes. Reading one as the other is an error of a factor of eight, which is 800%, and it is the single largest routine mistake in this category.

The convention is not arbitrary. Bits are what a line actually moves, one signal at a time, and the byte is a grouping imposed above them; a link that carries eight bits per second delivers one byte per second and the equipment has no opinion about what the byte contains. That is why the units differ on either side of the same wire, and why a conversion between them belongs in any estimate that starts from a connection speed.

A browser reports the rate at which bytes are arriving, because bytes are the unit of the file it is fetching. An internet provider advertises bits, because bits are the unit of the line. Dividing the advertised figure by eight converts one to the other: 100 Mbit/s is 12,500 kB/s, 50 Mbit/s is 6,250, and a 2.4 MB photograph over the second of those takes a little under half a second at best.

"At best" is doing real work in that sentence. Protocol overhead, the round trips needed to open a connection, contention on the local network and the speed of the server at the far end all take a share, and a transfer that reaches 80 to 90% of the theoretical byte rate is doing well. When somebody says their 100 Mbit line only downloads at 11 MB/s, the line is behaving correctly and the arithmetic was done once, wrongly, in an advertisement.

For a photograph, pixel dimensions dominate. Halving the width and the height removes three quarters of the pixels, and the file usually falls by more than that because the remaining detail compresses better. Only after the dimensions are right is the JPEG quality setting worth touching, and below roughly 70 the losses start to show on skin, sky and flat colour — the places a document scan or a portrait is judged on.

For a document, the size is nearly always images rather than text. A PDF of a scanned page can be several megabytes because the scanner stored a photograph of the paper; the same page exported as text with an embedded font is tens of kilobytes. Re-saving a compressed file at a lower quality over and over is the one approach that reliably fails, because compression artefacts are themselves detail that has to be encoded.

Four spellings circulate and only three are meaningful. MB is a megabyte, Mb is a megabit, and kB is a kilobyte with the lower-case k that SI actually prescribes. A lower-case m is the prefix milli, so mB would be a thousandth of a byte and mb a thousandth of a bit — neither is a quantity anybody has ever needed, which means both are always typing errors for one of the others.

The practical rule when reading a specification is to look at the size of the number rather than the letters. A limit of "5 Mb" for a photograph is a megabyte limit written carelessly, because nobody caps an upload at 625 kB expressed in bits. A line speed of "50 MB" is a megabit figure for the same reason. Where the number is ambiguous and the difference matters, the byte count is the only version worth trusting.

A cap is rarely about disk space, which is cheap. It is about the memory a server spends holding an upload, the time a mobile connection spends sending it, the cost of scanning or converting it, and the queue behind it. That is why limits cluster at values like 500 kB, 2 MB and 5 MB rather than tracking what storage costs, and why they are so often unchanged decades after they were set.

It also explains why the check happens where it does. Client-side validation is a courtesy that stops a doomed upload before it starts; the real check is on the server, after the bytes have arrived, using the byte count and whatever kilobyte the code was written with. Converting your file yourself before uploading it is the only way to know which side of the line it falls on before finding out slowly.