How to Prepare Your Online Store for AI Recommendations: Catalog, Product Cards, Schema Markup, and FeedsLongread · digest for November 21
Studio still life with a tablet showing a product card, SKU, GTIN, and MPN identifier badges, and cards illustrating the stages of an AI agent checking an online store.
Longread7 sections≈ 28 min

How to Prepare Your Online Store for AI Recommendations: Catalog, Product Cards, Schema Markup, and Feeds

The TexTerra team recently ran a telling experiment. They sent an AI agent to buy products in real Russian online stores. At first, things looked great: the bot found the right product pages on every single site. Then came the cold shower. The agent could only read the public price in half of the tested 'query + store' pairs, and it reached a confirmed cart step in just one third of cases. The other stores looked visible in search and feeds, yet to an AI system they felt like a shop window with no price tags and a locked door.

That is the main trap for e-commerce owners. Many assume that exporting a price list into a product feed will make AI assistants send ready-to-buy shoppers. It will not. In a detailed breakdown by Sergey Lomakin on the TexTerra blog, he shows why AI services do not trust a feed on its own. He also explains how to rebuild your catalog, product cards, structured data, and exports so you do not confuse product visibility with actual ability to buy. Let's walk through the whole system step by step, from category structure to a 90-day rollout plan.

Why an AI Agent Sees Your Card but Loses the Buyer Before Checkout

Let's look at how AI product discovery works today. Shoppers no longer type dry queries like 'buy robot vacuum Moscow'. Instead, they ask as if talking to a store clerk: 'Which robot vacuum under 30,000 rubles should I pick if I have a fluffy cat at home?' This is where GEO (Generative Engine Optimization) begins. You structure your site and product data so generative systems like Yandex with Alice or ChatGPT can find the page, parse the specs, compare models, and recommend you accurately.

To answer that prompt, an AI service pulls puzzle pieces from several layers at once. It checks brush types, filters by budget, and reviews ratings, regions, and delivery terms. Yandex Goods, for example, reads data from both your product feed and your regular site pages. If the feed lists one price, the product page shows another, and shipping terms sit inside a pop-up image, the algorithm stumbles. Optimizing for one platform does not guarantee results on another either, because each service crawls and verifies data differently.

TexTerra Experiment: How Many Stores the AI Agent Passed at Each Step

The chart clearly shows the gap between 'they found me' and 'they bought from me'. The closer the agent gets to an actual order, the more stores drop out over small technical issues: a hidden price, a broken variant switcher, or mismatched inventory. You end up paying for development and content, getting noticed by the algorithm, and then losing the sale to a competitor whose page is easy to parse.

To keep systems from getting confused, your store needs a clear split of roles between pages. A category page acts like a floor consultant: it helps compare several models using clear criteria. A product card handles the finish line: the exact variant, exact price, warehouse stock, warranty, and delivery. Sometimes an algorithm pulls pieces from both pages for one query. For instance, if a shopper asks about vacuum delivery to Tula, the service might take model options from the category and delivery terms from the product card. As the author puts it, match the page to the buyer's task, not to whatever stock happens to sit in your warehouse.

Catalog and Faceted Filters: How Not to Drown Search in Empty Duplicates

Most catalogs are sliced the way an accountant or inventory software likes it: 'Home Appliances -> Vacuums -> Robot Vacuums'. Shoppers think in terms of their own problem. If someone lives with a fluffy Maine Coon, they want a section like 'Robot Vacuums for Pet Owners' that explains what matters right from the top.

You do not need a 5,000-character wall of SEO text at the start of that category. A short intro of a few lively sentences works better: which brush design stops hair from tangling, how the robot handles rugs, what threshold height it can climb, and when a self-emptying dock actually makes sense. It is also helpful to bust a common myth right there: high suction power in pascals alone does not prove a vacuum picks up pet hair from carpet.

Right below the intro, place a plain HTML table of five to ten current models. Use columns for the specs people actually compare: brush type, max threshold height, self-emptying dock, and price. Make each model name a clickable link to its product card. You can add a nice infographic beside it for visual appeal, but keep all text and numbers in clean HTML so both shoppers and bots can read them easily.

