AI SEO for a food or beverage brand means stating the facts a shopper checks before eating or drinking something, in plain words on the page and in structured data, so an AI assistant can answer with your product instead of a competitor's. A shopper asks for a gluten free oat milk latte mix, a coffee that is decaf and whole bean, or a snack box with no nuts. Your pages need to state the flavor, the size or pack count, the ingredients, the allergens, the dietary labels, the storage facts, and the shelf life, in words a model can quote and in markup a model can check. If the ingredients sit only in a photo of the label, the pack count hides in a selector, or the allergen facts live only in a PDF, the assistant has nothing solid to cite, and it will pick a brand that states the facts. This guide covers the food and beverage parts: flavors, pack sizes, ingredients, allergens, dietary labels, storage, and shelf life. The shared mechanics are covered in their own guides, linked at the end.
A food catalog turns over with seasons and harvests, and each product carries facts that matter to health and safety. A shopper with a nut allergy cannot buy a product that never states its allergens. A shopper who wants a decaf coffee cannot buy a bag that never says decaf in words.
Where it goes wrong
Food and beverage pages fail in ways that look fine to a human shopper and break for a machine reader.
- The ingredients and allergens live only in a photo of the label. The page shows a picture of the back of the pack, and the words on the page never list what is inside it. A model that reads the page text cannot tell whether the product contains nuts, dairy, or gluten.
- The flavor and the pack size hide in a selector. The page shows a dropdown for flavor and another for pack size, and the words on the page never say which flavors exist or how many units a pack holds. A model that reads the page text cannot tell a twelve pack of oat milk from a single bottle.
- One page carries every flavor with one price. A coffee comes in whole bean and ground, in three roast levels, 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 at which price.
- The dietary label is a badge with no words. The page shows a small gluten free or vegan badge, and no sentence that says what the label means for this product or which body certifies it. A shopper who asks for a certified gluten free snack gets no words to match against.
- The shelf life and storage facts are missing. The page never says how long the product keeps, whether it needs refrigeration, or how it ships in warm weather. A shopper who asks how long a box of chocolates keeps after delivery gets no answer from your page.
- The nutrition facts sit only in a table image. The page shows a nutrition panel as an image, and the words on the page never state the serving size or the calories. A model that reads the page text cannot quote a single nutrition fact.
The steps
Step 1. Write the ingredients and allergens in words on the page. The marketer writes the full ingredient list and the allergen statement in plain words on the product page, in the same words as the label. Put that list where a reader can see it, not only in a label photo and not only in a PDF. Name the allergens plainly, using the words shoppers use, such as contains milk, contains tree nuts, or made in a facility that handles peanuts. If a shopper cannot read the ingredients from the words on the page, the assistant cannot either. Never invent an allergen claim, and never soften one. If the label changes, the page changes the same day.
Step 2. Give every flavor and pack size its own facts. The developer makes sure each flavor and pack size has its own price and stock status in the data, even when the combinations share one page. Google's Merchant Center guidance asks 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 flavor and pack combination 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 coffee that comes in six combinations.
Step 3. State the dietary labels in words, with the certifier named. The marketer writes one sentence per label: what it means for this product, and which body certifies it where a certification exists. A gluten free claim should say whether it is certified and by whom, or say that it is made without gluten ingredients without claiming certification. A vegan claim should say the product contains no animal ingredients. Do not use a label your product has not earned. A badge with no words gives an assistant nothing to quote, and a label with no certifier gives a shopper no reason to trust it.
Step 4. State shelf life, storage, and shipping in plain words. The marketer writes how long the product keeps, whether it needs refrigeration or freezing, and how it ships. For a perishable product, say how it is packed for transit. Google's Merchant Center product data specification includes an expiration date attribute, which tells Google when a product should stop showing, so a product with a short shelf life should carry that fact in the feed as well as on the page. State only the shelf life and storage facts the maker publishes. Do not guess how long a product keeps.
Step 5. Put the nutrition facts in words, not only in an image. The marketer writes the serving size and the key nutrition numbers in plain words on the page, matching the label exactly. Schema.org defines a NutritionInformation type with properties for calories, fat, protein, sugar, sodium, and serving size, and that type belongs on recipe and menu item pages in Google's guidance, not on a plain product page. So keep the nutrition numbers in visible words on the product page, and use the structured nutrition type only where the page is a recipe. Never invent a nutrition number.
Step 6. Title products the way shoppers ask. The marketer rewrites product titles so each one names the item, the flavor or variety, and the size or pack count, in plain words. A title that says only a brand name and a code cannot match a shopper's question about a decaf whole bean coffee in a two pound bag. Keep the same title in the feed, on the page, and in the markup. A title that differs between the feed and the page tells the model that neither copy can be trusted.
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 a recipe or a pack changes: the same price, the same currency, the same stock status, the same flavors, the same pack counts, and the same ingredient words. For merchant listings, Google asks for a name, an image, and an offer carrying a price, a currency, and availability, and Merchant Center asks for the same facts in the feed. Where the three disagree, correct the source they all draw from.
The machine-readable piece
This is Product markup for one flavor and pack size of a hypothetical oat milk latte mix. Replace the placeholders in square brackets with your own values, and repeat the offer block per flavor and pack combination where your platform supports it. The flavor and the pack count sit in additional properties, because schema.org Product has no dedicated flavor field, and the values must match the words on the page exactly. The price and the currency sit in the offer, and the availability uses the schema.org in stock value. Nutrition numbers stay in visible words on the page, not in this block, because the structured nutrition type belongs on recipe pages.
{
"@context": "https://schema.org",
"@type": "Product",
"name": "Oat milk latte mix, vanilla, 12 pack",
"description": "An oat milk latte mix in vanilla. Gluten free, certified by [certifier name]. Contains oats. Made in a facility that handles tree nuts.",
"image": "https://[yourdomain.com]/images/oat-milk-latte-mix-vanilla-12-pack.jpg",
"brand": {
"@type": "Brand",
"name": "[Your brand name]"
},
"sku": "[your SKU]",
"additionalProperty": [
{
"@type": "PropertyValue",
"name": "flavor",
"value": "vanilla"
},
{
"@type": "PropertyValue",
"name": "pack count",
"value": "12"
}
],
"offers": {
"@type": "Offer",
"url": "https://[yourdomain.com]/products/oat-milk-latte-mix-vanilla-12-pack",
"priceCurrency": "USD",
"price": "29.00",
"availability": "https://schema.org/InStock",
"itemCondition": "https://schema.org/NewCondition"
}
}
Check the markup after you add it: confirm the flavor, the pack count, the price, 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 flavor and the pack size, the ingredients and allergens in words, the dietary labels with the certifier named, the shelf life and storage facts, and a price that matches the checkout. Under the surface, the same facts sit in the markup and in the feed, one offer per flavor and pack combination, with the same price and stock status in all three places.
Say you run a hypothetical coffee brand selling whole bean and ground coffee in three roasts and two bag sizes. The marketer rewrites each product title to name the roast, the grind, and the bag size, and adds the ingredients, the allergen statement, and the shelf life to every product page. The developer splits the feed so each roast, grind, and bag size is its own item, grouped by one item group id per coffee. A shopper asks an assistant for a decaf whole bean coffee in a two pound bag. The assistant can find the coffee, check that the decaf whole bean two pound bag is in stock at that price, and cite your page instead of a competitor's listing that never states a grind.
The fundamentals
These mechanics are shared across every store and written in full in their own guides, so this guide points to them instead of repeating them:
- •The llms.txt format for your store, in our llms.txt guide
- •The Product markup AI systems read, in our product schema guide
- •The crawler rules for AI systems, in our robots.txt guide for AI search
What this guide does not cover
This guide covers the food and beverage parts of AI search: flavors, pack sizes, ingredients, allergens, dietary labels, storage, and shelf life. It does not cover the full technical audit that checks every crawler and every page, the complete product feed build, the sitemap plan for a large catalog, or the transaction layer that lets an agent complete a purchase. It does not cover paid advertising, social content, or recipe content on its own. Those belong to other guides. This one covers the food pages only.
Scan your own store
Get the free scan at aizii.ai/aeo-scan. One click, no signup, and it checks whether AI crawlers can read your store today.
Sources
- Google Search Central, Product structured data (specific): https://developers.google.com/search/docs/appearance/structured-data/product
- Google Merchant Center Help, Product data specification (specific): https://support.google.com/merchants/answer/7052112
- Google Merchant Center Help, Expiration date (specific): https://support.google.com/merchants/answer/6324499
- 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
- Schema.org, NutritionInformation type (specific): https://schema.org/NutritionInformation
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.
