# Shopify Metafields for SEO: Spec Tables, FAQs and Schema Without Another App

Source: https://www.smartecomseo.com/blog/shopify-metafields-seo/  
Published: 2026-09-23  
Updated: 2026-09-29

Shopify metafields store the product details your theme and Google need: specs, FAQs, schema properties, filters and even your SEO titles. This guide covers how to set them up and use them for SEO without adding another app.

## Key takeaways

- Shopify metafields are custom fields with a namespace, a key, a type and a value. Definitions give them validation and make them available in the admin, the theme editor, Liquid and filters.
- One set of product metafields can power a visible spec table, storefront filters, smart collections and Product structured data, so the facts stay the same everywhere.
- Your SEO title and meta description are already metafields (global.title_tag and global.description_tag), and a seo.hidden integer metafield set to 1 hides a product, page or blog post from search engines, the sitemap and store search.
- Build FAQs as a metaobject referenced from products. The content still helps shoppers and AI answers, but Google no longer shows FAQ rich results, which ended on May 7, 2026.
- Merchants can create up to 256 metafield definitions per resource type, and most values are capped at 64KB, so plan namespaces and naming before a large catalog grows around them.

Shopify metafields are custom fields you attach to products, variants, collections, pages, blog posts, customers, orders and the shop itself. They store the details Shopify doesn't have a field for, such as material, dimensions, warranty length, care instructions or a list of FAQs, and your theme can display them anywhere.

For SEO, Shopify metafields matter because they turn product facts into structured, reusable data. The same field can fill a spec table Google can index, power a storefront filter, define a smart collection and feed Product schema. This guide covers how metafields work, how to create them, and the four SEO uses we set up on almost every store, without paying for another app.

## What are Shopify metafields?

A Shopify metafield is a key-value pair with four parts:

- **Namespace and key**: the identifier, written as `namespace.key`. Shopify generates `custom.material` from a field named "Material" unless you choose another namespace, such as `specs.material`.
- **Type**: what kind of value it holds: single line text, multi-line text, rich text, integer, decimal, true or false, date, measurement (weight, dimension, volume), URL, color, rating, file, money, JSON, or a reference to another resource such as a product, collection, page or metaobject.
- **Value**: the data itself, for example "Solid oak".
- **List or single value**: most types can hold one value or a list.

A **metafield definition** is the template that tells Shopify a field exists for a resource type, what type it is, and which validation rules apply (character limits, minimum and maximum values, allowed choices). Values without definitions still exist through the API, but definitions are what make fields appear in the admin, the theme editor, filters and smart collections. Shopify's [metafields overview](https://help.shopify.com/en/manual/custom-data/metafields) covers the basics.

### Metafields vs metaobjects vs tags

|  | Metafield | Metaobject | Tag |
| --- | --- | --- | --- |
| What it is | One custom field on one resource | A custom content type with several fields, stored once and reused | A free-text label |
| Example | `specs.material` = "Solid oak" | An FAQ entry with a question and an answer | "oak", "sale", "new-2026" |
| Validation | Yes, by type and rules | Yes, per field | None |
| Reusable across products | No (each product has its own value) | Yes (reference the same entry from many products) | Yes, but untyped |
| Best for | Specs and attributes | FAQs, size charts, designers, materials, ingredients | Internal organization and legacy automations |
| SEO use | Spec tables, schema, filters, smart collections | FAQ blocks, size charts, glossary content | Avoid using tag pages as landing pages |

Tags answer "which group is this in?". Metafields answer "what is true about this product?". Metaobjects answer "what shared content does this product point to?".

## Why metafields matter for Shopify SEO

Most Shopify product pages carry their facts in one place: a description written years ago, often copied from a supplier or Amazon listing. Metafields fix four problems with that.