Another common mistake is making unsupported claims in descriptions. Writing 'this robot vacuum is great with pet hair' is easy, but both people and AI models ignore empty adjectives. If you make a claim, back it up: point to the manufacturer's manual or describe your own quick test (which floor type you used, which mode, and what ended up on the brush). No measurements? Stick to verified design facts without big promises. The same goes for updates: list variants with different specs separately, and only change the roundup's update date after you actually re-check prices and stock. Faking a fresh date does not speed up indexing or boost rankings.

Now let's talk about filters, or faceted navigation. A faceted page is a filtered product list your site builds from one or more attributes, such as 'Robot Vacuums with Self-Emptying Dock'. It is useful, yet risky: if you let search engines index every filter combination, your site can generate tens of thousands of junk URLs overnight that mostly duplicate the main category.

Follow a simple selection rule:

  • Index only high-demand combinations where your catalog actually has enough products to choose from. Give that page a clear title, two lines explaining the selection logic, and a normal HTML link from the catalog. If filtered items go out of stock, reconsider keeping the page in search.
  • Block combinations of three or more filters (plus random mixes like 'white color + sort by price + rare attribute') from indexing. Only make exceptions for narrow queries where both demand and selection clearly exist.
  • Handle duplicates properly. Use rel="canonical" pointing to the main version for similar URLs and sort pages, keeping in mind that canonical is a hint to search engines, not a strict order. Never point a canonical from a useful faceted page to the parent category if they serve different intents. When you need a page out of search results for sure, use the noindex directive. Key detail: do not block that same URL in robots.txt, or the crawler will never load the page to see your noindex tag.

Do not cram complex buying advice into your commercial catalog. Move it into articles and guides. For example, a comparison like 'Robot Vacuum vs. Stick Vacuum: Which Is Better for Pet Hair' belongs in your blog, explains the trade-offs clearly, and links readers to the right category and product cards. From the category page, add a neat link back to that guide so the storefront stays clean. In articles about compatibility and consumables, always include exact model names, device numbers, and part codes, because AI search uses them to connect guides with products. And one more habit: if a popular model is discontinued, do not delete its page with a 404 error. Keep the page and URL live, clearly state that it is discontinued, and show current alternatives with a brief note on how they differ.

Priority Sections and Product Cards: Where the Biggest Bugs Hide

When a store holds 30,000 or 50,000 items, trying to fix everything at once usually kills the project in week two. A smarter start is much smaller: pick 5 to 10 priority categories. Look at two metrics: share of revenue and demand for comparison queries ('which is better', 'for which conditions'). Before you start, check your capacity honestly: does your team have the bandwidth to keep prices, stock, and specs updated in those sections? If not, narrow the pilot.

Inside the product card itself, order starts with identifiers. Stores often mix these up, so keep all three codes in their own corners:

  • SKU — your internal item code in the store's accounting system;
  • GTIN — the global product barcode (such as EAN or UPC);
  • MPN — the manufacturer's factory part number.

Each code must live in its own dedicated field, ideally pulled straight from an accounting system like 1C so content managers never retype digits by hand. If a real GTIN or MPN does not exist or is unverified, leave the field blank or hide it. Putting fake placeholders like 000000 in there is a sure way to break product matching in algorithms.

Infographic diagram of a product card showing three code fields (SKU, GTIN, and MPN), stock status, and direct data sync with 1C and a product feed.

Break specs into separate fields and always include units of measurement: not just '800', but 'power — 800 W' and 'capacity — 2 L'. List different bundles as separate offers: a bare cordless drill without a battery and the same drill in a case with two batteries are two different products, and you cannot mix them in one card.

Write descriptions around real usefulness rather than ad slogans. In the first paragraph, state who the model fits. Next, list honest limits on compatibility and what is in the box. After that, pull recurring questions from customer chats and reviews and answer them with exact SKUs, such as: 'Fits printers X and Y. Version Z requires a different adapter.' Just make sure a product specialist reviews those answers so you do not promise the wrong thing.

Pay close attention to purchase terms. Who provides the warranty, for how long, and with what exclusions? Separate your store's extended warranty from the manufacturer's warranty. For delivery, list supported regions and a clear way to calculate timing, and explain return terms in plain language with a link to the full policy. One critical rule: all of this must sit in plain HTML. If shipping terms are baked into a banner image or hidden inside a tab that loads only after a tricky click, an AI agent simply will not see them.

