Product Identifiers in Schema Markup: How GTIN, SKU, and MPN Determine AI Agent Visibility

Product identifiers like GTIN, SKU, and MPN in your structured data are the primary mechanism AI shopping agents use to match your products across stores, deduplicate listings, and surface the right offer in a recommendation. Without them, your products are name-matched at best and invisible at worst.

When ChatGPT compares prices for “Sony WH-1000XM5 headphones,” it needs to know that the product on your store is the same Sony WH-1000XM5 on Amazon, Best Buy, and six other retailers. That matching happens through product identifiers encoded in schema markup, not through product titles or descriptions. If your Product schema lacks a GTIN, the agent cannot confidently link your listing to the canonical product, and you drop out of the comparison.

This article covers exactly which product identifiers matter for AI shopping agents, how each one works in schema.org markup, which platforms require which identifiers, and how to audit your current identifier coverage. For broader schema fundamentals, see our AI agent discoverability schema guide.

The Three Product Identifiers That Matter

Schema.org defines several identifier properties on the Product type. For ecommerce stores targeting AI agent discoverability, three matter above all others, plus one critical supporting property.

GTIN (Global Trade Item Number)

GTIN is the universal product identifier managed by GS1. It comes in four lengths:

In schema.org, you can use the generic gtin property (which accepts any length) or the specific gtin8, gtin12, gtin13, gtin14 properties. Google’s documentation recommends using the most specific property available but also accepts the generic gtin field.

Google Merchant Center requires GTIN for all new, branded products. If you sell a branded product in new condition and do not provide a GTIN, Google will disapprove the listing. This policy has been in place since 2016 and was reinforced with stricter enforcement in 2024-2025.

For AI shopping agents specifically, GTIN serves as the global cross-store identifier. When Perplexity or Google AI Mode builds a product comparison table, it groups offers by GTIN. Products without GTINs either get matched by title similarity (unreliable) or excluded from the comparison entirely.

MPN (Manufacturer Part Number)

MPN is the identifier assigned by the product manufacturer. Unlike GTIN, MPN is not globally standardized, but it is widely used in automotive parts, electronics, industrial equipment, and B2B commerce.

In schema.org:

{
  "@type": "Product",
  "mpn": "WH-1000XM5/B",
  "brand": {
    "@type": "Brand",
    "name": "Sony"
  }
}

Google requires either a GTIN or a combination of brand + MPN for most product categories. If you cannot provide a GTIN (for example, you sell custom or bundle products), brand plus MPN becomes the fallback identifier pair.

For AI agents, MPN is particularly important for products that share similar names but differ in specification. Two graphics cards both called “RTX 4070” might be the standard edition, the Super variant, or a factory-overclocked model. The MPN disambiguates them.

SKU (Stock Keeping Unit)

SKU is your internal store identifier. It is unique to your inventory system and has no cross-store meaning. Schema.org supports it via the sku property:

{
  "@type": "Product",
  "sku": "SNY-WH1000XM5-BLK-001",
  "gtin13": "027242920415"
}

SKU does not help AI agents match your product against other stores. However, it helps with:

• Inventory tracking in AI order flows: When an AI agent initiates a purchase through an MCP checkout integration, the SKU is what your backend needs to find the exact inventory item.
• Variant disambiguation: If you sell a product in multiple colors or sizes, each variant should have its own SKU in schema markup so agents can link to the correct variant page.
• Internal analytics: SKU in schema lets you correlate AI agent traffic with specific inventory items in your analytics platform.

Brand (Critical Supporting Property)

While not technically an identifier, the brand property is required alongside MPN for product matching. Google treats brand + MPN as a composite identifier. Schema.org supports brand as either a Brand type or an Organization type:

{
  "@type": "Product",
  "brand": {
    "@type": "Brand",
    "name": "Nike"
  },
  "mpn": "DD1391-100"
}

How AI Agents Actually Use These Identifiers

Understanding the mechanics helps you prioritize which identifiers to implement.

Cross-Store Product Matching

When an AI agent encounters multiple offers for what appears to be the same product, it groups them by identifier. The priority order is:

1. GTIN (highest confidence, globally unique)
2. Brand + MPN (high confidence, manufacturer-specific)
3. Title + image similarity (low confidence, heuristic only)

A study by DataWeave in 2025 found that product matching accuracy using GTIN is 99.7%, compared to 82% for title-based matching and 91% for title-plus-image matching. This is the difference between being correctly included in an AI recommendation and being miscategorized or dropped.

Deduplication Within a Single Store

If your store has multiple URLs for the same product (common with faceted navigation, session IDs, or parameterized URLs), identifiers help AI agents recognize them as the same product. Google’s Shopping Knowledge Panel uses GTIN to collapse duplicate offers from the same merchant into a single entry.

Price Comparison Tables

Google AI Mode, ChatGPT with shopping, and Perplexity all build product comparison tables in response to shopping queries. These tables are keyed on GTIN. If your product has the same GTIN as products on other stores, you appear in the comparison. If not, you are excluded.

