Bytes to MB Converter — Convert Bytes to Megabytes (Both Standards)

What this bytes to MB calculator does

Paste a byte value from anywhere — a Python os.path.getsize() return, a JavaScript File.size property, a MySQL BLOB length, an HTTP Content-Length header, a log line, or a database dump — and this calculator converts it to megabytes under both standards at once. The decimal answer divides by 1,000,000; the binary answer divides by 1,048,576. The two are about 4.86 percent apart, and knowing which one you actually mean matters more often than most people realise.

What makes this page different from a generic byte converter is that it is aimed squarely at the audience that actually has byte values: developers and sysadmins. Every default in the tool reflects that. The initial byte value is 1048576 — the exact 2^20 power-of-two value that Python, JavaScript, PHP, and MySQL all recognise as "1 MB" internally. The quick-pick panel is packed with the byte values that appear in real code — 4194304, 10485760, 5242880, 26214400, 104857600. The reference tables below the tool list the exact byte counts behind every PHP, MySQL, PostgreSQL, and HTTP size limit you are likely to hit.

If you have a byte value and need to know what it means in MB, this is the fastest path. If you have a MB value and need the byte count for a config file, the reverse tabs and lookup tables handle that too.

How to use it

1. Paste your byte value. Type or paste a byte count into the input field. The result updates as you type — no need to press a convert button.
2. Or click a power-of-two quick-pick. The panel above the tool has the byte values that appear in real code — 1024, 1048576, 4194304, 5242880, 10485760, 26214400, 104857600. One click loads them.
3. Or drop a file. Drag any file onto the dashed drop zone and the browser reads its exact byte count using the File API. Useful when you want to verify a file's size against a byte limit.
4. Read both answers. The large number is the primary answer in the standard that matches your input. The line beneath shows the alternate standard so you can see exactly how far apart they are.
5. Check the bit/byte visualizer. The panel below the result shows the same value in bits, bytes, KB (decimal and binary), and MB (decimal and binary). Useful when you are working at the boundary between bits and bytes — network throughput, storage, or memory allocation.
6. Use the reference tables. If you are setting a PHP upload limit or checking a MySQL BLOB size, the tables below the tool list every common limit with its exact byte count.
7. Swap direction if needed. The MB → Bytes tab flips the converter so you can start from a MB value and find the byte count for your config file.

Why most byte values you see in code are powers of two

If you have spent any time in a codebase that handles file sizes, uploads, or memory, you have noticed something: the byte values are almost always suspiciously round in binary but messy in decimal. Values like 4,194,304 — which looks arbitrary in decimal — turn out to be exactly 2^22. Values like 10,485,760 are exactly 10 × 2^20. And the reason is simple: computers address memory in binary.

A system with N address lines can address 2^N unique bytes. Twenty address lines give you 1,048,576 bytes. Thirty give you 1,073,741,824 — one gibibyte. Because the underlying hardware is binary, the operating systems and programming languages that run on top of it inherit those round numbers. When a language designer writes "default buffer size: 4 MB", they almost certainly mean 4 × 2^20 = 4,194,304 bytes, not 4,000,000.

That is why the byte values in your code look the way they do. Here are the ones that come up most often:

The practical upshot: when you see a byte value in code that looks suspiciously like 4,194,304 or 268,435,456, it is almost certainly a power of two. Divide by 1,048,576 to get the exact mebibyte count — 4 MiB or 256 MiB respectively — and you will match the intent of the original author. Divide by 1,000,000 instead and you get a slightly different number (4.194304 MB) that will not match any assert statement.

Bits, bytes, and the factor-of-8 trap

The single most common source of bugs in network code is forgetting that a byte is 8 bits. Every byte count has a matching bit count — just multiply by 8 — and every bit rate has a matching byte rate — divide by 8. This matters every time you compare a network throughput figure against a file size.

