Google Review QR Code Generator
Paste your Google review link below and print the code where happy customers actually are — the counter, the receipt, the door. One scan opens the review form for your business, signed in as the customer, ready to rate.
Print checklist
- Keep the white margin around the code — it is the quiet zone scanners need, not empty space to crop.
- Size for the scan distance: at least 2 × 2 cm for arm's-length scanning, and roughly one tenth of the farthest scan distance for posters.
- Scan a test print with a real phone before making copies.
Step 1: find your official review link
Google gives every verified Business Profile a share link that opens the "write a review" form directly. The current official steps (verified against Google Business Profile Help, July 2026):
- Go to your Business Profile — search for your business name on Google (or open it in Google Maps) while signed in with the account that manages it.
- Select Read Reviews, then Get more reviews. (In Search this also appears as Ask for reviews.)
- Copy the review link. Google also offers its own QR code there — the generator on this page exists because you will usually want a print-quality, styleable file rather than a screenshot of that dialog.
Sources: Google Business Profile Help, "Get Google reviews" and "Create a Google review link or QR code".
Step 2: encode it — worked example
Review links typically look like https://g.page/r/…/review. An illustrative
example (this one is a placeholder — paste your own link from step 1):
https://g.page/r/EXAMPLE0abc123/review
The code encodes your link exactly as Google issued it — no shortener, no redirect through us, no tracking layer between your customer and the review form.
What the code contains
A QR code has two independent layers. The payload is the text encoded inside; the symbol is the matrix of dark and light modules that carries it. For a review code the payload is nothing more than the link from step 1. This page is the URL generator preconfigured for that one job, and its builder follows the convention documented on the ZXing "Barcode Contents" wiki, verified against that source on 2026-07-20: the symbol encodes exactly the text of the URL, and the protocol must be included so readers recognise it as a link. The builder therefore validates the address and never rewrites it. There is no shortener, no redirect through our servers and no tracking layer, because nothing is added: the payload above is 38 characters long, and so is the link that produced it.
The symbol is produced to ISO/IEC 18004 by a vendored copy of the reference encoder (Project Nayuki's qrcodegen), kept byte-comparable with upstream, and every worked example on this page is rendered at build time by that same engine, so the payloads and numbers in this prose cannot drift from what the generator produces. Most "my code doesn't work" problems are payload problems. Here the payload is a single address, so the two questions worth asking are whether the address is the right one — which the methodology page explains the engine cannot answer — and whether the printed symbol can be read, which the symbol facts below help with.
Every code this site produces is static: the link lives in the image itself, with no redirect through our servers. That is why the code cannot expire and cannot be held hostage, and also why it cannot be edited after printing and why scans cannot be counted. A review code that carries the link Google issued, and nothing else, depends on nobody in between.
Read next: Static versus dynamic QR codes — where the content lives in each kind of code, the trade-offs stated plainly, and why a code that points at a link you were issued needs no hosting service to keep it alive. More background is in all guides.
Reading the symbol facts
The long-form example below and the table that follows report three numbers from the encoder. The version is the size class the encoder chose for the symbol; the module count is the symbol's width and height in modules, the small squares, not counting the quiet zone; and the error-correction level is one of L, M, Q or H as the engine exposes them. The generator encodes at M unless you choose otherwise, and the level reported is the one actually encoded: it is never lower than requested, but it can be higher, because the reference encoder raises the level when doing so does not increase the version. A logo overrides the choice and forces H.
Review links come in more than one length. The short g.page/r/… form above is
38 characters and needs version 3 at
29×29 modules. The FAQ mentions a longer
search.google.com/local/writereview… form; the example below stands in for one. Its
query string is a placeholder, not a real parameter — it is there only so that the symbol reflects
the length of such a link.
An illustrative long-form link of 85 characters (everything after
? is a placeholder) encodes as:
https://search.google.com/local/writereview?example=PLACEHOLDER0000000000000000000000
Version 6, 41×41 modules, error correction M. The payload is the input, unchanged; the extra characters are what the symbol has to carry.
The table collects the symbol facts for both links, first at the default level and then at error correction H, which is what the engine switches to the moment a logo is placed on the code. The payload — its length and the characters it uses, which you control only by pasting the link Google issued — and the error-correction level, which a logo takes out of your hands, drive the module count.
| Example | Payload length | Version | Modules | Error correction |
|---|---|---|---|---|
| Short form (the worked example), default level | 38 characters | 3 | 29×29 | M |
| Long form (placeholder query), default level | 85 characters | 6 | 41×41 | M |
| Short form with a logo (error correction H) | 38 characters | 5 | 37×37 | H |
| Long form with a logo (error correction H) | 85 characters | 9 | 53×53 | H |
The size readout in the style panel is arithmetic on top of these facts, not a scanning guarantee. A PNG download is a square of 512, 1024, 2048 pixels, and the readout divides the pixel width by 300 to give inches, then converts to millimetres. The image divides that width among the symbol's modules plus the 4-module quiet zone on each side, so the same preset prints the short link with wider modules than the long one. The table shows the module width that falls out of that division for the two links at the default level.
| PNG preset | Print size | Module width, version 3 | Module width, version 6 |
|---|---|---|---|
| 512 px | 1.71 in × 1.71 in (43.3 mm × 43.3 mm) at 300 DPI | 1.17 mm | 0.88 mm |
| 1024 px | 3.41 in × 3.41 in (86.7 mm × 86.7 mm) at 300 DPI | 2.34 mm | 1.77 mm |
| 2048 px | 6.83 in × 6.83 in (173.4 mm × 173.4 mm) at 300 DPI | 4.69 mm | 3.54 mm |
Error correction helps a damaged code scan, but print size and contrast still matter, and the engine cannot know what your printer and your customers' cameras will make of a given module width at the till. Treat a freshly generated code as untested until a real device has scanned it — from the print, not the screen, where you can.
Exactly as entered: what the builder changes and what it refuses
The builder makes one change to what you paste, and it is not to the link: surrounding whitespace is trimmed. Paste the short link with two leading spaces and a trailing line break and the payload is byte for byte the same 38-character string as the clean paste, so the symbol is the same symbol — the build of this page checks that equality and fails if it ever stops holding. Inside the address nothing is altered. The path and the query string of the long-form example above are carried exactly as typed, because the convention is that the symbol carries the text of the URL and the builder has no licence to improve it.
What it refuses, it refuses in its own words, printed here at build time so the limits in the
prose cannot drift from the limits in the form. Paste g.page/r/EXAMPLE0abc123/review — the link
without its protocol — and the generator answers "Include the protocol (e.g. https://) so scanners recognize the link." Paste an address on
another scheme, such as mailto:owner@example.com, and it answers "Only http:// and https:// links are supported."
Paste something that is not an address at all, such as https://, and it
answers "This is not a valid URL." In every case the response is a message instead of a code: the
generator never guesses at what you meant.
What the generator cannot verify
The engine validates format, not truth. It can confirm that the text is an http
or https address with a protocol a reader will recognise. It cannot know whether that
address is the review link for your business, whether it opens the review form rather than your
profile page, or whether it is safe. A link to the wrong page encodes exactly as well as the right
one — the engine reports the same kind of symbol facts for a wrong address as for the right one
— so the private-window test in the section below is the only check that settles the link, and a
scan of a printed copy with a real device is the only check that settles the symbol.
It also makes no network request. Encoding happens on your device, and nothing you paste into the generator is transmitted or logged unless you choose to save a code to an account. That is a consequence of the static design rather than a feature bolted onto it: because the link lives in the image, there is nothing hosted that could lapse, and the code works for exactly as long as the link does. The same fact has a cost worth stating plainly. The code cannot be edited after printing, so a new link means a new code and a new print, and scans cannot be counted by the code, because nothing sits between the scanning phone and the link. The static versus dynamic guide sets both sides of that trade-off against each other.
Common misreadings
- Cropping the quiet zone. The 4-module white border required by the standard is rendered into every download and cannot be disabled, because cropping it, in the file or in the layout, is the most common self-inflicted scan failure. Look at either example above: the border is part of the code.
- Inverting the colours. The style panel evaluates your colour pair with the WCAG relative-luminance contrast formula and warns below 4.5:1, and it warns separately for light-on-dark codes. Black on white assesses at 21.00:1 with no warnings. White modules on a near-black background (#ffffff on #1a1a1a) assess at 17.40:1 — comfortably above the threshold — and the engine still warns: "Light-on-dark (inverted) codes are not reliably read by all scanners. Prefer dark modules on a light background." Contrast is necessary; it is not sufficient.
- Fading the foreground to match the branding. Mid-grey modules on white (#8a8a8a on #ffffff) assess at 3.45:1, and the panel reports: "Low contrast (3.45:1). Scanners may fail below 4.5:1 — darken the foreground or lighten the background." Contrast is computed, not guessed, so the warning appears the moment a pair drops below the threshold rather than after a failed print run.
- Adding a logo without reading the numbers. A centre logo destroys modules that error correction must rebuild, so the engine forces error correction H whenever one is present and caps the logo at 16% of the symbol area, a cap that is decode-tested in the round-trip suite with a worst-case logo rather than derived from a theoretical ceiling. The symbol-facts table shows the price: at H the short link moves from version 3 to version 5 (37×37 modules) and the long form from version 6 to version 9 (53×53 modules), with smaller modules at the same print size. The logo is part of the image, never part of the link.
- Blaming the symbol for the wrong link. A code that scans and opens your profile page instead of the review form is, as far as the engine can tell, indistinguishable from one that works: both are well-formed addresses. The engine cannot tell a review link from any other link, so check what the copied link opens before suspecting the code — and if the link is right and the code still will not scan, that is exactly the kind of report the contact page asks for.
Where review codes work — and the rules
- Moment of satisfaction: the till, the receipt, the takeaway bag, the invoice email footer — right after good service, not before it.
- Make the ask honest: "Enjoyed it? A Google review helps us a lot" with the code underneath is the entire playbook.
- Know Google's rules: Google's review policies prohibit paying or offering incentives for reviews and prohibit selectively soliciting only happy customers ("review-gating"). Print one code for everyone and let the reviews be real — fake or incentivized reviews can be removed and can penalize your profile.
- Test the link before printing: open your copied link in a private browser window; it should land on the review form for your business, not your profile page.
Google review QR code FAQ
Does the customer need a Google account?
Yes — Google reviews require being signed in to a Google account. On Android that is nearly universal; on iPhone the form prompts a sign-in if needed. The code cannot change that requirement; it just removes the finding-your-business step.
Will the code break if Google changes its link format?
Links Google has already issued keep working — Google maintains them as entry points to your profile. The code contains your link verbatim, so it lives exactly as long as the link does. That risk sits with Google's link, not with this site: nothing about the code routes through us.
Can I see how many people scanned it?
Not from the code — it is a direct link with no tracking layer, by design. Your Business Profile's performance dashboard shows review activity, which is the number that actually matters.
My link is very long — does that hurt the code?
Longer links make denser codes. The g.page/r/… form is short; if Google gave you a long search.google.com/local/writereview… form, print the code a little larger (the 300-DPI size readout in the style panel helps) and always scan a test print.
Why is my link rejected when I leave off https://?
Because the builder follows the convention that the symbol encodes exactly the text of the URL, protocol included, so a reader recognises it as a link. Its message is the engine’s own: “Include the protocol (e.g. https://) so scanners recognize the link.” Add https:// and the same text is accepted unchanged. Addresses on other schemes are refused too — “Only http:// and https:// links are supported.”
Does the code contain anything besides my link?
No. The payload is the link and nothing else: the worked example’s input is 38 characters long and so is its payload, with no shortener, redirect or tracking parameter added, because every code on this site is static. The guide Static versus dynamic QR codes sets out what that means for a code you print.
I pasted the link with spaces around it — did they go into the code?
No. Surrounding whitespace is the one thing the builder removes. The short link pasted with leading spaces and a trailing line break produced a payload byte for byte identical to the clean one, so the symbol is the same symbol. Inside the address nothing is altered: the builder validates the shape of the link and encodes it as typed, which is why the private-window test above is worth doing before you print.
Can I put my logo in the middle of a review code?
Yes, with two consequences the engine enforces rather than leaves to chance. A logo destroys modules that error correction has to rebuild, so the encoder switches to error correction H whenever a logo is present, and the logo is capped at 16% of the symbol area — a cap that is decode-tested in the round-trip suite with a worst-case logo rather than derived from a theoretical ceiling. H costs density: at that level the short link needs version 5 instead of 3, and the long-form example version 9 instead of 6. The logo decorates the image; it is not part of the link.
Round out the counter: a guest WiFi code, a WhatsApp enquiry code, and a plain link code for the menu or booking page.