Blog
Google Product Category: How to Map Product Descriptions to a Category Taxonomy
A practical method for mapping thousands of SKUs to Google's product taxonomy, and why product_type now matters as much as the Google category.
The short answer
To map product descriptions to a category taxonomy, map your own category tree to Google's taxonomy first, one node to one numeric ID. Then classify the leftover products from their title and description, with AI choosing from a shortlist of valid categories. Send the result as google_product_category, keep a detailed product_type, and review only products where Google's category disagrees.
How to map products to Google's taxonomy: the short answer
Map your category tree to Google IDs once, handle mixed nodes with rules, and use AI only for the products the tree can't place. Put as much care into product_type as into the Google category.
Most teams that need to map product descriptions to a category taxonomy start at the wrong end: 20,000 SKUs classified one by one, when the existing category tree would do most of the work.
- 01
Google already assigns a category to every product, so
google_product_categoryis an override. Use it where it changes something. - 02
product_typedoes more work than most teams think. It structures Shopping bidding, and OpenAI's feed spec reads it before Google's category. - 03
Map your own category tree once, node by node. Classify single products from their descriptions only where the tree can't tell you.
- 04
Let AI choose from a shortlist of valid category IDs. Never let it invent a path.
Google product category vs product type
google_product_category uses Google's fixed list and overrides the category Google assigns automatically. product_type is your own breadcrumb, and it drives bidding, reporting and how other channels read your catalog.
Google's product category documentation is blunt: every product is automatically assigned a category, based on your title, description, brand and GTIN. The attribute overrides that guess, and Google accepts the override in three cases: categories with required attributes (apparel, mobile phones, software), campaigns organized by category, and alcohol.
So the usual advice to fill google_product_category on every SKU is half right. On a clean catalog, Google's classification is usually fine, and a hand-mapped category one level too broad is worse than a correct automatic one. We set it where it changes eligibility, policy or campaign structure. The rest of the effort goes into product_type.
`product_type` is your own breadcrumb, up to 750 characters, such as Home > Women > Dresses > Maxi Dresses. You can send up to five values. Only the first one organizes bidding and reporting, so send one detailed path.
| Attribute | Whose taxonomy | Format | Where it gets used |
|---|---|---|---|
google_product_category | Google's fixed list | One numeric ID or one full path, never both | Required attributes, policy, Shopping product groups in 11 countries, Meta catalogs |
product_type | Yours | Breadcrumb with " > " separators, first value counts | Bidding and reporting in every country, relevance, OpenAI product feeds |
The country detail matters. Outside those 11 markets (the US, the UK, Italy and the Netherlands among them), only product type can organize product groups. Google Ads lets you subdivide by product type up to five times, so the first five levels of your breadcrumb should be the ones you actually bid on. The Google Merchant Center guide covers the other identity attributes, including when you need a GTIN and what to do without one.
How the Google product taxonomy is structured
It's a published list of categories with numeric IDs, 21 top-level branches and uneven depth. Map to the deepest level that fits, and map with IDs.
Open the taxonomy file and the first line reads Google_Product_Taxonomy_Version: 2021-09-21. That's the public list, even though Google calls its internal taxonomy continuously evolving. Old IDs still work: Google translates older categories to the current version, which is why the value you submit can differ from what Google Ads shows.
What the structure looks like
There are 21 top-level categories, from Animals & Pet Supplies to Vehicles & Parts. Depth is uneven. 2271 - Apparel & Accessories > Clothing > Dresses is fine for a dress. But 187 - Apparel & Accessories > Shoes has no children at all, so a trail running shoe and a stiletto get the same ID. The distinction has to live in product_type and attributes.
Format rules that trip feeds
- ID or path, never both.
2271orApparel & Accessories > Clothing > Dresses. - Escape XML. In an XML feed the path needs
&and>. Unescaped ampersands break the whole file, not one item. - Most specific level. Google's own example is an MP3 player charger: MP3 Player Accessories (
232), not Electronics (222). - Required IDs. Contract phones need
267, tablets4745, gift cards53, and alcohol sits under499676or its subcategories. Run new categories past the Google Merchant Center requirements checklist before you submit.
Why we map with IDs
Category IDs are the same in every language version of the taxonomy. If you sell in Italy and the Netherlands from one catalog, you map to IDs once. Localized path strings break the first time someone edits a translation.
How to map product descriptions to the taxonomy at scale
Start with a lookup table, add rules for mixed nodes, use AI with a shortlist for the leftovers, and send the disagreements to a person.
Map the tree, then the leftovers. A catalog with 400 leaf categories needs 400 decisions plus a few rules. That's a week, where classifying 20,000 SKUs one at a time is a quarter.
- 1
Export your category tree
Pull every leaf node with its product count from your platform or PIM. Skip collections like New In.
- 2
Map each leaf to one Google ID
A two-column lookup table: your node, Google's ID. Pick the deepest match and note the judgment calls.
- 3
Split the mixed nodes
An Accessories node holds belts and bags alike. Add rules on title keywords or attributes (if
titlecontains "belt", use169). - 4
Clean up product_type
Replace "Sale" and "New In" with the real breadcrumb. In OpenAI's feed,
product_typetakes priority over Google's category. - 5
Classify the leftovers from descriptions
Products with no usable node go to an AI step that picks from a shortlist (below).
- 6
Push and compare
Send both attributes through a supplemental data source keyed on
id. Review only the products where Google's category disagrees with yours.
Mapping from the product description when the tree is no help
This is where generic AI tools go wrong. Ask a model for the Google product category and it returns a plausible path that doesn't exist in the file. We've seen feeds with hundreds of those.
What works is the setup researchers use. A dual-expert approach presented at an ACL workshop has a domain model propose the top candidate categories, then a general LLM compares them and picks one. In practice:
- Build the shortlist from keywords in the title and description, matched against the taxonomy (10 to 20 candidates).
- Give the model the product's text, its attributes and the shortlist with IDs. Ask for one ID from the list, plus a confidence level.
- Reject any answer that isn't on the list. Send low-confidence products to a person.
DataWeave reported 92% accuracy across 1,240 fashion classes with a translation-style model. Every method still fails on a description that never names the product. "Our softest piece yet" can't be classified by anyone.
| Method | Good for | Breaks when |
|---|---|---|
| Lookup table by category node | Most of a catalog with a clean tree | Nodes are collections, not product types |
| Keyword rules on title | Splitting mixed nodes | Titles are brand names with no product noun |
| AI with a shortlist | Leftovers and messy supplier data | Descriptions don't name the product |
What a fixed row looks like
title
BeforeTrail Runner 2
AfterFjellsko Trail Runner 2 Women's Waterproof Trail Running Shoes, Slate Grey
product_type
BeforeNew In
AfterHome > Women > Shoes > Running Shoes > Trail Running Shoes
google_product_category
Before(empty)
After187
description
BeforeOur lightest shoe yet. Built for adventure.
AfterWaterproof women's trail running shoe with a membrane upper, 6 mm lugs for wet rock and mud, and a 280 g weight in size 38.
attributes
Beforecolor: grey
Aftergender: female; age_group: adult; color: slate grey; material: recycled mesh; waterproof: yes
The Google category barely mattered here, because Shoes is a leaf. The title and product_type did the work. See product feed optimization for supplemental sources and rules.
Categories beyond Google: Meta, Shopify and ChatGPT
Meta accepts Google category IDs, Shopify has its own taxonomy, and OpenAI's feed reads product_type before the Google category. One clean mapping serves all of them.
Meta accepts Google category IDs (and its own fb_product_category) and recommends a Google category on every product. In the US, Meta uses it to decide which items need a size. On Shopify, categories are required if customers check out on Facebook and Instagram, and they must be at least two levels deep.
Shopify now runs its own Standard Product Taxonomy, open source under MIT on GitHub. It suggests a category with AI and maps existing Google categories only when the value matches the English taxonomy exactly or comes as an ID. A shortened or reworded path won't map.
Then the AI channels. OpenAI's product feed spec has an optional product_category path. In Google-compatible feeds it reads product_type first and uses google_product_category only when product_type is empty. If your product_type says "New In", that's what ChatGPT sees. On the page, schema.org's `category` property takes the same kind of breadcrumb.
The category gets a product into the candidate set. The attributes and description get it picked. That's the core idea of Agentic Commerce Optimization, and it's why we treat taxonomy as the first step, never the whole job. More in how to get recommended by ChatGPT.
How AndromedAI helps
AndromedAI fixes the titles, descriptions and attributes that every category mapping, rule or classifier depends on, and publishes them to Google Merchant Center and your store.
Keep your mapping table in your PIM or feed tool. We fix the product data it depends on. The Optimizer rewrites titles and descriptions so they name the product type, and extracts attributes like material, fit or waterproofing that both classifiers and agents read. The free AI Readiness Audit scores Shopping Metadata alongside three other dimensions. Through integrations, AndromedAI imports from Shopify, Akeneo, SAP or XML feeds and publishes to Google Merchant Center, Shopify and Shopware, among others.
ROAS on Google Shopping, with CPC down 6%
Instalhours saved monthly in catalog management
Global Markorganic traffic
SemprefarmaciaFAQ
It's Google's fixed product taxonomy, sent as the google_product_category attribute with a numeric ID such as 2271 or a full path. Google assigns a category to every product automatically, so the attribute works as an override. Most catalogs only need it where it changes eligibility, policy or campaign structure.
No. Google accepts it as an override for categories with required attributes like apparel, mobile phones and software, for campaigns organized by category, and for alcohol. Elsewhere, a detailed product_type is the better use of time.
google_product_category uses Google's list of categories. product_type is your own breadcrumb of up to 750 characters, used for Shopping bidding and reporting in every country. You can send up to five product_type values, but only the first one organizes bidding, so make it one detailed path.
Map your category tree to Google IDs with a lookup table first. For the products left over, build a shortlist of 10 to 20 candidate categories from keywords in the title and description, ask the model to pick one ID from that list, reject answers outside it and send low-confidence cases to a person.
OpenAI's product feed spec has its own product_category path. In Google-compatible feeds it reads product_type first and uses google_product_category only when product_type is empty. A product_type like New In or Sale tells ChatGPT nothing about what the product is.
Glossary
- Google product taxonomy
- Google's published list of product categories with numeric IDs, downloadable as a text or Excel file in many languages
- google_product_category
- Merchant Center attribute that overrides the category Google assigns automatically, sent as one ID or one full path
- product_type
- Merchant Center attribute for your own category breadcrumb, up to 750 characters, used for Shopping bidding and reporting
- Supplemental data source
- A secondary Merchant Center source, keyed on id, that adds or overrides attributes without changing the primary feed
- Shopify Standard Product Taxonomy
- Shopify's open source category system, with category metafields such as size or fabric attached to each category
Keep reading
Every attribute Google reads, and how to fix diagnostics
Read nextProduct Information Management (PIM) in the AI Era: The Complete GuideBuild the source of truth your category mapping lives in
Read nextProduct Feed Optimization: The Complete Guide for Google, Meta and AI ChannelsRun one feed that performs on every channel
Read nextGTINs Explained: When You Need Them and What to Do WithoutThe other identifier Google uses to classify your products
Sources (12)
- Google Merchant Center Help: Google product category
- Google Merchant Center Help: Product type
- Google: Product taxonomy with IDs (en-US)
- Google Ads Help: Manage a Shopping campaign with product groups
- Meta for Developers: Product categories
- Shopify Help Center: Shopify's product taxonomy
- Shopify Help Center: Providing Google product categories for Facebook and Instagram
- GitHub: Shopify product-taxonomy
- OpenAI: Product feed spec
- ACL Anthology: E-Commerce Product Categorization with LLM-based Dual-Expert Classification Paradigm
- DataWeave: AI-driven mapping of retail taxonomies, part 2
- Schema.org: category
Parlano di noi