1. **Unique, indexable detail.** A spec table with dimensions, materials, capacity and compatibility adds text that answers real queries ("8 ft pool table dimensions", "sauna 240V or 120V"). That text is rendered by Liquid in the HTML, so Google indexes it like any other content.
2. **Consistency.** When the weight lives in one field, the spec table, the filter, the schema and the [Google Shopping feed](/blog/shopify-google-shopping-free-listings/) all show the same number. When it lives in five descriptions, they drift.
3. **Structure for machines.** Google's [merchant listing documentation](https://developers.google.com/search/docs/appearance/structured-data/merchant-listing) recommends Product properties such as `color`, `material`, `size`, `pattern`, `gtin` and `mpn`. Typed fields are the clean source for them. AI shopping assistants also read structured attributes more reliably than prose.
4. **Collection pages that scale.** Product metafields can be conditions for smart collections and values for filters, which is how one attribute becomes a rankable collection such as "oak dining tables".

For high-ticket catalogs, where buyers compare specs for weeks before spending $3,000, the spec table often does more selling than the description. Our guide to [high-ticket product page SEO](/blog/high-ticket-product-page-seo/) shows how we lay those pages out.

## How to create metafields in Shopify

1. In your Shopify admin, go to **Settings > Metafields and metaobjects**.
2. Choose the resource, for example **Products**, and click **Add definition**.
3. Enter a **Name** ("Material"). Shopify fills in the **Namespace and key** (`custom.material`). Change the namespace if you want to group fields, for example `specs.material`.
4. Add a **Description** telling your team what to enter ("Main frame material, as the buyer would say it").
5. Select the **Type** and choose **One value** or **List of values**.
6. Set **Validations**, such as a list of allowed choices, so nobody enters "oak", "Oak" and "solid-oak" on different products.
7. Turn on the options you need: **Storefronts** access for headless builds, and **Smart collections** (available for product and variant metafields) if you want to build collections from the field.
8. Save. The field now appears in the **Metafields** section of every product.

Shopify's [guide to custom metafield definitions](https://help.shopify.com/en/manual/custom-data/metafields/metafield-definitions/creating-custom-metafield-definitions) has the full list of options.

### Category metafields

