Most QR code generators cap a logo at 20-25% of the code's width and require error-correction level H, which covers roughly 30% data loss. Push past that limit and scanners start failing. A different technique, sometimes called artcode generation, solves which QR modules can double as the logo across the entire code, so there's no percentage ceiling to work around.
Why does a QR code stop scanning once a logo covers too much of it?
A QR code scanner reads every module, each small black or white square, as a data bit or an error-correction bit. Error correction exists to recover a bad camera read: glare, dirt, a torn corner. A logo spends from that same budget. Once a logo blocks more modules than the error-correction budget can rebuild, the decoder runs out of redundant data to fall back on and the scan fails.
QR codes ship with four error-correction levels, according to DENSO WAVE, the company that invented the QR code and holds the trademark:
| Level | Recoverable data loss | Typical use |
|---|---|---|
| L | 7% | Clean environments, maximum data capacity |
| M | 15% | General purpose, the default for most codes |
| Q | 25% | Higher damage tolerance |
| H | 30% | Logos, industrial or outdoor printing |
Level M is what most generators reach for when there's no logo involved. Level H is the only one that leaves enough headroom to survive both a printed logo and ordinary wear.
That 30% ceiling has to cover two jobs at once: real-world damage and the logo itself. A logo sized right at the edge of that ceiling leaves nothing in reserve for a blurry print or an off-angle scan.
What's the maximum safe logo size on a standard QR code?
Keep a logo to roughly 20-25% of the code's total width and height, centered, with error-correction level H turned on. HoverCode's logo guidance puts the ceiling at "~25% the width and height of the QR code." That leaves the remaining slice of the 30% budget in reserve for print and scan conditions.
A few placement rules follow directly from how a QR code is structured:
- Center the logo. The three large squares in the corners, the finder patterns, and the timing strips between them are load-bearing; covering them breaks the scan no matter how much error-correction budget is left.
- Keep a solid white or light backing square behind the logo. A transparent-background logo dropped straight onto QR modules creates false edges the decoder misreads as data.
- Hold contrast. The logo and the surrounding modules still need a clear light-to-dark boundary; a low-contrast logo can fail well within the size limit.
- Test the printed size, not the screen preview. A code that scans cleanly at full size on a monitor can fail at business-card scale, where the logo's edges blur into neighboring modules and the finder patterns shrink to a few millimeters.
Is there a way past the logo-size ceiling?
Yes, but it takes a different construction method. A standard logo QR code generates a normal code first, then pastes a logo image over the center, relying on the error-correction budget to absorb the difference. A second category of tool skips the overlay step: it solves for which of the QR code's own modules can hold valid data and match the logo's shape at the same time, with every candidate checked against the real QR math.
| Overlay logo QR | Whole-code QR | |
|---|---|---|
| How the logo gets added | An image pasted over the center after the code is generated | The QR modules themselves are solved to match the logo's light and dark pattern |
| Logo footprint | Capped around 20-25%, center only | Can extend across the code's full data area |
| Scan guarantee | Depends on staying under the error-correction ceiling; needs testing | Spec-valid by construction, checked against a decode test |
| Best for | A small badge or icon | A logo that should read as the code itself |
Any free QR generator can composite an image over a code in seconds, and for a small centered mark, that's enough. Overlay is quick and cheap, and it holds up fine at the sizes it's built for. Whole-code generation is slower to compute, and only a handful of tools build it. QRlfy's version treats the problem as a system of linear equations over the QR's padding bits, an extension of the QArt technique, and trades that extra computation for a logo that isn't capped at a quarter of the code.
Where QRlfy fits in
QRlfy is one implementation of the whole-code approach above. Instead of pasting a logo over a finished code, it uses Gaussian elimination over the QR's error-correction math to solve for the padding-byte values that make the code's own modules draw the uploaded logo, while every module stays valid QR data. Each output runs through a five-rung decode test: native resolution, downscaled to 512px and 256px, and two blur levels that simulate a camera out of focus. Across a 196-brand benchmark set, all 196 pass every rung. See real examples in the QRlfy showcase.
Upload a logo and a destination URL at qrlfy.com/generate to see it on your own brand mark.