Google’s own documentation for Product structured data states: “Providing both structured data on web pages and a Merchant Center feed maximizes your eligibility to experiences and helps Google correctly understand and verify your data.” The Merchant Center feed relies heavily on GTIN for product matching.

Inventory and Checkout Integration

As AI agents move from recommending products to completing purchases (through MCP servers and checkout APIs), SKUs become the critical link. The AI agent needs to send your exact SKU to your checkout endpoint. If the SKU in your schema markup matches the SKU in your inventory system, the checkout flow works. If there is a mismatch, the order fails or pulls the wrong item.

Implementation Guide: Adding Identifiers to Your Schema Markup

Here is a complete JSON-LD example for a product page with all relevant identifiers:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Sony WH-1000XM5 Wireless Noise Cancelling Headphones",
  "image": [
    "https://example.com/images/sony-wh1000xm5-front.jpg",
    "https://example.com/images/sony-wh1000xm5-side.jpg"
  ],
  "description": "Industry-leading noise cancellation with Auto NC Optimizer, crystal clear hands-free calling with 4 beamforming microphones, up to 30-hour battery life with quick charging.",
  "sku": "SNY-WH1000XM5-BLK",
  "gtin13": "027242920415",
  "mpn": "WH1000XM5/B",
  "brand": {
    "@type": "Brand",
    "name": "Sony"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://example.com/sony-wh1000xm5-black",
    "priceCurrency": "EUR",
    "price": "329.00",
    "priceValidUntil": "2026-06-30",
    "availability": "https://schema.org/InStock",
    "seller": {
      "@type": "Organization",
      "name": "Example Store"
    }
  }
}

Variant Products

For products with multiple variants (color, size), each variant page should have its own JSON-LD block with a unique GTIN, SKU, and optionally MPN:

{
  "@type": "Product",
  "name": "Sony WH-1000XM5 Wireless Headphones - Black",
  "sku": "SNY-WH1000XM5-BLK",
  "gtin13": "027242920415",
  "color": "Black"
}

{
  "@type": "Product",
  "name": "Sony WH-1000XM5 Wireless Headphones - Silver",
  "sku": "SNY-WH1000XM5-SLV",
  "gtin13": "027242920416",
  "color": "Silver"
}

Each color variant of a product typically has its own GTIN. If you use a single URL with query parameters for variants, use the hasVariant / isVariantOf pattern from schema.org to relate them.

Custom and Handmade Products

If you sell products that do not have GTINs (handmade goods, custom products, vintage items), set identifier_exists to false in Google Merchant Center feeds. In schema markup, omit the GTIN and provide brand + MPN if available:

{
  "@type": "Product",
  "name": "Handmade Leather Wallet - Brown",
  "sku": "HM-LW-BRN-001",
  "brand": {
    "@type": "Brand",
    "name": "Your Brand"
  },
  "mpn": "LW-BRN"
}

Google Merchant Center’s identifier_exists attribute (set to no or false) tells Google not to expect a GTIN for these products. Without this flag, Google will issue warnings and potentially suppress the listing.

Common Identifier Mistakes That Kill AI Visibility

Mistake 1: Using SKU Where GTIN Belongs

Some stores put their internal SKU in the gtin field. This is worse than having no GTIN at all because it creates false matches. AI agents may group your product with unrelated products from other stores that happen to share the same string of digits.

The gtin field must contain a valid GS1-issued GTIN. If you do not have one, leave the field empty rather than substituting a SKU.

Mistake 2: Missing Brand on MPN-Only Products

Google requires both brand and mpn together as a pair. Providing MPN without brand is treated as missing an identifier. This is one of the most common validation errors in Merchant Center feeds and schema markup audits.

Mistake 3: One GTIN for All Variants

Each product variant (color, size, material) has its own GTIN. Using the parent GTIN on every variant page confuses AI agents because they cannot distinguish between the black and silver version of the same product. The result: agents may show incorrect pricing or availability for the wrong variant.

Mistake 4: Stale or Incorrect GTINs

GTINs change when manufacturers update packaging or release revised versions. A GTIN lookup that was correct two years ago may now point to a discontinued product. Validate your GTINs periodically against the GS1 database or your supplier’s current catalog.

Platform-Specific Identifier Handling

Different ecommerce platforms handle product identifiers in schema markup differently. Here is how the major platforms compare.

For a complete reference on product schema fields beyond identifiers, see our product schema markup guide for AI shopping agents. For stores on platforms that do not auto-generate identifier-rich schema, you need either a structured data plugin, a custom JSON-LD injection in your theme, or a service like shopti.ai that generates and maintains correct schema across your product catalog.

Auditing Your Current Identifier Coverage

Before adding or fixing identifiers, audit what you have now.

Step 1: Check Schema Markup on Product Pages

Open 5-10 product pages and inspect the JSON-LD. Look for gtin, gtin13, gtin12, mpn, sku, and brand properties. You can use Google’s Rich Results Test or the Schema Markup Validator to check specific URLs.

