# What Is Semantic Enrichment of Product Data?

> What semantic enrichment is, how it differs from completing the catalog and how to get a machine to understand what each piece of data means.

URL: https://clione.ai/glossary/semantic-enrichment/
Lang: en

In libraries, archives or language processing, semantic enrichment means annotating a text with the entities it names. In an online store it is the same thing applied to product data: **it is not about adding data, but about saying what each piece of it means**. That is why it is not another name for [catalog enrichment](/glossary/catalog-enrichment/), which fills in and corrects the values of each field. A field can be full and still be ambiguous: "Capacity: 30" does not say whether it is liters or kilos, and "Category: New arrivals" does not say what the product is. It matters to you because anyone reading your catalog from outside, whether Google or an AI assistant, has to interpret each value, and what is not said gets guessed. Google puts it this way: you can help it understand a page by **giving it explicit clues about its meaning** with [structured data](/glossary/structured-data/).[^google-sd-intro]

## How it works

Semantic enrichment is done with four operations, from the most general to the most specific.

**1. Say what kind of thing it is.** An HTML tag tells the browser how to display a piece of text, but not what it means. [Schema.org](/glossary/schema-org/)'s example is a heading that says "Avatar": it could be the movie or a profile picture, and the code cannot tell them apart.[^schema-gs] Declaring that a page describes a [Product](/glossary/product-schema/), that its maker is a [Brand](/glossary/brand-schema/) and that whoever sells it is an [Organization](/glossary/organization-schema/) turns a piece of text into a typed [entity](/glossary/entity/). Google uses the structured data it finds to understand the content of the page and to gather information about the world, such as the people, books or companies that appear in the markup.[^google-sd-intro]

**2. Use shared properties.** Instead of a label of your own like "Col." or "Fabric," the properties the vocabulary defines: `color`, `material`, `gtin`. For what has no property of its own, schema.org offers `additionalProperty` with a value of type `PropertyValue`, which accepts a `propertyID`, the usual identifier for that characteristic, such as the code from a product-properties standard, and a `unitCode`, the unit according to the UN/CEFACT common code, three characters long, or a URL.[^schema-propertyvalue]

**3. Normalize the values.** Some data a machine cannot interpret without a convention. Schema.org uses a date as its example: "04/01/11" could be January 11, 2004, April 1, 2011 or January 4, 2011, and the fix is to write it in ISO 8601 format. The same goes for closed lists, like availability, which is expressed with fixed values such as `https://schema.org/InStock` and not with an "only a few left."[^schema-gs] **A number without a unit, a date without a format and a status in free language are the three most common semantic gaps.**

**4. Link with stable identifiers.** The [GTIN](/glossary/gtin/) identifies the product outside your store; [sameAs](/glossary/sameas/) links the brand to a reference page about it, and schema.org explains that links to third-party sites about the same item help search engines better understand what you are describing.[^schema-gs] Category works the same way: [Google Merchant Center](/glossary/google-merchant-center/) accepts Google's category as a full path or as a numeric ID, and **recommends the ID**.[^gmc-spec] In Google's taxonomy, "Luggage & Bags > Backpacks" is category 100.[^google-taxonomy] It is someone else's [product taxonomy](/glossary/product-taxonomy/), which is why whoever reads it understands it.

## If you don't do it, the platform does

[Shopify Catalog](/glossary/shopify-catalog/), the product database Shopify uses to supply AI channels, does part of this work on its own. In December 2025, Shopify explained that the catalog **infers categories, extracts attributes, consolidates variants and groups identical items** so AI can understand the data.[^shopify-agentic-storefronts] Its developer documentation adds the fine print: some fields are inferred by Shopify's AI, may be missing or of varying accuracy depending on the available product data, and are marked as inferred.[^shopify-dev-catalog] The lesson is not about Shopify: **what the store does not make explicit, someone infers**, and the store stops deciding what its data means.

## In a store

**Fictional example.** A mountain gear store sells a 30-liter backpack. Its [product page](/glossary/product-page/) has every field filled in, and yet almost all of them are ambiguous to a machine:

| Data         | Complete but ambiguous | With the meaning explicit                                         |
| ------------ | ---------------------- | ----------------------------------------------------------------- |
| What it is   | A page with a title    | A `Product`                                                       |
| Brand        | The text "Trailhead"   | A `Brand` with its name and `sameAs` to its official site         |
| Capacity     | "Capacity: 30"         | A `PropertyValue` with name, value 30 and a declared unit         |
| Category     | "Fall arrivals"        | Google category 100, "Luggage & Bags > Backpacks"                 |
| Availability | "Only a few left"      | `https://schema.org/InStock`                                      |
| Identifier   | An internal code       | The manufacturer's GTIN, in addition to the [SKU](/glossary/sku/) |

In [JSON-LD](/glossary/json-ld/), the right-hand column looks like this:

```json
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Trailhead 30 Backpack",
  "brand": {
    "@type": "Brand",
    "name": "Trailhead",
    "sameAs": "https://trailhead.example/"
  },
  "sku": "TRAIL30-BLK",
  "additionalProperty": {
    "@type": "PropertyValue",
    "name": "Capacity",
    "value": 30,
    "unitText": "liters"
  },
  "offers": {
    "@type": "Offer",
    "availability": "https://schema.org/InStock"
  }
}
```

The text on the product page has not changed; what has changed is what a machine can state about it without guessing. Clione, for example, publishes a single [`@graph`](/glossary/graph/) on each product page whose product node carries a stable [`@id`](/glossary/id-json-ld/) and coexists with the theme's instead of duplicating it.


Thinking that enriching semantically means writing descriptions with more synonyms and related words, which is how [semantic SEO](/glossary/semantic-seo/) is sometimes understood. The semantics a machine reads are not in the vocabulary density of the text, but in the markup: **the type, the property and the normalized value**. Schema.org exists precisely because an HTML tag does not say what the text it contains means.[^schema-gs]


## How to check it

1. **Run a product page URL through the [schema validator](/glossary/schema-markup-validator/)** and see which types it detects. If only a web page shows up, the product is not declared as such.
2. **Look for numbers without units** in your attributes: capacity, weight, dimensions, power. Each one needs its unit in a field, not in the product name.[^schema-propertyvalue]
3. **Look at how you send the category to Merchant Center.** If you send your collection's name instead of a category from Google's taxonomy, swap it for the ID.[^gmc-spec][^google-taxonomy]
4. **Review availability in the markup**: it has to be one of schema.org's fixed values, not text.[^schema-gs]
5. **Check the brand**: if it is only text, declare it as an entity and, if the brand has a reference page, link it with `sameAs`.

## Related concept: catalog enrichment

The two jobs are done on the same [product catalog](/glossary/product-catalog/) and often go together, but they answer different questions. Catalog enrichment answers **what each field is worth**: it fills in the missing material, fixes a GTIN or writes a description. Semantic enrichment answers **what that value means to a machine**: that the material is the `material` property of a `Product`, that the 30 is liters, that the category is Google's 100. A catalog can be complete and semantically poor, but not the other way around: you cannot declare the meaning of a value that does not exist.

To go further, the [catalog and entities reading path](/learn/catalog-and-entities/) orders the rest of the terms, up to the [product graph](/glossary/product-graph/), which brings all these entities together in a single piece of markup.