Shopify Liquid Cheat Sheet: Complete Reference for Developers

Key Insights
• Liquid is built on three components: objects output data, tags control logic, and filters transform output. Nearly everything else is a variation on these three.
• The render tag has replaced the older include tag in modern theme development. Themes still using include are working from a deprecated pattern.
• Theme Check, Shopify’s official linter, catches syntax errors, deprecated tags, accessibility issues, and performance anti-patterns before code ever reaches production.
• Over 1.7 million retailers depend on Liquid for their storefronts, making it one of the most widely used templating languages in commerce specifically.

A Shopify Liquid cheat sheet earns its place as a bookmark for one simple reason: even experienced developers forget the exact filter name, the correct metafield access syntax, or whether render fully replaced include this quarter. This reference organizes Liquid’s core syntax so it’s findable in seconds instead of buried in documentation tabs, covering the objects, tags, and filters that come up in real theme development, not just the textbook examples that most tutorials stop at. Over 1.7 million retailers depend on Liquid for their storefronts today, which is part of why small syntax changes ripple across a huge share of the ecommerce web the moment Shopify ships an update.

The Three Pillars of Liquid

Everything in Liquid builds from three fundamental components, and understanding how they divide labor makes the rest of the language click into place faster than trying to memorize syntax in isolation:

Objects use double curly braces and output data directly. For example, {{ product.title }} prints the product name wherever it appears. Tags use curly-brace-percent syntax and handle logic and control flow. They power if statements, loops, and variable assignments without producing visible output on their own. Filters use the pipe character to transform an object’s output. You can also chain them, so one value passes through several filters before appearing on the page.

Objects: Where Your Store Data Lives

Every meaningful piece of store data products, collections, customers, the cart is exposed to Liquid as an object with its own set of properties. product.title, product. price, product.featured_image, and collection. products are the ones a developer touches daily. Every object also carries a handle, a URL-safe version of its title generated automatically: lowercase, spaces and special characters replaced with hyphens. If two products would generate the same handle, Shopify auto-increments it, so a second product named “Shirt” gets the handle shirt-1 rather than colliding with the first, and a third becomes shirt-2, and so on indefinitely.

Tags: Controlling Logic and Flow

Tags are where actual programming logic lives inside a template. Conditionals branch with if, elsif, and else, or their inverse, unless, for cases where checking the negative reads more naturally. Loops iterate with for, most commonly over product. variants or collection.products, and support useful modifiers like limit and offset for controlling how much of a collection actually renders. assign stores a single computed value for reuse later in the template, while capture does something similar but stores an entire rendered block of markup as a string, useful for building up complex strings conditionally before outputting them once.

One tag distinction worth knowing specifically: render has replaced include as the standard way to pull in a reusable snippet. render runs in its own isolated scope, which prevents the variable-naming collisions that made include a common source of subtle bugs in larger themes, where a variable set in one included file could unexpectedly leak into and overwrite a variable in another. Themes still leaning on include are working from an older, discouraged pattern that Theme Check will now flag directly as deprecated.

Need custom Liquid built for your theme? Talk to Our Dev Team

Filters: Transforming Output

Filters modify how a value displays without changing the underlying data, and they’re where a lot of practical theme work actually happens day to day, far more than most of the flashier Liquid features get credit for:

money is the filter every store touches constantly, formatting a raw number into properly formatted currency based on the store’s settings. where filters an array down to items matching a specific property value, genuinely useful for pulling a subset of products or collections without a manual loop and conditional. img_url builds a correctly sized image URL on demand, which matters more than it sounds for page performance, since serving an oversized image for a small thumbnail slot wastes real load time on every single page view that loads it.

Common Mistakes Worth Avoiding

A specific, recurring set of errors accounts for a disproportionate share of Liquid debugging time:

The metafield .value mistake deserves special attention since it’s genuinely the most common issue reported by developers working with custom data. Referencing a metafield object directly outputs the object itself, not the human-readable value inside it; appending .value is what actually surfaces the data a template is meant to display. This one habit alone resolves a large share of the “why is my metafield showing nothing” debugging sessions developers run into.

Metafields carry their own syntax quirks beyond this one. Our complete Shopify metafields guide covers accessing them correctly in depth.

A Liquid cheat sheet earns its bookmark not by teaching the language from scratch, but by being faster to check than official documentation for the ten things every theme developer looks up repeatedly. Objects output data, tags control logic, filters transform output, and the specific syntax details in between are what separate working code from code that silently breaks on an edge case nobody tested for before launch.

Want a Liquid theme audit before your next launch? Book a Consult

Pro Tip 💡

Install Theme Check as a VS Code extension before your next Liquid session, not after you hit a confusing bug. It catches deprecated tags, missing blank guards, and accessibility issues in real time as you type, which is considerably faster than debugging the same class of error after it’s already live on a storefront and a customer has already noticed something broken.

FAQ

1. What Are the Three Core Components of Shopify Liquid?

Objects, tags, and filters. Objects output data using double curly braces, tags control logic and flow using curly-brace-percent syntax, and filters transform output using the pipe character, chainable in sequence to apply several transformations at once.

2. Should I Use include or render in Shopify Liquid?

Use render. It replaced include as the standard way to pull in reusable snippets, running in an isolated scope that prevents the variable collision bugs include was known for in larger, more complex themes with many nested snippet files.

3. How Do I Access a Metafield in Liquid?

Reference it through its namespace and key, then append .value to get the actual data: {{ product.metafields.custom.material.value }}. Forgetting .value is the most common mistake, since it outputs the metafield object itself, including its type and internal structure, rather than the readable value it actually stores.

4. What Does the money Filter Actually Do?

It formats a raw numeric value as currency according to the store’s configured settings, handling the currency symbol, decimal places, and formatting conventions automatically rather than requiring manual string formatting for every price displayed.

5. What Is Theme Check and Do I Need It?

Theme Check is Shopify’s official linter for Liquid and JSON, catching syntax errors, deprecated tags, accessibility issues, and performance anti-patterns before they ship. It’s available as a VS Code extension or through the Shopify CLI, and it’s worth using on every single theme project regardless of size.

6. What’s the Difference Between assign and capture?

assign stores a single computed value, a number, string, or boolean, for reuse later in the template. capture stores an entire rendered block of markup as a string, which is useful for building complex, conditional strings before outputting them once at the end.