How to Compress an Image to an Exact File Size — And Why It's Harder Than You Think
If you've ever tried uploading a photo to a government website, university portal, or job application and been told your image must be exactly 50KB or 100KB, you've probably wondered why most image compressors miss the target. Type "50" into a KB box, click compress, and get back a file that's actually close to 50KB, but understanding why this is genuinely difficult reveals something interesting about how JPEG compression works — and why almost no free tool actually does this well.
Compress Your Image to an Exact File Size
Try Exact KB Compression Free →Where Exact File Sizes Actually Matter
This isn't a theoretical problem. Passport and visa photo portals often require files under 50KB. University admission portals commonly specify limits like 100KB or 200KB. Job application forms frequently reject images that exceed a strict upload limit, sometimes without a clear error message explaining why. In every one of these cases, "roughly small enough" isn't good enough — the portal is checking an exact number.
The Problem: Quality and File Size Aren't Linearly Related
A JPEG's "quality" setting (0-100) controls how aggressively the encoder discards visual information, but it has no fixed, predictable relationship to the resulting file size. Quality 80 on one photo might produce 40KB. Quality 80 on a different photo — same dimensions, same format — might produce 400KB. The determining factor isn't the quality number; it's how much entropy (visual complexity, detail, noise) exists in the source image. A flat-colored graphic compresses to almost nothing at high quality. A grainy, detailed photograph of foliage or fabric texture can stay large even at fairly aggressive compression, because there's simply more information for the encoder to represent.
This means there's no formula that maps "quality X" to "Y kilobytes" in advance. The only way to know the resulting file size for a given quality setting is to actually run the compression and measure it.
Why Two 5MB Photos Compress Differently
Two photos can both start out at exactly 5MB, yet one compresses down to 80KB while the other only reaches 200KB at the same settings. This isn't a bug or inconsistency — it's the entropy problem in practice. A simple portrait against a plain background contains far less visual information than a busy, detailed scene, even if both files happened to be the same size to begin with. Original file size tells you almost nothing about how compressible an image actually is; visual complexity does.
Why a Linear Search Is Too Slow
The naive approach is starting at quality 100 and decreasing by fixed steps — 95, 90, 85 — re-compressing and checking the file size each time, until you cross below the target. This works, eventually, but it's inefficient: for a large image needing a low target size, you might need 15-20 full compression passes before landing close, and each pass on a large image isn't instant.
The Actual Algorithm: Binary Search Over Quality
A proper exact-size compressor uses binary search instead — the same algorithmic idea as guessing a number between 1 and 100 in the fewest possible tries by always guessing the midpoint:
- Start with quality at the midpoint of the possible range (typically 50)
- Compress at that quality, measure the resulting file size
- If the result is larger than the target, the next guess needs lower quality — search the lower half of the remaining range
- If the result is smaller than the target, there's room for higher quality — search the upper half
- Repeat, each time cutting the remaining range roughly in half
Because each step eliminates half of the remaining possibilities, this converges in roughly 7-10 iterations even across a full 0-100 quality range, rather than the 15-20+ a naive linear approach would need. This is also why CompressFor can hit an exact-size target in a couple of seconds rather than freezing while it churns through dozens of attempts.
Why the Result Still Isn't Perfectly Exact
Binary search finds the quality setting that produces the closest achievable file size to your target, not a mathematically perfect match — because quality settings are discrete integers (you can't ask for "quality 73.5"), and JPEG encoding isn't perfectly deterministic down to the byte. Depending on the image and the specific compression method used, an exact-size compressor typically gets as close as possible to your requested target rather than guaranteeing a byte-for-byte match — commonly within a small margin, though this varies by tool and image. Aiming a little under your actual limit, rather than exactly at it, is sensible practice if a portal has zero tolerance for going even slightly over.
What Happens When the Target Genuinely Can't Be Reached
Binary search on quality alone has a floor: even at the lowest usable quality setting, some images simply can't get small enough, because extremely low quality settings introduce compression artifacts severe enough to make the image unusable, without shrinking the file size much further. Below a certain quality floor, additional compression barely reduces file size but dramatically worsens visible quality — a phenomenon caused by JPEG's block-based DCT (discrete cosine transform) compression hitting a point of diminishing returns.
When this happens, quality reduction alone isn't enough, and the only remaining lever is reducing the image's actual pixel dimensions — a 4000×3000 photo has far more raw data to compress than the same photo resized to 1200×900, regardless of quality setting. A well-built exact-size compressor detects when quality reduction alone won't reach the target and automatically falls back to reducing dimensions as well, rather than returning a badly artifacted result at the "closest" quality setting.
Try Exact KB Compression Free
Compress to an Exact Size Free →Frequently Asked Questions
Why doesn't my quality percentage match a predictable file size?
File size depends on how much visual detail (entropy) is in the image, not just the quality setting. The same quality number produces very different file sizes on a simple image versus a detailed, high-noise one.
How does an exact-size compressor find the right quality setting so quickly?
It uses binary search — testing a middle quality value, checking whether the result is above or below the target, and repeatedly narrowing the range by half. This typically converges in 7-10 attempts rather than dozens.
Why is my compressed file 52KB instead of exactly 50KB?
Quality settings are discrete whole numbers, so the algorithm lands on the closest achievable file size rather than a mathematically exact match. Results vary by image and method, but landing close to the target rather than hitting it byte-for-byte is normal and expected.
Why can't some images be compressed down to a very small target size at all?
Below a certain quality floor, JPEG compression stops meaningfully reducing file size while quality keeps getting worse. When quality reduction alone can't reach the target, reducing the image's pixel dimensions is the only remaining way to shrink the file further.
Is exact file size compression lossless?
No, it's typically lossy. Hitting a specific file size works by adjusting the JPEG quality setting, which discards some visual information by design. If you need a genuinely lossless result, you'll generally have to accept whatever file size that produces, since lossless formats like PNG don't offer the same fine-grained control over output size.