Do not abandon product cards when an item goes out of stock. Keep the URL alive, display 'Out of stock' prominently, swap the 'Buy' button for a restock alert, and suggest available alternatives with a short note on differences. Most importantly, make sure the out-of-stock status matches in three places at once: on the page itself, in structured data (OutOfStock), and in the product feed, all synced from real inventory.

Schema.org Markup: Making Product, Offer, and ProductGroup Work Together

Even when a product card looks great to humans, AI models and search engines read data far more reliably from a structured code block: Schema.org markup in JSON-LD format. Five core building blocks do the work here:

  • Product describes the item itself (name, brand, identifiers, photos);
  • Offer handles the seller's commercial terms (price, currency, availability, URL);
  • ProductGroup links variants of the same model (such as colors or storage sizes) so algorithms do not confuse them;
  • BreadcrumbList shows where the page sits in your catalog tree;
  • ItemList marks up product lists on category pages.

To connect entities inside a single code block — for example, linking a specific seller (Organization) to each offer (Offer.seller) — you use the technical identifier @id.

Example of product variants displayed with ProductGroup structured data in Google Search (Source: Google Search Central)

Below is a shortened working JSON-LD example from TexTerra's breakdown for a Series A vacuum in white and black. It shows how ProductGroup unites two variants with different SKUs, prices, and stock statuses (replace the demo URLs and values with your real ones before deploying).

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.ru/#seller",
      "name": "Online Store",
      "url": "https://example.ru/"
    },
    {
      "@type": "BreadcrumbList",
      "itemListElement": [
        {
          "@type": "ListItem",
          "position": 1,
          "name": "Catalog",
          "item": "https://example.ru/catalog/"
        },
        {
          "@type": "ListItem",
          "position": 2,
          "name": "Vacuums",
          "item": "https://example.ru/vacuums/"
        }
      ]
    },
    {
      "@type": "ProductGroup",
      "name": "Series A Vacuum",
      "productGroupID": "A",
      "variesBy": ["https://schema.org/color"],
      "hasVariant": [
        {
          "@type": "Product",
          "name": "Vacuum A, white",
          "sku": "A-WHITE",
          "mpn": "MODEL-A-W",
          "color": "white",
          "image": "https://example.ru/img/a-white.jpg",
          "brand": {"@type": "Brand", "name": "Brand A"},
          "offers": {
            "@type": "Offer",
            "url": "https://example.ru/a/?color=white",
            "price": "24990",
            "priceCurrency": "RUB",
            "availability": "https://schema.org/InStock",
            "seller": {"@id": "https://example.ru/#seller"}
          }
        },
        {
          "@type": "Product",
          "name": "Vacuum A, black",
          "sku": "A-BLACK",
          "mpn": "MODEL-A-B",
          "color": "black",
          "image": "https://example.ru/img/a-black.jpg",
          "brand": {"@type": "Brand", "name": "Brand A"},
          "offers": {
            "@type": "Offer",
            "url": "https://example.ru/a/?color=black",
            "price": "25990",
            "priceCurrency": "RUB",
            "availability": "https://schema.org/OutOfStock",
            "seller": {"@id": "https://example.ru/#seller"}
          }
        }
      ]
    }
  ]
}

Notice how cleanly the variants are separated: the white vacuum has its own sku, its own url with a color parameter, price, and InStock status, while the black one has a different SKU, price, and an honest OutOfStock. If variants open at different URLs, each variant must have its own direct link.

Official Google Search Central documentation and the Schema.org spec define two ways to link variants. The first is nested (hasVariant), like in the code above, where all variants sit inside one ProductGroup. The second is flat (isVariantOf), where each variant lives on its own URL as a standalone Product and points back to the parent ProductGroup. A handy perk of this setup is that shared properties — brand, description, model rating, or return policy — can stay at the ProductGroup level so you do not repeat them dozens of times. Just make sure you only add shipping and return terms to markup if they are actually shown on the site and match store policy.

Now for two classic traps that trip up Russian stores. The first is trade offers (variants) in 1C-Bitrix. It happens all the time: a shopper clicks a color switcher, the visible price changes from 24,990 ₽ to 25,990 ₽, yet the JSON-LD in the page source still outputs the default first variant. To a bot, that looks like a price mismatch. After implementation, click through your variant switchers and verify that URL, SKU, price, and availability all update together.

