AI SEO for a fashion brand means making every product, size, color, and collection page readable in plain words and in structured data, so an AI assistant can answer a shopper's question with your product instead of a competitor's. A shopper asks for a linen midi dress in navy, size medium, under a set price, that ships to their country. Your pages need to state the fabric, the fit, the colors, the sizes in stock, the price, and the shipping terms in words a model can quote and in markup a model can check. If the page hides the size list behind a selector, the price behind a script, or the color in a photo with no words, the assistant has nothing solid to cite, and it will pick a brand that states the facts. This guide covers the fashion-specific parts: variants, sizes, colors, seasonal turnover, and collection pages. The shared mechanics live in their own guides and are linked at the end.
A fashion catalog turns over fast. A dress sells out in one size, a color is dropped, and the pages that AI systems read still show the old range. The fix is one source of truth for each product, written in words on the page and repeated exactly in the markup and in the feed, and updated the day the stock changes.
Where it goes wrong
Fashion pages fail in ways that look fine to a human shopper and break for a machine reader.
- The size and color facts live only in a selector. The page shows a dropdown or a row of swatches, and the words on the page never say which sizes exist or which are in stock. A model that reads the page text cannot tell a size medium in navy from a size small in black.
- Every variant shares one page and one set of facts. A dress comes in six colors and five sizes, and the page carries one price, one stock line, and one set of markup. The assistant cannot tell which combination the shopper asked for is actually available.
- The color name is a brand name, not a color. A shade called Midnight Tide or Desert Rose appears in the title and in the feed, with no plain color word beside it. A shopper who asks for a navy dress will not match a page that never says navy.
- The size is written one way on the page and another way in the data. The page says UK 12, the feed says 12, and the markup says something else again. Size systems differ by country, and a model that cannot tell which system a number belongs to will not risk recommending it.
- The title is a style name, not a product description. A title that reads only as a collection name and a code gives the model no fabric, no cut, no length, and no occasion to match against a shopper's words.
- The category page is a photo grid with no words. A collection page for linen dresses carries images, prices, and filter links, and no sentence that says what linen dresses the brand sells, in which sizes, and for which season. A model needs words to describe the collection, and the page gives it none.
The steps
Step 1. Write one plain product description per product, and keep it on the page. The marketer writes the description in plain words: what the item is, the fabric, the cut, the length, the fit, the colors, and the sizes it comes in. Put that description on the product page where a reader can see it, not only in the markup and not only in the feed. Name the plain color beside any brand color name, so a navy dress says navy and a shade name sits beside it as a second word. Check the description against the live page. If a shopper cannot read the fabric and the fit from the words on the page, the assistant cannot either.
Step 2. Give every variant its own facts. The developer makes sure each size and color combination has its own price and stock status in the data, even when the combinations share one page. Google's Merchant Center guidance for apparel asks for color, size, gender, and age group for apparel products, and for each variant to be submitted as its own item grouped by an item group id, so each combination is a separate row with its own price and availability. On the page, the markup should carry the same split: one offer per variant where the platform supports it, or a clear offer for the combination the page shows, with the price and the stock status matching what the shopper sees. Do not carry one price and one stock line for a product that has thirty combinations.
Step 3. Match the size system to the shopper. The marketer decides which size system each market sees, and the developer makes sure the feed, the page, and the markup agree on it. A size value should match the size shown on the product page and in the size selector, and the size system field should state which country's sizing the value uses where the catalog serves more than one country. Do not convert sizes in the feed while the page shows the original size. A shopper in one country who asks for their size needs the number that fits them, not a number converted in a file they never see.
Step 4. Title products the way shoppers ask. The marketer rewrites product titles so each one names the item, the fabric or key feature, the color, and the intended wearer where that applies, in plain words. A title that says only a style name and a code cannot match a shopper's question about a linen midi dress. Keep titles short enough to read, and keep the same title in the feed, on the page, and in the markup. A title that changes between the feed and the page teaches the model that neither version can be trusted.
Step 5. Give every collection a sentence. The marketer adds one short paragraph to each collection page that says what the collection holds, in which fabrics and sizes, and for which season or occasion. A page for linen dresses should say so in words, and name the colors and sizes the collection covers. Link from the collection page to the products in it with plain links a crawler can follow. A collection page with no words is a photo grid, and a photo grid gives an assistant nothing to quote.
Step 6. Retire the old season the day the new one goes live. The marketer and the developer agree a routine for season change: a discontinued product leaves the feed and the sitemap, and its page either shows that it is out of stock with no price to buy, or redirects to the closest live product or to the collection page. Do not leave last season's prices and stock on indexable pages. A product page that cannot be bought should not read as if it can be, and a feed that still lists it will keep it in front of shoppers who cannot buy it.
Step 7. Check the facts match in all three places. The developer compares the page, the markup, and the feed for a sample of products each time the catalog changes: the same price, the same currency, the same stock status, the same colors, and the same sizes. Google's product structured data guidance asks for a name, an image, and an offer carrying a price, a currency, and availability for merchant listings, and Merchant Center guidance asks for the same facts in the feed. Where the three disagree, fix the source that feeds them.
The machine-readable piece
This is Product markup for one variant of a hypothetical linen dress. Replace the placeholders in square brackets with your own values, and repeat the offer block per variant where your platform supports it. The color uses a plain color word first, with the brand shade name beside it in the description on the page. The size value matches the size shown on the page. The price and the currency sit in the offer, and the availability uses the schema.org value for in stock. Only include a size system value if your catalog serves more than one sizing system.
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Linen midi dress in navy",
"description": "A linen midi dress with a relaxed fit and short sleeves. Shown in navy, shade name Midnight Tide.",
"image": "https://[yourdomain.com]/images/linen-midi-dress-navy.jpg",
"brand": {
"@type": "Brand",
"name": "[Your brand name]"
},
"sku": "[your SKU]",
"color": "navy",
"material": "linen",
"size": "M",
"offers": {
"@type": "Offer",
"url": "https://[yourdomain.com]/products/linen-midi-dress-navy-medium",
"priceCurrency": "USD",
"price": "128.00",
"availability": "https://schema.org/InStock",
"itemCondition": "https://schema.org/NewCondition"
}
}
Check the markup after you add it: confirm the price, the size, and the stock status on the page match the markup exactly, and test the page with a structured data testing tool.
What it looks like when it works
On the page, a shopper sees a clear product name, a plain description that names the fabric and the fit, a size selector that shows which sizes are in stock, a color list that names each color in plain words, and a price that matches the checkout. Under the surface, the same facts sit in the markup and in the feed, one offer per variant, with the same price and stock status in all three places. The collection page carries a short paragraph that says what the collection holds, and links to every product in it. The old season is gone from the feed and the sitemap, and its pages no longer read as buyable.
Say you run a hypothetical fashion brand selling linen dresses and tailored trousers, with each dress in six colors and five sizes. The marketer rewrites each product title to name the item, the fabric, and the color, and adds a plain color word beside each brand shade name. The developer splits the feed so each size and color combination is its own item, grouped by one item group id per style, with its own price and stock status. A shopper asks an assistant for a navy linen midi dress in size medium under a set price. The assistant can find the dress, check that the navy medium combination is in stock at that price, and cite your page instead of a competitor's stale listing.
The fundamentals
These mechanics are shared across every store and covered in full in their own guides:
- •The llms.txt format and a complete sample, see our guide to writing a good llms.txt file
- •The markup AI systems read to verify facts, see our product schema guide
- •The complete crawler rule reference, see our robots.txt guide for AI search
What this guide does not cover
This guide covers the fashion-specific parts of AI search: variants, sizes, colors, titles, collections, and seasonal turnover. It does not cover the full technical audit that checks every crawler and every page, the product feed build in full, the sitemap strategy for a large catalog, or the transaction layer that lets an agent complete a purchase. It does not cover paid advertising, social content, or influencer work. Those are separate jobs, and this guide is the map for the fashion pages, not the whole trip.
Check your own store now
Run the free scan. One click, no signup, and it shows whether AI crawlers can read your store today: aizii.ai/aeo-scan
Run the free scanSources
- Google Search Central, Product structured data (specific): https://developers.google.com/search/docs/appearance/structured-data/product
- Google Merchant Center Help, Free listings for products (specific): https://support.google.com/merchants/answer/9199328?visit_id=639234295611713744-2772141442&rd=1
- Google Search Central, Optimizing your website for generative AI features on Google Search (specific): https://developers.google.com/search/docs/fundamentals/ai-optimization-guide
- Schema.org, Product type (specific): https://schema.org/Product
- Schema.org, Offer type (specific): https://schema.org/Offer
Note: links marked specific point to the page that supports the claim in this guide. Links marked general docs point to the vendor's general docs section for that topic, not to a page that proves every step. Check the vendor docs for the current path before relying on a menu name or click path in this guide.