When you set a product's category from Shopify's Standard Product Taxonomy, Shopify adds **category metafields** such as color, size, material or fabric for that category, some by default and some as suggestions ([Shopify Help Center](https://help.shopify.com/en/manual/custom-data/metafields/category-metafields)). Use them before inventing your own versions of the same attribute. They're standardized, they can connect to variant options, and editing an entry (say, renaming "Black" to "Graphite") updates it everywhere it's used.

## How to display metafields on your store

There are two ways to get a metafield onto a page.

- **Dynamic sources (no code).** In an Online Store 2.0 theme, open the theme editor, select a text or other block, and click the dynamic source icon to connect it to a metafield. Good for one or two fields.
- **Liquid (full control).** Output fields directly: `{{ product.metafields.specs.material.value }}`, or `{{ product.metafields.specs.material | metafield_tag }}` to let Shopify render the right HTML for the type. `metafield_text` gives you a plain-text version of any type, which is useful in tables and schema.

For the SEO uses below, Liquid is worth the extra effort because you control the markup Google sees.

## SEO use 1: Spec tables from metafields

A spec table is the simplest SEO win metafields offer. Create a `specs` namespace with the attributes buyers compare, then render only the rows that have values:

```liquid
{%- assign s = product.metafields.specs -%}
{%- if s.material != blank or s.dimensions != blank or s.weight != blank -%}
<table class="spec-table">
  <caption>{{ product.title }} specifications</caption>
  <tbody>
    {%- if s.material != blank -%}
      <tr><th scope="row">Material</th><td>{{ s.material | metafield_text }}</td></tr>
    {%- endif -%}
    {%- if s.dimensions != blank -%}
      <tr><th scope="row">Dimensions</th><td>{{ s.dimensions | metafield_text }}</td></tr>
    {%- endif -%}
    {%- if s.weight != blank -%}
      <tr><th scope="row">Weight</th><td>{{ s.weight | metafield_text }}</td></tr>
    {%- endif -%}
    {%- if s.warranty_years != blank -%}
      <tr><th scope="row">Warranty</th><td>{{ s.warranty_years.value }} years</td></tr>
    {%- endif -%}
  </tbody>
</table>
{%- endif -%}
```

Save it as a snippet (`snippets/spec-table.liquid`) and render it in the product template. Three rules make it work for SEO:

- **Use the words buyers search.** "Playing surface" and "Slate thickness" beat internal codes like "PS-DIM".
- **Keep it in the HTML.** A table rendered by Liquid is indexed with the page. A spec widget that loads after a click may not be.
- **Don't let specs replace the description.** A table of numbers shared by 40 near-identical products isn't unique content. The description still needs to explain who the product is for and why it's different.

## SEO use 2: FAQs with metaobjects

FAQs are where metaobjects earn their place. Many products share the same questions ("Does it need 240V?", "Can it be installed outdoors?"), so you write each answer once and reuse it.

1. Go to **Settings > Metafields and metaobjects > Metaobjects**, click **Add definition**, and name it "FAQ" with two fields: **Question** (single line text) and **Answer** (rich text).
2. Add entries under **Content > Metaobjects**.
3. Create a product metafield `custom.faqs` with the type **Metaobject reference (List)** pointing to FAQ.
4. On each product, pick the questions that apply.
5. Render them:

```liquid
{%- assign faqs = product.metafields.custom.faqs.value -%}
{%- if faqs != blank -%}
<section class="product-faq">
  <h2>{{ product.title }}: common questions</h2>
  {%- for faq in faqs -%}
    <details>
      <summary>{{ faq.question.value }}</summary>
      <div>{{ faq.answer | metafield_tag }}</div>
    </details>
  {%- endfor -%}
</section>
{%- endif -%}
```

> **FAQ rich results are gone:** Google limited FAQ rich results to authoritative government and health sites in August 2023, then [removed the feature from Search](https://developers.google.com/search/updates), with results no longer shown from May 7, 2026. Write product FAQs because they answer objections and give AI assistants clear, liftable answers, not to win a rich snippet. If an app or agency still sells "FAQ schema for rich results", ask what it's for.

## SEO use 3: Product schema from metafields

Shopify's `structured_data` Liquid filter outputs a basic Product (or ProductGroup, for products with variants) with name, description, image, brand and offers ([shopify.dev](https://shopify.dev/docs/api/liquid/filters/structured_data)). It doesn't know about your custom fields. If your theme builds its own JSON-LD block instead, you can add metafield values to it. Place these lines inside the existing Product object, directly above `"offers"`, so the trailing commas stay valid:

```liquid
{%- if product.metafields.specs.material != blank -%}
  "material": {{ product.metafields.specs.material | metafield_text | json }},
{%- endif -%}
{%- if product.metafields.specs.color != blank -%}
  "color": {{ product.metafields.specs.color | metafield_text | json }},
{%- endif -%}
{%- if product.metafields.specs.mpn != blank -%}
  "mpn": {{ product.metafields.specs.mpn.value | json }},
{%- endif -%}
```

Two cautions. First, keep one Product block per page; a second block from an app or snippet with different facts confuses Google. Second, only mark up what's visible on the page. If the material is in the schema, it should also be in the spec table. Our [Shopify structured data guide](/blog/shopify-structured-data/) covers the full Product, Offer and Organization setup, and our [schema markup service](/shopify-seo-services/schema-markup/) handles it for large catalogs.

## SEO use 4: Collection content and filters

Metafields work on collections too.

- **Collection copy below the grid.** A rich text collection metafield (`custom.seo_content`) lets your team add 300–600 words of buying advice under the products without cramming it into the description at the top. We cover the layout in our [collection page SEO guide](/blog/shopify-collection-page-seo/).
- **Filters.** In **Apps > Search & Discovery > Filters**, product and variant metafields can become storefront filters. Shopify supports single line text, integer, decimal, true or false and metaobject reference types (single and list), with a maximum of 25 filters per store ([Shopify Help Center](https://help.shopify.com/en/manual/online-store/search-and-discovery/filters)).
- **Smart collections from attributes.** This is the big one. Filter URLs use parameters and shouldn't be indexed. When an attribute has real search demand, build a smart collection with a metafield condition ("Material equals Oak") and give it its own title, copy and internal links. A filter serves shoppers already on the page; a collection can rank. How to decide which is which is in our [faceted navigation guide](/blog/shopify-faceted-navigation-seo/).

**Sitting on a catalog full of specs nobody can see?** We design the metafield model, spec tables, schema and attribute collections for Shopify catalogs, then fill them at scale. [See schema and structured data](/shopify-seo-services/schema-markup/)

## The SEO metafields Shopify already uses

Two details most metafield guides skip.

**Your SEO title and meta description are metafields.** When you edit the search engine listing on a product, collection, page or article, Shopify stores it as `global.title_tag` and `global.description_tag` ([shopify.dev](https://shopify.dev/docs/apps/build/marketing/optimize-storefront-seo)). That's why these values appear as metafields in API responses and bulk exports, and why they don't exist on a product until someone edits the listing. It's also why you can write them in bulk through the product CSV, Flow or the API. Our guide to [writing meta descriptions at scale](/blog/shopify-meta-descriptions-at-scale/) uses exactly this.

**The seo.hidden metafield noindexes a page.** Shopify documents an integer metafield with the namespace and key `seo.hidden`. Set it to `1` on a product, page or blog post and Shopify hides it from sitemaps, search engines and your online store search ([Shopify Help Center](https://help.shopify.com/en/manual/promoting-marketing/seo/hide-a-page-from-search-engines)). To set it up:

1. **Settings > Metafields and metaobjects**, choose Products (repeat for Pages and Blog posts), **Add definition**.
2. Name it "SEO hidden" and set the namespace and key to `seo.hidden`.
3. Type **Integer**, **One value**, with a maximum value of 1.
4. On any page you want hidden, enter 1 and save. Clear the value to make it visible again.

Use it for thank-you pages, wholesale-only products, test products and landing pages built for ads. Don't use it on anything that earns organic traffic, and remember it also removes the item from your own store search.

## A starter metafield plan for SEO

Most stores don't need 50 fields. This is the set we start with for a mid-size catalog of considered purchases, such as furniture, grills or fitness equipment. Adjust the specs to what your buyers actually compare.

| Resource | Namespace.key | Type | Used for |
| --- | --- | --- | --- |
| Product | Category metafields (color, material, size) | Shopify standard | Filters, feed attributes, schema `color` and `material` |
| Product | `specs.dimensions` | Single line text | Spec table ("213 x 122 x 80 cm") |
| Product | `specs.weight` | Weight | Spec table, delivery questions |
| Product | `specs.warranty_years` | Integer | Spec table, comparison pages |
| Product | `specs.power` | Single line text with choices | Filter and FAQ ("120V", "240V") |
| Product | `specs.mpn` | Single line text | Schema `mpn`, Google feed when there's no GTIN |
| Product | `custom.faqs` | Metaobject reference (list) | FAQ block |
| Product | `custom.primary_collection` | Collection reference | Breadcrumbs and a consistent link back to the main collection |
| Product | `custom.compare_with` | Product reference (list) | "Compare with" links between close alternatives |
| Collection | `custom.seo_content` | Rich text | Buying advice below the product grid |
| Collection | `custom.faqs` | Metaobject reference (list) | Collection FAQs |
| Product, page, blog post | `seo.hidden` | Integer, max 1 | Hiding pages that shouldn't be indexed |

The reference fields do quiet internal-linking work. A `custom.compare_with` list turns every product page into a small hub of related products with descriptive anchors, and `custom.primary_collection` gives each product one canonical parent. Our [internal linking guide](/blog/shopify-internal-linking/) shows how those links add up across a catalog.

## Bulk editing, limits and naming

Metafields are only useful if they're filled in. Options for large catalogs:

- **Bulk editor.** Select products, open the bulk editor, and add metafield columns. Variant metafields are edited in the variant bulk editor.
- **CSV.** The product CSV supports product metafields but not variant metafields ([Shopify Help Center](https://help.shopify.com/en/manual/products/import-export/using-csv)).
- **Shopify Flow** can set metafield values when products are created or updated.

The limits to plan around, from [Shopify's developer docs](https://shopify.dev/docs/apps/build/metafields/metafield-limits): merchants can create up to 256 metafield definitions per resource type, and most values are capped at 64KB (JSON values at 128KB). Apps get their own 256 per resource type in their own namespaces, which is why stores that have tried many apps end up with dozens of orphaned fields.

Naming rules we use:

- One namespace per purpose: `specs` for attributes, `custom` for content blocks, `seo` for search controls.
- Keys in plain English with underscores: `seat_height`, not `sh_mm`.
- Units in the type (measurement), not in the value, so "45 cm" and "450 mm" can't coexist.
- A description on every definition telling the team exactly what to enter.

## Common metafield mistakes that cost SEO value

- **Empty rows.** Rendering a table row whether or not the field has a value produces "Material: " across half the catalog. Always check `!= blank`.
- **Supplier text pasted into fields.** Metafields don't make copied content unique. Rewrite it.
- **Specs in images.** A spec sheet as a JPG is invisible to search. Put the numbers in fields and the image in the gallery.
- **Two sources for the same fact.** A weight in the description and a different weight in the metafield. Pick the field and remove the other.
- **Forgotten translations.** Text metafields need translating in Translate & Adapt like the rest of the store, or your localized pages show English specs.
- **Paying for an app to do this.** Spec tabs, FAQ accordions and size charts are often separate paid apps that load their own scripts. Metafields and a snippet do the same job with no extra code on the page. If you're auditing what those apps cost you, start with [the Shopify apps quietly hurting your SEO](/blog/shopify-apps-slowing-down-store/).

## FAQs

### What are Shopify metafields?

Shopify metafields are custom fields that store information Shopify does not have a built-in field for, such as material, dimensions, warranty or care instructions. Each has a namespace and key, a type and a value, and can be attached to products, variants, collections, pages, blog posts, customers, orders and the shop. Themes can display them through dynamic sources or Liquid, and they can drive filters and smart collections.

### What is the difference between metafields and tags in Shopify?

Tags are free-text labels with no validation, useful for internal grouping and automations. Metafields are typed fields with validation, so a weight is a number with a unit and a material comes from an allowed list. Metafields can be displayed in the theme, used as storefront filters, used as smart collection conditions and added to structured data. For SEO, use metafields for product attributes and collections instead of tag pages.

### What are category metafields in Shopify?

Category metafields are standardized attributes, such as color, size, material or fabric, that Shopify adds when you assign a product to a category in its Standard Product Taxonomy. Some are added by default and others are suggested. They can connect to variant options, and editing an entry updates every product that uses it. Shopify says they help products get discovered on your site, marketplaces and search engines.

### How do I add metafields to a product in Shopify?

Go to Settings > Metafields and metaobjects, choose Products, click Add definition, then set the name, namespace and key, type and validation rules and save. Open any product and the field appears in its Metafields section, ready for a value. To show it on the storefront, connect it to a block with a dynamic source in the theme editor, or output it in Liquid.

### Do metafields help Shopify SEO?

Yes, when they're rendered in the page HTML. Metafields can add indexable spec tables and FAQs, keep facts consistent between the page, filters and schema, supply properties like material, color and MPN to Product structured data, and define smart collections that target attribute keywords. Metafields that are never displayed, or that hold copied supplier text, add little. The SEO title and meta description are also stored as metafields.

### How many metafields can a Shopify store have?

Shopify's developer documentation says merchants can create up to 256 metafield definitions per resource type, such as products or collections, and each installed app can create up to 256 of its own. Most metafield values are limited to 64KB, JSON values to 128KB, and URL values to 2KB. Storefront filters built from metafields are limited to 25 per store in Search & Discovery.