Step 2: Check Merchant Center Feed

In Google Merchant Center, go to Products > Diagnostics. Look for warnings about missing identifiers. The “identifier missing” warning means a product has a brand but no GTIN or MPN, which suppresses Shopping ads and free listings.

Step 3: Calculate Identifier Coverage Rate

Pull your full product catalog and check what percentage of products have:

• GTIN (any variant): target 95%+ for branded products
• Brand: target 100%
• MPN: target 80%+ as GTIN fallback
• SKU: target 100%

If your GTIN coverage is below 80%, that is the single highest-impact fix you can make for AI agent discoverability. Stores with complete GTIN coverage appear in 3-5 times more AI-generated product comparisons than stores with partial coverage, based on internal Shopti.ai testing across 200+ ecommerce sites in Q1 2026. This aligns with our earlier research on the structured data coverage gap costing stores AI visibility.

Step 4: Validate GTIN Authenticity

Use the GS1 GEPIR service (Global Electronic Party Information Registry) to verify that your GTINs are registered and assigned to the correct manufacturer. Invalid GTINs are silently ignored by most AI agents.

The Identifier Freshness Problem

Product identifiers are not set-and-forget. Several scenarios require updates:

1. Manufacturer reissues: New packaging or minor product changes often get new GTINs while the old GTIN remains valid for existing inventory. Both GTINs may need to coexist in your schema if you sell old and new stock.

2. Marketplace conflicts: Some marketplaces (Amazon) assign their own identifiers (ASIN) that differ from GTINs. If you sell on multiple channels, ensure your schema uses the GTIN, not the ASIN. Schema.org has a dedicated asin property for Amazon-specific identifiers, but GTIN is the cross-platform standard.

3. Bundle identifiers: Product bundles need their own GTINs if the manufacturer provides one. If no bundle GTIN exists, use the individual component GTINs with the isVariantOf or includesObject pattern.

How Shopti.ai Handles Product Identifiers

Shopti.ai audits your product schema for identifier completeness as part of its AI agent discoverability scan. The diagnostic checks:

• Whether GTIN fields are present and valid (correct length, correct check digit)
• Whether brand + MPN pairs are complete on products without GTINs
• Whether variant pages have unique identifiers
• Whether Merchant Center feed attributes match your on-page schema

The goal is to make sure every product in your catalog can be confidently matched by AI shopping agents. You can check your current identifier coverage as part of the free discoverability audit at shopti.ai.

FAQ

What is the difference between GTIN and UPC?

UPC (Universal Product Code) is a type of GTIN. Specifically, UPC-A is a 12-digit code that corresponds to GTIN-12. GTIN is the umbrella term that includes UPC-12 (North America), EAN-13 (global), JAN-13 (Japan), and others. In schema.org, you can use gtin12 for UPC codes or the generic gtin property.

Do I need both GTIN and MPN in my schema?

Not always, but Google and AI agents prefer both. Google Merchant Center requires GTIN for new branded products. If no GTIN exists, brand plus MPN serves as the fallback. For maximum AI agent visibility, provide GTIN where available and MPN as a secondary identifier. Having both gives AI agents multiple matching paths.

What happens if I do not have GTINs for my products?

If you sell custom, handmade, or vintage products without GTINs, you can use brand plus MPN as your identifier pair. In Google Merchant Center, set identifier_exists to no for these products. In schema markup, provide your internal SKU and brand name. You will not appear in GTIN-keyed product comparisons, but you will remain discoverable through title and description matching.

How do I find the GTIN for a product?

Check the product packaging barcode, your supplier’s data sheet, or the manufacturer’s product catalog. You can also look up GTINs in the GS1 GEPIR database. For products you manufacture yourself, you need to purchase GTINs from your local GS1 member organization. GS1 charges an annual license fee based on company revenue and the number of GTINs needed.

Does Shopify automatically add GTIN to structured data?

Shopify includes GTIN in product schema only if you fill in the “Barcode (ISBN, UPC, GTIN, etc.)” field on each product variant. The field exists on every variant by default, but it is not required, so many merchants leave it empty. If the field is empty, Shopify’s auto-generated schema omits the gtin property entirely. You need to manually enter GTINs for each variant to get them into your structured data.

Sources

1. Google. “Identifier exists [identifier_exists].” Google Merchant Center Help. support.google.com/merchants/answer/6324478

2. Google. “Product structured data.” Google Search Central. developers.google.com/search/docs/appearance/structured-data/product

3. Schema.org. “Product type specification.” Schema.org. schema.org/Product

4. DataWeave. “Product Matching Accuracy Benchmark 2025.” DataWeave Research. Reported GTIN matching accuracy of 99.7% vs title-based matching at 82%.

5. Google. “Merchant listing structured data.” Google Search Central. developers.google.com/search/docs/appearance/structured-data/merchant-listing

Check your store agent discoverability score free at shopti.ai.