The second trap is AggregateRating. Only output it when the page has real published reviews for that exact model. Slipping your store's overall rating in place of a specific vacuum's rating is strictly off-limits. Run your finished markup through three validators: Google Rich Results Test, Schema Markup Validator, and the Yandex Webmaster validator. Keep a realistic expectation, though: a green light in a validator only proves there are no syntax errors. It does not guarantee rich snippets or a spot in an AI answer.

Product Feeds in Practice: Yandex YML, Google Merchant Center, and OpenAI

While structured data helps a bot understand one page, a product feed is a structured export file that sends your catalog, prices, stock, and links straight to commerce platforms at scale. There is no single magic feed 'for all AI systems at once'. Even more importantly, choosing a platform depends directly on where you sell.

Product panel in Google Search based on structured data and a feed (Source: Google Search Central)

To avoid mixing up formats or spending weeks building channels that will not work for you, here is how the three main systems compare.

PlatformFile FormatAvailability for RussiaKey Required FieldsVariant Grouping
Yandex Goods & DirectYML (XML)#1 priority for Russiaid (up to 80 chars), url, price, currencyId, categoryId, picture, name, availableSeparate <offer> tags linked via group_id and <param>
Google Merchant CenterXML / TSV / APINot supported for sales in Russiaid, title, link, price, availability (strictly matching JSON-LD)item_group_id attribute
OpenAI Product Feed (ChatGPT)jsonl.gz / parquet (SFTP/API)Not first priority (check eligible countries and Business Hub)9 fields: item_id, title, description, url, brand, seller_name, image_url, availability, pricegroup_id and variant_dict fields

Let's look at the practical details for each system, starting with what actually drives Russian e-commerce today.

Yandex YML (Yandex Goods and Direct). Per Yandex Goods documentation, every orderable product offer goes into its own <offer> tag. Create separate offers with stable IDs for different colors or sizes. A smart engineering trick: use the exact same offer id (like A-WHITE) in both your YML feed and Yandex Metrica e-commerce events so analytics and product impressions match cleanly.

<!-- White variant: stable ID matches SKU and Metrica -->
<offer id="A-WHITE" available="true" group_id="A">
  <url>https://example.ru/a/?color=white</url>
  <price>24990</price>
  <currencyId>RUB</currencyId>
  <categoryId>101</categoryId>
  <picture>https://example.ru/img/a-white.jpg</picture>
  <name>Vacuum A, white</name>
  <param name="Color">white</param>
</offer>

This short block packs several Yandex rules. For Russian rubles, both RUB and RUR are supported — use whichever the specific service requires. The group_id attribute is optional for single items, but for grouping variants it works together with <param> tags (color, size, etc.). When an item sells out, pass available="false" or remove it from the active export, because only available offers appear in product listings. You can feed the same YML file to both Yandex Goods and Yandex Direct, as long as you check both services' specs first, since their required fields and processing rules differ.

Now for Yandex's toughest rule, the one that hurts revenue. If the crawler finds wrong prices or broken cards on individual items, it simply pauses those items. However, if errors show up in more than 25% of the checked sample, your entire data source can be suspended from product listings. Match your feed generation schedule to how fast your prices and warehouse stock change, and check the upload error report regularly.

Google Merchant Center. Here is a quick reality check: if your store only sells inside Russia, spending time on Merchant Center right now makes no sense. Russia is not supported as a target country for Shopping Ads or free listings. You only need this feed if you sell internationally — and there, id, item_group_id, price, and availability in the feed must match your site's JSON-LD down to the last digit.

OpenAI Product Feed for ChatGPT. Geography matters here too: for a local Russian store, this is not a month-one task. Onboarding runs through Business Hub after business verification, and you need to check eligible countries and program terms right before starting. If you do sell abroad, follow the current OpenAI Product Feed spec: never reuse an item_id for a different product, format prices as a number with an ISO 4217 currency code (like 79.99 USD), and use fixed availability values in_stock or out_of_stock. The url must open with that exact variant already selected.

Below is a compact interactive simulator built from the real failure points in TexTerra's experiment and platform rules. Toggle the switches to match your store and see whether an AI agent reaches the cart or trips along the way.

Simulator: Will Your Product Card and Feed Pass an AI Agent Check?