• A 100 Mbps internet connection downloads 12.5 MB per second, not 100. Divide the Mbps figure by 8 to get MB/s.
• A 1 Gbps fibre connection downloads 125 MB per second.
• A 10 Gbps datacentre link transfers 1,250 MB per second — a 1 TB file takes about 14 minutes at sustained throughput.
• A 25 Mbps upload speed sends 3.125 MB per second — a 1 GB backup uploads in about 5 minutes 20 seconds.

The bits-vs-bytes distinction also shows up in storage calculations. RAM is measured in bytes, but RAM chips are physically built as arrays of bits, and their internal bandwidth is quoted in bits per second. When you see "DDR4-3200", the "3200" refers to 3,200 million transfers per second — but each transfer moves 8 bytes on a standard 64-bit memory bus, so the effective bandwidth is 25,600 MB/s. The factor of 8 is everywhere once you start looking.

PHP, MySQL, and HTTP — the byte limits that actually break things

Most byte-to-MB conversions in a developer's life come from hitting a size limit and needing to know what the number actually means. Here are the ones that come up most, with their exact byte counts.

PHP upload and memory limits

PHP uses the shorthand suffixes K, M, and G in its php.ini file, and those suffixes are binary — M means 1,048,576 bytes, not 1,000,000. So the following are the exact byte counts behind the common settings:

• upload_max_filesize = 2M means 2,097,152 bytes (2 MiB)
• upload_max_filesize = 8M means 8,388,608 bytes (8 MiB)
• upload_max_filesize = 10M means 10,485,760 bytes (10 MiB)
• post_max_size = 8M means 8,388,608 bytes — and it must always be ≥ upload_max_filesize
• memory_limit = 128M means 134,217,728 bytes (128 MiB)
• memory_limit = 256M means 268,435,456 bytes (256 MiB)

The classic WordPress problem — "the uploaded file exceeds the upload_max_filesize directive in php.ini" — happens when a user tries to upload a file whose byte count exceeds the configured limit. Knowing the exact byte count of the limit is the difference between a five-minute fix and an hour of debugging.

MySQL BLOB and TEXT limits

MySQL has four BLOB sizes and four matching TEXT sizes, and each one has a hard byte ceiling imposed by the column type:

• TINYBLOB / TINYTEXT — 255 bytes (2^8 - 1)
• BLOB / TEXT — 65,535 bytes (2^16 - 1)
• MEDIUMBLOB / MEDIUMTEXT — 16,777,215 bytes (2^24 - 1)
• LONGBLOB / LONGTEXT — 4,294,967,295 bytes (2^32 - 1)

The -1 in each of those formulas is why MySQL's BLOB limits are one byte less than the corresponding power of two. A BLOB column can hold up to 65,535 bytes, not 65,536, because MySQL reserves one value of the byte count for NULL handling.

HTTP and URL limits

• HTTP header size — most servers reject requests with total headers over 8 KB (8,192 bytes). Nginx defaults to large_client_header_buffers 4 8k; Apache defaults to 8,190 bytes per header.
• URL length — most modern browsers accept URLs up to about 2,000 characters, though the actual limit depends on the browser and the server. Apache defaults to 8,177 characters; IIS defaults to 16,384.
• POST body size — set by the server, not by HTTP itself. Nginx defaults to client_max_body_size 1m (1 MiB); Apache is usually configured in PHP via post_max_size.

Bytes to MB in Python, JavaScript, PHP, and SQL

Different languages have different conventions for byte-to-MB conversion, and getting it wrong can cause bugs that only surface at specific file sizes. Here is the reference for the languages you are most likely to be working in.

In every one of those languages, the safer choice for user-facing file-size display is the binary conversion (÷ 1,048,576) with an "MB" label. That matches what Windows File Explorer and macOS Finder show. If you are writing to a spec that says "megabytes" in the SI sense — a drive label, a cloud storage quota, a mobile data plan — use the decimal conversion instead.

Where bytes to MB conversion actually matters

