How to map Shopify video and 3D models to schema for AI search

At Pendium, we watch Shopify merchants lose critical visual real estate in AI recommendations daily because their rich media is completely invisible to large language models. While customers increasingly rely on conversational engines like ChatGPT and Google AI Overviews to visually compare products, standard theme code fails to translate product videos and 3D models into structured data. Resolving this discoverability gap requires bypassing default theme scripts and deploying a custom, nested JSON-LD graph that maps your media files using schema.org properties like subjectOf and 3DModel. This technical guide walks through exactly how to structure and inject these rich media properties directly into your Shopify Liquid templates so multimodal AI bots can cite and render your visual assets.

Why the default Shopify theme schema drops your rich media

Shopify storefronts are built to display beautiful galleries to human visitors, but search engine crawlers and large language models see the web through raw code. Shopify themes auto-emit a basic Product JSON-LD block on every product page, which typically contains basic properties like name, description, price, and primary image files. However, this native output almost always ignores interactive 3D assets, AR models, and embedded product demonstration videos. This limitation is documented in our analysis of Why AI bots read your Shopify Liquid code instead of product specs, which details how bots bypass visible page layouts to parse underlying data.

When search bots cannot find structured metadata for these files, they classify your page as a text-only listing. Standard Shopify themes fail to emit these media fields by default because they rely on JavaScript-based gallery players to load videos and 3D models. Because web crawlers and AI indexing bots like GPTBot or OAI-SearchBot do not reliably execute heavy client-side JavaScript, they miss these assets entirely. They require server-side rendered, machine-readable structured data to confirm the files exist and understand their properties.

This technical gap has massive commercial consequences. According to data published on the Shopify Blog, AI-driven traffic to Shopify sites grew eight times year-over-year in 2025, alongside a 15x growth in AI-driven orders. If your products lack structured media files, search engines will exclude them from image-rich carousels and visual shopping results. To capture this expanding traffic source, merchants must manually feed these files into their structured data using the correct schema properties.

To verify what your theme currently hides, examine the auto-emitted schema on your product detail pages. Standard implementations drop critical rich media fields, which prevents conversational engines from retrieving them. According to technical guides on Shopify Product Schema: 5 Fields Your Theme Won't Emit, these omissions leave major blind spots in your catalog. Fixing this requires building a customized, server-rendered JSON-LD schema that overrides default theme outputs.

Structuring video objects for multimodal crawlers

To ensure AI crawlers index your product demonstration videos, you must translate them into structured VideoObject schema blocks. This structure allows conversational search tools to understand the contents, duration, and thumbnail of your video before rendering it to users. Merely hosting a video file on Shopify's servers does not make it discoverable; you must declare it explicitly within the parent product entity.

Correcting the auto-generated poster frame

Shopify automatically generates a poster frame for uploaded videos at roughly the one-second mark, which is often blurry or black. To prevent search engines from displaying an unappealing preview, you must explicitly upload and map a high-quality custom thumbnail image. According to specifications from Shopify Product Video and 3D Media Specs 2026 | Konvrt, your thumbnail should match the exact aspect ratio of the source video to avoid distortion in search displays.

Your JSON-LD schema must point to this custom thumbnail URL. If you skip this step, search engine validators will return warning messages or pull the incorrect auto-generated placeholder. By declaring the thumbnail file path directly in the VideoObject metadata, you control the exact visual preview displayed in search engine result pages and conversational interfaces.

Defining the VideoObject properties

A valid VideoObject schema must contain specific fields to meet modern search and discovery requirements. The most important properties include:

• name: A concise, descriptive title for the product video.
• description: A brief summary detailing what the video demonstrates.
• thumbnailUrl: An array containing the absolute path to your custom poster frame.
• uploadDate: The publication date formatted in ISO 8601 syntax.
• duration: The length of the video formatted as an ISO 8601 duration (for example, PT1M30S for one minute and thirty seconds).
• contentUrl: The direct, un-redirected path to the hosted MP4 file.

Here is how you map these properties within your Shopify Liquid template to dynamically generate the schema for each product:

{% assign product_video = product.media | where: "media_type", "video" | first %}
{% if product_video %}
"subjectOf": {
  "@type": "VideoObject",
  "name": {{ product.title | append: " Demonstration Video" | json }},
  "description": {{ product.description | strip_html | truncatewords: 30 | json }},
  "thumbnailUrl": [
    {{ product_video.preview_image | image_url: width: 1920 | json }}
  ],
  "uploadDate": "2026-01-01T08:00:00+00:00",
  "duration": "PT0M45S",
  "contentUrl": {{ product_video.sources | where: "format", "mp4" | first.url | json }}
}
{% endif %}

