What Is a QR Code and How Does It Work?
A QR code (short for "Quick Response" code) is a two-dimensional barcode that stores information in a grid of black and white squares. Unlike a traditional barcode, which only encodes data in one direction, a QR code stores data both horizontally and vertically - which is why it can hold far more information in the same amount of space. A standard 1D barcode tops out at around 20-25 characters; a QR code can hold thousands.
It's easy to take for granted just how much is happening in the half-second between pointing a camera at a code and a link popping up on screen. This guide walks through what's actually inside that pattern of squares, why the format was designed the way it was, and how it went from a niche industrial tool to something scanned billions of times a day.
The anatomy of a QR code
Every QR code is built from a grid of individual squares called modules. Each module is either "dark" or "light," and the specific pattern of dark and light modules is what encodes your data. But not every module carries your content directly - a meaningful portion of the grid is dedicated to structural elements that let a scanner make sense of everything else:
- Finder patterns - the three large square-in-a-square markers in the top-left, top-right, and bottom-left corners. These let a scanner instantly locate the code and determine its orientation, even if the code is rotated, tilted, or viewed at an angle.
- Alignment patterns - smaller square markers scattered through larger codes that help correct for distortion, such as scanning a code printed on a curved surface like a bottle.
- Timing patterns - alternating dark and light lines connecting the finder patterns, used to help the scanner count modules accurately across the grid.
- Quiet zone - the blank margin surrounding the entire code. It looks like empty space, but it's a required part of the standard; without it, a scanner can't reliably tell where the code starts and ends.
- Data and error-correction modules - the remaining modules, which actually store your encoded content plus redundant information used for error recovery.
How your data actually gets encoded
When you type a URL or a message into a QR generator, several things happen before a single module is drawn. First, the software determines the best encoding mode for your data - numeric (digits only), alphanumeric (digits, uppercase letters, and a small set of symbols), byte (any text, including lowercase letters and most symbols), or kanji (for Japanese characters). Numeric mode is the most space-efficient, byte mode the least - which is one reason a QR code encoding "12345" looks noticeably simpler than one encoding a long mixed-case URL of the same character count.
Next, the data is broken into blocks and run through a mathematical process called Reed-Solomon error correction - the same family of error-correction algorithms used in CDs, DVDs, and satellite communications. This step deliberately adds redundant data alongside your original content, which is what allows a QR code to remain readable even when part of it is damaged, dirty, or covered by a logo.
Finally, the combined data and error-correction blocks are arranged into the grid according to a fixed pattern defined by the QR code standard (ISO/IEC 18004), and a mask pattern is applied - one of eight possible patterns chosen specifically to avoid large blocks of solid color or patterns that could confuse a scanner's edge detection.
Why error correction is the most important feature you never think about
QR codes build in four selectable levels of error correction - L, M, Q, and H - each trading a bit of data density for tolerance to damage; our complete error correction guide breaks down exactly what each level recovers from and when to choose which one. What matters here is the effect this has in practice: it explains why a code still scans after a coffee spill smudges a corner, why a torn parking ticket's QR code often still works, and - most relevant if you're designing your own - why you can place a logo directly in the center of a code without breaking it. As long as the obscured area stays within what the chosen error-correction level can recover, the scanner reconstructs the missing information mathematically rather than needing to actually "see" every module.
How your phone actually reads the code
Modern smartphone cameras don't need a dedicated app anymore - scanning is built directly into the native camera on both iOS (since iOS 11, released in 2017) and Android (natively in most manufacturers' camera apps since around the same era). The process, from the phone's perspective, happens roughly like this:
- The camera's image processor scans the live video feed looking for the distinctive three-square finder pattern arrangement.
- Once found, it calculates the code's size, rotation, and perspective distortion, and digitally "unwarps" the image as needed.
- It reads the module grid, decodes the mask pattern, and reconstructs the raw data blocks using the error-correction information.
- It interprets the decoded text according to its format - recognizing, for example, that a string starting with "WIFI:" should trigger a network-join prompt, or that one starting with "BEGIN:VCARD" should offer to save a contact.
All of this happens in a fraction of a second on hardware that fits in your pocket - a remarkable amount of applied mathematics packed into something that feels completely mundane today.
What can actually go inside a QR code?
A QR code doesn't inherently "know" what type of content it holds - it's simply a container for text, and it's the receiving app's job to interpret that text meaningfully. This is why the same underlying technology can trigger wildly different behavior depending on how the text is formatted:
- A plain URL opens a browser
- Text starting with
mailto:opens an email draft - Text starting with
tel:opens the phone dialer - Text starting with
WIFI:triggers a network connection prompt - Text formatted as a vCard (
BEGIN:VCARD...END:VCARD) offers to save a contact - Text starting with
upi://pay,bitcoin:, or a PayPal.Me link opens the relevant payment app
This is also why generating a correctly formatted QR code matters more than people expect - a WiFi QR code with a formatting mistake in the password field won't just fail to connect, it may fail to trigger the network prompt at all, because the scanning app won't recognize the pattern as WiFi data in the first place.
A brief note on capacity
QR codes come in 40 different sizes, called "versions," ranging from Version 1 (21x21 modules, holding up to 41 numeric characters at the lowest error correction) up to Version 40 (177x177 modules, holding several thousand characters). Most real-world use cases - a URL, a WiFi password, a vCard - comfortably fit within the first ten or so versions. A generator automatically selects the smallest version that fits your data at your chosen error-correction level, which is why longer text produces a visibly denser code.
Conclusion
None of this engineering is something you need to think about while actually using a QR code, which is rather the point - a finder pattern locating the grid, Reed-Solomon math reconstructing a smudged corner, a mask pattern avoiding confusing runs of solid color, all resolving in a fraction of a second before a link even finishes loading. But understanding the mechanics does change how you use the format: it explains why a WiFi code needs its fields typed exactly right, why a logo can sit in the center without breaking anything, and why a longer message produces a visibly denser pattern. From here, it's worth reading how error correction levels actually work, or jumping straight into building one yourself.
Frequently asked questions
Do QR codes expire? A standard (static) QR code never expires - the data is permanently encoded in the pattern itself. Only dynamic QR codes (which redirect through a hosted short link) depend on that service staying online.
Can a QR code contain a virus? The code itself cannot execute code or contain malware - it's just text. The risk is entirely in where that text sends you, the same as clicking any link.
Why do some QR codes look more complex than others? Complexity correlates with the amount of data encoded and the error-correction level chosen - more data or higher error correction both require more modules, producing a visually denser grid.
Ready to put this into practice? Try our free QR code generator for any of the 39 formats we support, from plain text to WiFi, payments, and more.