The simulator makes the failure point obvious: even with a spotless YML feed, one mismatch between page variants and 1C stock can stall the agent right before checkout. Once your feed is set up, do not trust green checkmarks in the admin panel alone. Run a manual spot-check. Pick a few different product types and a couple of variants of the same model. Compare the ID, direct variant URL, price, and stock in the feed against what actually loads on the site. Then walk through the checkout flow yourself and verify that the selected color or bundle sticks and the final price does not shift.

External Platforms, Reviews, and Weekly AI-Answer Monitoring

An AI model rarely looks only at your website. It cross-checks facts across the open web, including marketplaces and review sites. If a vacuum has one full name on your site, yet your marketplace listing uses a short title with no part number, the algorithm might not even realize they are the same model.

On external platforms, fill in the full model name and manufacturer part number wherever fields allow. Spell out what is in the box clearly — again, a bare tool without a battery and a kit with a battery must stay clearly distinct. Complete your official store profile and link back to your main website if platform rules allow it. On your own site, collect genuine reviews specifically about the products and keep them separate from courier or pickup-point ratings. A shopper choosing a model cares about how it performs, not whether a courier arrived ten minutes late last Tuesday.

How do you know your fixes are actually working? Guessing will not tell you. You need a simple monitoring protocol. Start with a test set of 15 to 20 product queries across your priority categories. Mix real buyer scenarios instead of sticking to one question type:

  • budget picks (for example, 'cordless drill under 12,000 rubles for assembling furniture');
  • comparing two models;
  • finding alternatives;
  • buying with delivery to a specific region;
  • checking warranty terms from a specific seller.

Grade each AI answer strictly on whether it solves the task. If you asked for a cordless drill under 12,000 ₽ for furniture assembly, check whether the suggested model actually fits the budget and the job. If you asked about the warranty on Model X from Seller Y, verify that exact seller's terms rather than generic manual text.

Run checks from the same region and keep a clean spreadsheet: which service you tested, the date, the exact prompt, and your account/session state. Do not rely blindly on incognito mode. It clears some browser history, yet it does not turn off regional or other personalization. Log whether your store was mentioned, the URL, price accuracy, and stock status. Track hallucinations and misses on a separate line — like when an AI names your product but links to a competitor or swaps in the wrong variant. Most importantly, one appearance proves nothing. Run the same list on a fixed schedule, say once a week, and watch the trend across multiple checks.

The 30, 60, and 90-Day Rollout Plan: Starting Without a Bloated Team

To keep this work from turning into an endless rebuild that burns budget without results, split it into three clear 30-day sprints.

First 30 days — priorities and baseline. Pick 5 to 10 priority categories and a pilot pool of products. Audit the foundation: can crawlers reach the pages, and are titles, units, prices, and stock clean? Run your 15 to 20 starter prompts in AI services and record your baseline so you have something to compare against in two months. Your main deliverable for month one is a concrete list of gaps with owners and deadlines.

By day 60 — technical fixes. Fix product card templates and variant links, implement and validate JSON-LD (ProductGroup + Product + Offer), and build or clean up your YML feed. Set up price and stock sync along the chain: 'accounting system (1C) -> website -> feed'. Check 1C-Bitrix trade offers and regional stock as a dedicated item. Wrap up the phase with a test export and check what actually renders on the site and inside the platform's merchant dashboard.

By day 90 — scaling the pilot. Once the first categories run smoothly, add the next sections, open useful faceted filter pages for indexing, and publish interlinked buying guides. Repeat your monitoring across the same 15 to 20 prompts under the same conditions, close remaining gaps, and scale the process only to as many categories as your team can reliably maintain.

Quick Checklist Before Your Test Export

  • Priority categories have a task-focused intro and an HTML table of 5–10 models with links.
  • Junk 3+ filter combinations are blocked with noindex (without blocking in robots.txt), and useful facets do not canonicalize to the parent category.
  • Product cards separate SKU, GTIN, and MPN into their own fields with no fake placeholders, while shipping, warranty, and return terms sit in plain HTML.
  • Switching a variant on the site updates the URL, price, availability, and JSON-LD (ProductGroup/Product/Offer), and the store rating is not mixed into product AggregateRating.
  • The YML feed syncs with stock, error rates stay strictly under 25%, and a sample of products has been tested all the way to checkout.
Want a deep diveVotes help us choose what to break down in detail. This material has 0 votes.
Sources · 6