# QR Code Error Correction Levels: Types, Meaning, and Safe Defaults

> QR code error correction explained: the error types it handles (scratches, smudges, logos), what each level (L/M/Q/H) means, and the safe default for most printed codes.

Canonical: https://fast-qr.app/learn/qr-code-error-correction-explained
Last updated: 2026-09-30

Author: [Rehan Haider](https://fast-qr.app/author/rehan-haider)
Published: 2026-04-15
Tags: qr, error correction, error types, printing, logo, reliability

A QR code on a coffee bag survives a smudge of espresso. A poster gets a torn corner and still scans. A logo sits in the middle of an event ticket and the camera reads through it. None of that is luck. It's **error correction** — extra redundancy baked into the QR pattern that lets a scanner reconstruct missing or corrupted data.

If you print QR codes, embed logos, or rely on long-lived signage, this is the setting that matters most. Pick the right level and your code shrugs off scratches. Pick the wrong one and a scuffed corner takes the whole thing offline.

## What "QR code error" actually means

When QR documentation talks about an "error", it almost never means an on-screen error message. It means a **lost or corrupted module** in the printed code — a single dark or light cell the camera could not read clearly. A smudge wipes out a dozen modules. A logo blocks a few hundred. A scratch nicks a corner. Each is an "error" the way Reed–Solomon coding theory uses the word: a symbol that disagrees with what the encoder originally wrote.

Error correction is how the QR specification turns that loss into something recoverable. The encoder writes redundant parity alongside the data so a scanner with most of the modules can rebuild the rest. The meaning is operational, not user-facing: it is the spec's way of saying "this code can lose up to X% of its modules before it stops working."

## What error correction actually does

Error correction is not a vague quality boost. It is specific redundancy calculated from your payload using a method called **Reed-Solomon error correction**, the same family used in CDs, DVDs, and deep-space communications. The generator splits your data into blocks, calculates parity bytes for each block, and weaves both into the QR pattern. When some modules are unreadable, the scanner uses the parity to rebuild the original.

In practice, error correction helps when:

- a corner is smudged, scratched, or torn,
- the code is printed on textured material like cardboard or fabric,
- the camera reads at an angle and some modules blur,
- a logo or icon blocks part of the data area,
- glare washes out a strip of the code.

What it does not help with: a missing quiet zone, low contrast between modules and background, or a damaged finder pattern in the corner. Those break scanning before error correction even gets a chance to work. For a refresher on the parts that have to stay intact, see [how QR codes work](https://fast-qr.app/learn/how-qr-codes-work).

## Types of QR code errors error correction handles

The QR spec recognises two broad **error types** in a printed code, and the Reed–Solomon decoder treats them differently:

- **Erasures** — modules the scanner knows it cannot read. The location is known, the value is not. Typical causes: a torn corner, a sticker peeled off, a logo plate masking part of the data area.
- **Substitution errors** — modules the scanner reads as the wrong value without knowing it was wrong. Typical causes: ink bleed darkening a light module, a glare spot whitening a dark one, motion blur smearing one cell into the next.

The decoder can repair **roughly twice as many erasures as substitution errors** at the same correction level, because knowing where the damage is makes the math easier. That is why level H (≈30% recoverable) handles a logo (an erasure with a known boundary) more reliably than it handles a uniformly ink-bled scan of the whole code (a substitution error scattered everywhere).

<figure id="erasures-vs-substitution-errors" style="margin: 1.5rem auto; max-width: 720px;">
  <img src="https://fast-qr.app/images/learn/erasures-vs-substitution-errors.svg" alt="Two QR code panels comparing a known logo-shaped erasure with scattered substitution errors from ink bleed and glare." loading="lazy" decoding="async" style="width: 100%; max-width: 720px; height: auto;" />
  <figcaption style="margin-top: 0.5rem; text-align: center; font-size: 0.85rem; color: #4a6070;">Erasures versus substitution errors. A logo or torn patch has a known boundary, so the decoder knows where to rebuild. Ink bleed, glare, and blur are harder because some modules look valid but are wrong.</figcaption>
</figure>

In day-to-day terms, the error types that show up on real-world QR codes are:

<figure id="error-types-gallery" style="margin: 1.5rem auto; max-width: 720px;">
  <img src="https://fast-qr.app/images/learn/qr-code-error-types-gallery.svg" alt="Seven QR code thumbnails showing different damage types: ink bleed smudge, torn corner, centred logo overlay, scratches, glare reflection, camera angle blur, and sun-faded ink. Each thumbnail is colour-coded for the Reed-Solomon error correction level needed to recover it — M or Q for moderate damage, H for aggressive damage or logos." loading="lazy" decoding="async" style="width: 100%; max-width: 720px; height: auto;" />
</figure>

| Error type | Cause | Recovers at |
| --- | --- | --- |
| Smudge / ink bleed | Wet finger, espresso ring, low-quality print | M or higher |
| Torn corner | Sticker damage, packaging wear | Q if torn area ≤ 25% |
| Logo overlay | Centred brand mark on the data area | H, with logo ≤ 25% of area |
| Scratches | Laminated cards on busy reception desks | Q or H, plus matte lamination |
| Glare / reflection | Glossy stock under overhead light | Q, plus matte print |
| Camera angle blur | Phone tilted, motion at scan time | Alignment patterns + M or higher |
| Faded ink | Sun-exposed signage over months | H, plus UV-stable ink |

The one type error correction **cannot** recover from: damage to the three corner **finder patterns** or the surrounding **quiet zone**. Those are what the scanner uses to locate the code in the first place; if they fail, the decoder never gets called. Always design layouts so the corners stay clean and the four-module quiet zone is preserved — see [the QR anatomy walkthrough](https://fast-qr.app/learn/what-is-a-qr-code) for which regions are reserved.

## The four levels: L, M, Q, H

Every QR generator lets you choose one of four error correction levels:

- **L (Low)** — about 7% of codewords can be recovered
- **M (Medium)** — about 15%
- **Q (Quartile)** — about 25%
- **H (High)** — about 30%

<figure style="margin: 1.5rem auto; max-width: 720px;">
  <svg role="img" viewBox="0 0 720 260" xmlns="http://www.w3.org/2000/svg" style="width: 100%; max-width: 720px; height: auto;">
    <title>Error correction levels L M Q H — recoverable damage area</title>
    <desc>Four identical QR codes side by side, each marked with a translucent red region showing the share of code area that error correction can recover from. Level L recovers about seven percent of the area, M about fifteen, Q about twenty-five, and H about thirty.</desc>
    <rect width="720" height="260" fill="#FAF7F0"/>
    <defs>
      <symbol id="ec-qr" viewBox="0 0 130 130">
        <rect width="130" height="130" fill="#FFFFFF"/>
        <g fill="#00476b">
          <rect x="55" y="10" width="5" height="5"/><rect x="65" y="10" width="5" height="5"/>
          <rect x="75" y="10" width="5" height="5"/>
          <rect x="55" y="20" width="5" height="5"/><rect x="70" y="20" width="5" height="5"/>
          <rect x="60" y="30" width="5" height="5"/><rect x="80" y="30" width="5" height="5"/>
          <rect x="55" y="40" width="5" height="5"/><rect x="70" y="40" width="5" height="5"/>
          <rect x="85" y="40" width="5" height="5"/>
          <rect x="55" y="50" width="5" height="5"/><rect x="65" y="50" width="5" height="5"/>
          <rect x="75" y="50" width="5" height="5"/><rect x="95" y="50" width="5" height="5"/>
          <rect x="105" y="50" width="5" height="5"/><rect x="115" y="50" width="5" height="5"/>
          <rect x="50" y="60" width="5" height="5"/><rect x="60" y="60" width="5" height="5"/>
          <rect x="80" y="60" width="5" height="5"/><rect x="100" y="60" width="5" height="5"/>
          <rect x="115" y="60" width="5" height="5"/>
          <rect x="55" y="70" width="5" height="5"/><rect x="75" y="70" width="5" height="5"/>
          <rect x="90" y="70" width="5" height="5"/><rect x="105" y="70" width="5" height="5"/>
          <rect x="60" y="80" width="5" height="5"/><rect x="70" y="80" width="5" height="5"/>
          <rect x="85" y="80" width="5" height="5"/><rect x="95" y="80" width="5" height="5"/>
          <rect x="115" y="80" width="5" height="5"/>
          <rect x="55" y="90" width="5" height="5"/><rect x="75" y="90" width="5" height="5"/>
          <rect x="100" y="90" width="5" height="5"/><rect x="115" y="90" width="5" height="5"/>
          <rect x="60" y="100" width="5" height="5"/><rect x="80" y="100" width="5" height="5"/>
          <rect x="95" y="100" width="5" height="5"/><rect x="110" y="100" width="5" height="5"/>
          <rect x="55" y="110" width="5" height="5"/><rect x="75" y="110" width="5" height="5"/>
          <rect x="90" y="110" width="5" height="5"/><rect x="105" y="110" width="5" height="5"/>
        </g>
        <rect x="10" y="10" width="35" height="35" fill="#00476b"/>
        <rect x="15" y="15" width="25" height="25" fill="#FFFFFF"/>
        <rect x="20" y="20" width="15" height="15" fill="#00476b"/>
        <rect x="85" y="10" width="35" height="35" fill="#00476b"/>
        <rect x="90" y="15" width="25" height="25" fill="#FFFFFF"/>
        <rect x="95" y="20" width="15" height="15" fill="#00476b"/>
        <rect x="10" y="85" width="35" height="35" fill="#00476b"/>
        <rect x="15" y="90" width="25" height="25" fill="#FFFFFF"/>
        <rect x="20" y="95" width="15" height="15" fill="#00476b"/>
      </symbol>
    </defs>
    <g font-family="system-ui, sans-serif">
      <g transform="translate(40,25)">
        <use href="#ec-qr" width="130" height="130"/>
        <circle cx="80" cy="80" r="22" fill="#b04a3a" opacity="0.55"/>
        <text x="65" y="155" text-anchor="middle" font-size="22" font-weight="700" fill="#081e32">L</text>
        <text x="65" y="174" text-anchor="middle" font-size="11" fill="#4a6070">Low</text>
        <text x="65" y="192" text-anchor="middle" font-size="14" font-weight="700" fill="#b04a3a">~7%</text>
        <text x="65" y="207" text-anchor="middle" font-size="10" fill="#4a6070">recoverable</text>
      </g>
      <g transform="translate(205,25)">
        <use href="#ec-qr" width="130" height="130"/>
        <circle cx="80" cy="80" r="29" fill="#b04a3a" opacity="0.55"/>
        <text x="65" y="155" text-anchor="middle" font-size="22" font-weight="700" fill="#081e32">M</text>
        <text x="65" y="174" text-anchor="middle" font-size="11" fill="#4a6070">Medium</text>
        <text x="65" y="192" text-anchor="middle" font-size="14" font-weight="700" fill="#b04a3a">~15%</text>
        <text x="65" y="207" text-anchor="middle" font-size="10" fill="#4a6070">recoverable</text>
      </g>
      <g transform="translate(370,25)">
        <use href="#ec-qr" width="130" height="130"/>
        <circle cx="80" cy="80" r="37" fill="#b04a3a" opacity="0.55"/>
        <text x="65" y="155" text-anchor="middle" font-size="22" font-weight="700" fill="#081e32">Q</text>
        <text x="65" y="174" text-anchor="middle" font-size="11" fill="#4a6070">Quartile</text>
        <text x="65" y="192" text-anchor="middle" font-size="14" font-weight="700" fill="#b04a3a">~25%</text>
        <text x="65" y="207" text-anchor="middle" font-size="10" fill="#4a6070">recoverable</text>
      </g>
      <g transform="translate(535,25)">
        <use href="#ec-qr" width="130" height="130"/>
        <circle cx="80" cy="80" r="40" fill="#b04a3a" opacity="0.55"/>
        <text x="65" y="155" text-anchor="middle" font-size="22" font-weight="700" fill="#081e32">H</text>
        <text x="65" y="174" text-anchor="middle" font-size="11" fill="#4a6070">High</text>
        <text x="65" y="192" text-anchor="middle" font-size="14" font-weight="700" fill="#4a7c59">~30%</text>
        <text x="65" y="207" text-anchor="middle" font-size="10" fill="#4a6070">recoverable</text>
      </g>
      <text x="360" y="240" text-anchor="middle" font-size="11" fill="#4a6070" font-style="italic">Higher correction recovers more data, but encodes the same payload in a denser grid.</text>
    </g>
  </svg>
  <figcaption style="margin-top: 0.5rem; text-align: center; font-size: 0.85rem; color: #4a6070;">Error correction levels L through H. The red overlay marks how much of the data area each level can recover from — higher levels survive more obstruction (logos, smudges, scratches), but pack the same payload into a denser grid. Finder and timing patterns must stay intact at every level.</figcaption>
</figure>

These percentages refer to the share of the data that can be reconstructed if it is unreadable. They are not promises. Real-world scan success depends on print quality, lighting, camera, and which parts of the code are damaged. A code with 25% of its area destroyed in one big chunk near a finder pattern will fail at any level. The same 25% scattered across the data area is recoverable at H.

Most generators default to M because it covers the typical print case without bloating the pattern. Fast QR exposes the level on every generator so you can match it to the job: see [URL to PNG](https://fast-qr.app/static/url-to-png), [URL to SVG](https://fast-qr.app/static/url-to-svg), or [URL to JPG](https://fast-qr.app/static/url-to-jpg).

## Higher correction means denser codes

Here is the trade-off everyone forgets. More redundancy means more bytes in the pattern. More bytes mean a higher QR **version** (a larger grid of modules) for the same payload. At a fixed printed size, a higher version means smaller individual modules. Smaller modules are harder for a phone camera to resolve, especially in low light or from a distance.

So "always use H" is not a free upgrade. The right level depends on:

- payload length (a 30-character URL versus a 200-character URL),
- final printed size,
- whether you are adding a logo,
- viewing distance and lighting,
- and the worst phone camera you expect to encounter.

A short URL printed at 5 cm on a clean menu can use H without trouble. The same payload at H, shrunk to a 1 cm square on a foil pouch, will struggle. The fix is usually shorter payload or larger print, not lower correction.

## Safe default error correction levels by use case

The "safe" level — the one that handles the average production deployment without forcing you to think about it — is **M for most printed codes and H whenever a logo is involved.** That single rule covers maybe 80% of jobs. The rest is matching the level to the worst conditions the code is expected to meet:

- **No logo, large print, controlled environment** — M is plenty. Restaurant menus, business cards, posters indoors.
- **Small print, harsh lighting, or outdoor exposure** — Q or H. Packaging, parking signs, stickers on metal.
- **Logo in the center** — H, paired with a code that is large enough that the remaining modules stay crisp.
- **Digital screens only, never printed, payload very long** — L can be acceptable. Damage is not a risk and you save module density.

If your printed surface lives in a rough environment — kitchens, warehouses, outdoors — bump correction up *and* increase physical size. The two together cost you nothing once the print is set up.

## How logos interact with error correction

When you drop a logo in the middle of a QR code, you are deliberately blocking modules. The scanner can still recover the data if three things hold:

- the blocked area is within what your error correction level can recover,
- the quiet zone and the three finder patterns in the corners stay untouched,
- and the surrounding modules remain crisp and high contrast.

Some practical logo guidance:

- **Keep the logo around 20-25% of the code area at most.** H tolerates up to 30% damage in theory, but you want headroom for print imperfections.
- **Use a solid plate behind the logo.** A white circle or square stops the logo from visually merging with surrounding modules and confusing the scanner.
- **Never cover finder patterns or alignment patterns.** The big squares in three corners and the small squares on the grid are how the scanner orients itself. Damage them and the code fails before error correction is consulted.
- **Test on cheap phones.** Newer iPhones and Pixels are very forgiving. A five-year-old budget Android is the real test.

For more on visual design without breaking scans, see [QR code design best practices](https://fast-qr.app/learn/qr-code-design-best-practices).

## What makes codes denser (and how to fight back)

A dense QR pattern has more, smaller modules. Density goes up when:

- payloads are long, especially URLs with tracking parameters,
- correction is high,
- you encode raw text instead of linking to a hosted page.

If your code feels too dense to print small, the most effective fix is almost always the payload, not the correction level. Three things to try:

1. **Shorten the URL.** Drop unnecessary query parameters. Use a short canonical path on your own domain.
2. **Use a redirect on a domain you control.** A path like `go.brand.com/menu` is short, stable, and editable. See [static vs dynamic QR codes](https://fast-qr.app/blog/static-vs-dynamic-qr-codes) for the trade-offs.
3. **Link, don't embed.** A QR code carrying a 500-character paragraph of text will be huge. The same code carrying a URL to a page with that paragraph is tiny.

In real deployments, shortening the payload moves the needle far more than tweaking error correction.

## Error correction is not a substitute for good print

Even with H, a code still needs:

- a clean **quiet zone** of at least four modules around all edges,
- high contrast between modules and background (dark on light, please),
- enough physical size for the scan distance you expect,
- and a format that preserves edges. Vector [SVG](https://fast-qr.app/static/url-to-svg) for print, high-quality [PNG](https://fast-qr.app/static/url-to-png) for screens.

If a QR code is tiny, low contrast, and crammed against the edge of a label, error correction will not save it. For exact size guidance, see [QR code size and print guidelines](https://fast-qr.app/learn/qr-code-size-and-print-guidelines), and the [colored QR code guide](https://fast-qr.app/learn/qr-code-colored) for the contrast ratios that keep brand-coloured codes scannable in the first place.

## A quick test before you commit to a level

If you are unsure, do not guess. Run a five-minute test:

1. Generate the same payload at M and at H.
2. Print both at the smallest size you plan to deploy.
3. Scan each from arm's length on at least three phones, including one older Android.
4. Try in dim light, with a slight angle, and at the maximum expected distance.
5. If H scans noticeably slower because it is denser, increase the printed size or shorten the payload — do not drop to L.

The goal is not maximum redundancy. The goal is fast, consistent scanning across the messy conditions your code will actually meet.


Read [how QR codes work](https://fast-qr.app/learn/how-qr-codes-work) for the encoding and decoding sequence. If you are placing a mark over the pattern, the [QR code with logo guide](https://fast-qr.app/learn/qr-code-with-logo) explains the design checks.

## Sources

- [Wikipedia — QR code (Error correction)](https://en.wikipedia.org/wiki/QR_code#Error_correction) — Levels L/M/Q/H, capacity trade-offs, and recovery percentages.
- [Wikipedia — Reed–Solomon error correction](https://en.wikipedia.org/wiki/Reed%E2%80%93Solomon_error_correction) — The mathematical algorithm behind QR error correction.
- [Denso Wave — Error correction feature](https://www.qrcode.com/en/about/error_correction.html) — Inventor's overview of error correction in QR.

## Frequently asked questions

### What does QR code error correction mean?

QR code error correction is Reed-Solomon redundancy built into the QR pattern. The encoder calculates parity bytes from your payload and weaves them into the grid alongside the data, so a scanner can reconstruct the original message even when some modules are unreadable due to print damage, scratches, ink bleed, glare, or a logo covering part of the code. The 'error' in the term refers to lost or corrupted modules in the printed code, not to an error message the user sees.

### What types of QR code errors can error correction recover from?

Error correction recovers from damage to the data and parity area of the code: print smudges, ink bleed, torn or scuffed corners, scratches on stickers and laminates, glare or reflection that washes out part of the pattern, camera angle blur, and obstruction from a logo embedded in the center. It cannot recover from a missing or crowded quiet zone, low contrast between modules and background, or damage to the three corner finder patterns — those break detection before error correction is consulted.

### What are the four QR code error correction levels?

QR codes have four error correction levels: L (Low, ~7% recovery), M (Medium, ~15%), Q (Quartile, ~25%), and H (High, ~30%). A higher level adds more redundancy so the code survives more damage, but also increases the density of the QR pattern, which can reduce scan speed at small print sizes.

### What is a safe error correction level for QR codes?

Level M (Medium, ~15% recovery) is the safe default for most printed codes — restaurant menus, business cards, posters in controlled lighting. Use level Q or H (Quartile / High) for outdoor signage, packaging, or anything subject to wear; use level H whenever a logo sits in the center of the code. Level L is only safe on digital screens that never get printed and never get damaged.

### Which error correction level should I use for a QR code with a logo?

Use level H (High, 30% recovery) when embedding a logo in the center of a QR code. The logo obscures some modules, and level H gives the scanner enough redundancy to recover the full payload. Keep the logo to roughly 20-25% of the code area even with level H.

### Does higher error correction make a QR code harder to scan?

Higher error correction increases the number of modules in the QR pattern, which can make individual modules smaller at the same print size. At very small sizes this can slow scanning. For most print sizes (3 cm or larger), level M or H scans reliably. Only consider level L for very space-constrained digital displays where damage is not a concern.