• Debugging an upload failure. When a user's upload fails with a size-limit error, the exact byte count tells you whether the file exceeds the limit by 100 bytes or 100 MB — a very different fix.
• Configuring PHP limits. Setting upload_max_filesize requires knowing the exact byte count behind the "M" suffix.
• Writing a size-limit check in code. If your API caps uploads at 10 MB, do you mean 10,000,000 bytes or 10,485,760 bytes? The answer affects which files are accepted.
• Testing size limits in unit tests. Assertions on file size need to match the exact binary value your code uses, not a decimal approximation.
• Reading a Content-Length header. HTTP responses report sizes in bytes; you usually want to know if that is 1 MB or 10 MB.
• Analyzing log files. Log rotation thresholds, request size limits, and error thresholds are all written in bytes internally.
• Sizing a database column. Choosing between BLOB and MEDIUMBLOB depends on knowing the byte count of your typical data.
• Estimating transfer time. A network throughput figure in bits per second divided by 8 gives bytes per second; that divided into a file size in bytes gives seconds.
• Comparing cloud storage bills. AWS S3, Azure Blob, and Backblaze all bill in decimal GB — so a "1 GB" file in your local Python code is not the same as a "1 GB" file in S3's billing.

Common mistakes and how to avoid them

• Mixing binary and decimal within a calculation. If you read a file size in binary from Windows and then compute a percentage against a decimal GB quota, the answer will be off by about 7 percent. Pick one standard and stick to it.
• Assuming 1 MB = 1,000,000 bytes in code. Almost every programming environment uses the binary value internally, even when the label says "MB". Defaulting to 1,000,000 will cause silent bugs when you compare against a real file size.
• Confusing bytes and bits. Network speeds are in bits per second. File sizes are in bytes. A 100 Mbps connection downloads 12.5 MB per second, not 100. Always divide by 8.
• Forgetting that PHP's ini suffixes are binary. upload_max_filesize = 10M means 10,485,760 bytes, not 10,000,000. If you write a client-side file-size check that uses the decimal value, it will reject files that the server would actually accept.
• Assuming BLOB limits are power-of-two. MySQL's BLOB maxes are 2^N minus 1, not 2^N, because one byte count value is reserved. BLOB holds 65,535 bytes, not 65,536.
• Trusting a URL bar byte count. Modern browsers do not display byte counts in the URL bar, but many browser extensions do, and they disagree on which standard to use. Always check the tool's own documentation.
• Using the same conversion for both file sizes and network data. File sizes are bytes; network throughput is bits. If you confuse the two, you will be off by a factor of 8.
• Rounding too early. If you are chaining conversions — bytes → KB → MB → GB — do the full multiplication or division in a single step and round at the end. Rounding at each stage compounds the error.
• Assuming the byte count is always exact. Filesystem metadata, compression, and encoding can all change the effective size. A 1,048,576-byte file on disk might take 1,052,672 bytes of actual disk space due to block rounding.

Privacy and data handling

Every calculation happens inside your browser. Nothing you type is uploaded, logged, cached, or stored on any server. If you drop a file onto the drop zone, the browser reads only the file's .size property — a single integer the operating system already knows. The file's contents are never opened, decoded, or sent anywhere. Recent values are stored only in your browser's local storage so the tool can offer them back to you, and can be cleared with the button on the page. There is no account, no login, and no network request after the page loads.

Limitations to be aware of

• The tool cannot detect which standard your source used. If you paste a value from a Windows File Explorer panel labelled "MB", that number is a binary MiB in disguise. Use the MiB input unit to be exact.
• Display values are shown with up to 6 decimal places. For byte values below 1 MB, more digits may be needed — use the exact byte count or the raw division for full precision.
• The bit/byte visualizer assumes standard 8-bit bytes. Some legacy systems use non-standard byte sizes (rare, but they exist in aerospace and industrial contexts).
• The programming language reference assumes the standard library conventions. Some third-party libraries deviate — always check the documentation for the specific library you use.
• The file drop zone reads size only. It does not open, preview, edit, convert, or process the file itself.
• On rare occasions — iCloud "optimized storage" placeholders, OneDrive "files on-demand" items — the size the browser reports is the placeholder size, not the eventual downloaded size.
• History is per-browser. It does not sync across devices, and clearing your browser's site data will wipe it.

Frequently asked questions

Related tools on AIToolsPros