Using Liquid logic ensures the script runs entirely on Shopify's servers before sending the HTML to crawlers. This approach guarantees that AI search engines parse the video data without needing to run JavaScript.

Configuring the 3DModel schema for Merchant listings

As visual and spatial computing platforms expand, search platforms are prioritizing interactive product previews. Translating your physical goods into digital assets like glTF and GLB files makes them highly valuable for visual search engines. However, these models will not display in modern search results unless they are explicitly bound to your product's schema graph.

The 2025 Merchant listing requirements

Recent updates to search engine merchant specifications have introduced direct support for interactive three-dimensional previews. As outlined in the guide on Google's Merchant listing structured data update, sellers can now declare a 3D model directly under the product's main node. This structured markup is used by AI engines to build interactive, spatial previews directly in conversational search panels.

To qualify for these interactive experiences, the product schema must use the subjectOf property to point to a 3DModel object. This property informs the search crawler that a spatial model is available for rendering. The search engine can then load your interactive model directly inside search results, which drastically improves user engagement.

Mapping glTF and GLB file paths

Your 3D model schema must include the exact, absolute URL of the model file hosted on Shopify. Shopify's administrative backend allows merchants to upload GLB models directly, but themes do not automatically output the file paths in a structured manner. You can extract this data using Liquid loops that inspect the product's media array.

When building your structured data block, always confirm that your model files are publicly accessible and use standard formats. The following Liquid block shows how to safely extract and map your 3D models inside the parent Product schema:

{% assign product_model = product.media | where: "media_type", "model" | first %}
{% if product_model %}
"subjectOf": {
  "@type": "3DModel",
  "name": {{ product.title | append: " 3D Model" | json }},
  "encoding": [
    {
      "@type": "MediaObject",
      "contentUrl": {{ product_model.sources | first.url | json }},
      "encodingFormat": "model/gltf-binary"
    }
  ]
}
{% endif %}

This snippet locates the first model file associated with your Shopify product and structures it using the schema.org 3DModel format. It ensures that the model's direct URL is cleanly exposed to crawlers, allowing them to download and cache the asset for interactive display.

Injecting and validating the consolidated graph

Writing individual JSON-LD snippets for your videos and 3D models is only half the battle. If these snippets are injected as disjointed blocks throughout your Shopify theme, they will create duplicate, conflicting entities. Search engines will struggle to associate the media files with the correct price and availability data, which often results in indexing errors.

Disabling disjointed app scripts

Many Shopify merchants make the mistake of using multiple third-party apps to handle different elements of their search optimization. One app might inject review stars, another might handle video sitemaps, and the native theme handles basic pricing. This creates a fragmented codebase containing multiple, disconnected Product blocks.

To build a clean, unified graph, you must consolidate your structured data into a single schema block. As explained in the developer documentation from Zest Web Solutions, you should disable native theme schemas and instead use a centralized theme snippet. Combine your pricing, review stars, identifiers, videos, and 3D models into a single parent entity.

For a truly unified e-commerce schema, you should also integrate other critical product identifiers like barcodes. In our guide on how to Map Shopify barcodes to GTIN schema for AI search visibility, we explain how matching these identifiers helps search engines link your rich media to global product catalogs.

Consolidating your structured data into this format prevents duplicate entity errors in Google Search Console. It provides a single source of truth that search crawlers can parse in a single pass.

Testing with the Schema validator

After injecting your consolidated Liquid code into your product template, you must validate the output. Do not assume your code works because it renders without syntax errors in Shopify. Use the official Schema Validator (validator.schema.org) and Google's Rich Results Test to inspect the page.

Paste your live product URL into the validation tool and confirm that the parser detects exactly one parent Product entity. Ensure that this entity contains nested VideoObject and 3DModel blocks under the subjectOf property. If the validator displays multiple top-level Product nodes, go back to your theme files and remove the duplicate template scripts.

Once your 3D models and videos are correctly mapped, you are no longer just feeding plain text to AI crawlers. You are giving them the assets they need to construct interactive, visual product recommendations. The next step is to measure exactly how these search engines and conversational bots interpret your newly optimized catalog. To check how these platforms see your brand, you can Scan Your AI Visibility | Pendium | Pendium.ai to discover which channels are rendering your visual products correctly and where competitors are capturing your potential customers.