Recipe Schema

TL;DR — Recipe schemaRecipe schema (schema.org/Recipe) marks up a cooking recipe's image, name, ratings, times, ingredients, and nutrition so the page can earn Google's recipe rich result — a visual card with star ratings and cook time, plus carousel and recipe-filter eligibility. is code you add to a recipe page that labels the cooking details for search engines — “this is the dish name,” “this is the photo,” “it takes 20 minutes to cook,” “these are the ingredients,” “here are the steps,” “readers rated it 4.7 stars.” Adding it correctly makes the page eligible for Google’s recipe rich result — the visual card you see with a photo, star rating, and cook time. Unlike a lot of schema typesSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor., this one has a real, visible payoff. It does not guarantee the card shows up, and a multi-recipe carousel needs an extra piece (an ItemList page) on top of the per-recipe markup.

What Recipe schema is

When you look at a recipe page, you can tell the dish name from the cook time from the ingredient list just by reading. A search engine sees plain text and has to guess where the recipe stops and the blog story begins. Recipe schema spells it out in code, using the shared schema.org vocabulary — it tags each piece of the page with what it actually is: the name, an image, the prepTime and cookTime, the recipeIngredient list, the recipeInstructions steps, and any star aggregateRating.

It’s almost always written as JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. — a small block of code that sits in the page without changing how the page looks.

Why it’s worth doing

The payoff is the recipe rich result, and it’s a good one. On recipe searches Google shows enhanced cards with a photo, a star rating, the cook time, and sometimes a calorie count — and it groups them into a carousel or grid at the top of the page. Marked-up recipes also get recipe badges in Google Images. A card like that stands out more visually than a plain blue link, though Google doesn’t publish a guaranteed click-through or ranking lift for it — the payoff is the visual real estate itself, not a documented traffic number.

This is one of the two structured-data types (with VideoObject, which many recipe pages use for an embedded cooking video) that genuinely earns a mainstream rich result. If you run a food site, this is worth doing properly.

The two things you must have

Google only strictly requires two properties:

• name — the name of the dish (a real dish — more on that below).
• image — a photo of the finished dish. Google’s own condition: crawlable, indexable, in a supported format, and representative of the dish — it recommends multiple images at 16x9, 4x3, and 1x1 ratios, each at least 50,000 pixels. (Some guides claim a specific 1,200px-wide requirement; Google’s docs don’t state one.)

But two properties get you a bare-minimum valid recipe, not the full card. The fuller card — the one people actually engage with — is populated from the recommended properties, though having them doesn’t guarantee Google renders every field:

• author, datePublished, description
• prepTime, cookTime, totalTime — the times shown on the card.
• recipeYield — how many servings.
• recipeIngredient — the ingredient list.
• recipeInstructions — the steps.
• aggregateRating — the star rating (from genuine reader ratings).
• nutrition with calories — feeds the nutrition panel.
• recipeCategory, recipeCuisine, keywords — help Google understand and file the recipe.
• video — if you have a cooking video.

The thing most people get wrong

Individual recipe markup does not, by itself, produce a carousel. The nice multi-recipe carousel you see at the top of a search is a separate feature that needs an ItemList summary page — a page listing several recipes that each link out to their own recipe page. Per-recipe markup earns at most a single card. More on that in the Advanced tab.

Two more beginner traps:

• Valid markup ≠ guaranteed rich result. It makes you eligible; Google still decides whether to display the card.
• Only real dishes count. Recipe markup is for food you actually prepare and eat. Google literally says “facial scrub” or “party ideas” are not valid recipe names. Marking up non-food “recipes” is a content-policy violation.

Want the full version — the carousel/ItemList mechanics, the nutrition panel, the ISO 8601 time format, and why validated recipes still don’t show? Switch to the Advanced tab.

TL;DR — schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor./Recipe markup (usually JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.) makes a recipe page eligible for Google’s recipe rich result — a visual card (photo, star rating, cook time, calories) that can appear as a carousel/grid on the SERP and with recipe badges in Google Images. Only image and name are strictly required; the card is really built from the recommended set (aggregateRating, author, cookTime, prepTime, totalTime, recipeYield, recipeIngredient, recipeInstructions, recipeCategory, recipeCuisine, keywords, datePublished, nutrition.calories, video). Two implementation facts most round-ups skip: the multi-recipe carousel is a host-level feature that requires an ItemList page — either a summary page linking to separate recipe pages, or an all-in-one page linking to anchors on itself — per-recipe markup alone earns a single card, never a carousel — and Recipe markup is only valid for actual dishes (“facial scrub” and “party ideas” are Google’s own counterexamples). Times use ISO 8601 durations (PT20M), and the most common reason a valid recipe doesn’t show is a content-policy mismatch between markup and visible page. Along with VideoObject, this is one of the two structured-data types in the CreativeWork cluster that produces a genuine, visible rich result — not a documented ranking, CTR, or traffic factor, just a real visual upgrade when shown.

What the recipe rich result looks like — and how it’s built

Google renders Recipe markup as a visual card: the image thumbnail, the name, the aggregateRating stars and count, and the cook time (from totalTime or cookTime). On many recipe queries those cards are grouped into a carousel or grid at the top of the results, and marked-up recipes also earn recipe badges in Google Images, which is a meaningful discovery surface for food content.

Google’s framing of the whole point: “Help users find your recipe content by telling Google about your recipe with structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding..” That’s the mental model — you’re not asking for a ranking boost, you’re making the content machine-readable enough to qualify for a specific, visible feature.

Required vs. recommended — and why “required” undersells it

This is the property table that matters. Google only marks two properties as required, which is genuinely misleading if you stop reading there — a recipe with just name and image validates but produces a thin, unattractive result.

Required

Recommended (this is what Google uses to build the fuller card, when it decides to show one — populating them doesn’t force display)

totalTime and the prepTime/cookTime pair are both acceptable to Google; supply totalTime directly when you can, since it’s the single duration most likely to render on the card.

Times use ISO 8601 durations, not free text

A recurring validation failure: cookTime: "20 minutes" is invalid. Durations use the ISO 8601 format — PT (period of time) plus the value — so 20 minutes is PT20M, an hour and a half is PT1H30M. Dates like datePublished use ISO 8601 dates (2026-07-01). Getting these formats wrong is one of the most common reasons a recipe fails the Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test.

The carousel needs an ItemList — individual markup doesn’t

This is the implementation detail generic “types of schema” listicles almost always skip. There are two different things here:

• The single recipe card — earned by Recipe markup on the individual recipe page.
• The recipe carousel/grid — a host carouselA carousel rich result (Google calls it a \"host carousel\") is a horizontally scrollable row of cards, all from one site, built by wrapping two or more same-type items in an ItemList with position values. Only a short, shifting list of schema.org types qualifies — and a second, geographically limited beta carousel system now runs alongside the original., which is a separate feature.

To be eligible for the multi-recipe carousel, you add an ItemList page — and Google’s host-carousel documentation supports two different page models, not just one:

• Summary page — a page (a category or roundup page — “15 Weeknight Pastas”) with a short description of each item, where each ListItem points, in order, to the URL of a separate recipe detail page that itself has full Recipe markup. This is the pattern most guides describe.
• All-in-one page — a single page that contains the full markup for every item itself and doesn’t link out to separate detail pages; each ListItem carries an item object (with name and a url that’s an anchor on the same page) rather than a link to elsewhere.

Either model supplies the sequence Google needs for the carousel; which one fits depends on whether your recipes already live on their own URLs (summary page) or you’re presenting them all on one long page (all-in-one page).

The practical consequence: you cannot get a carousel from one ordinary recipe page. A single recipe page with excellent markup earns a single card. If you want the carousel, you need one of the two ItemList page models above, layered on top of (or containing) full Recipe markup. Missing this is the number-one reason people say “my markup is perfect but I’m not getting a carousel.”

The nutrition panel

nutrition is a NutritionInformation object, and nutrition.calories is the field Google calls out by name — it feeds the calorie figure Google may show in the rich result. That’s a data requirement, not a promise of a distinct expandable nutrition panel every time; Google’s docs describe the field, not a guaranteed UI element. There’s also a condition attached: if you set nutrition.calories, recipeYield must be defined too, since calories are stated per serving and Google needs the serving count to make sense of the number. You can add fatContent, proteinContent, carbohydrateContent, sodiumContent, and the rest, but calories (paired with recipeYield) is the combination that most reliably surfaces. Values are strings with units (“240 calories”, “9 g”). It’s a small block that adds a visible, differentiating detail to your card, so it’s worth populating for any recipe where you can compute it honestly.

Video: where Recipe meets VideoObject

Many recipe pages embed a cooking video, and the video property is where Recipe and VideoObject — the two CreativeWork types that produce genuine, visible rich results — intersect. Google’s guidance is explicit: video takes a full VideoObject and must follow that feature’s own required and recommended properties (name, description, thumbnailUrl, uploadDate, and a contentUrl or embedUrl) — supplying a bare video URL is not the same as the documented subprofile. Done right, the recipe can qualify for video treatment and the recipe card, and the video becomes eligible for its own surfaces. The per-field requirements for the video live with the VideoObject topic — the same object nests inside a recipe, so it’s worth getting that markup right rather than stubbing in a bare video: {}.

Content policy: only real dishes, matching the visible page

This is the most common reason otherwise-valid markup doesn’t display. Recipe markup is scoped to actual food. Google is blunt about it: “Use Recipe structured data for content about preparing a particular dish. For example, ‘facial scrub’ or ‘party ideas’ are not valid names for a dish.” A DIY cleaning “recipe,” a “recipe for success” listicle, or a roundup of party ideas dressed up as Recipe markup is a policy violation — the markup may pass the syntactic validator and still never earn a card, or get manually actioned.

The second half of the same principle: the markup must reflect the visible page. If your JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. lists ingredients, times, and a rating that aren’t actually on the page a user sees, that’s a mismatch Google treats as a spam signal. Mark up what’s genuinely there.

Why your valid recipe still shows no rich result

Eligibility is not display. The usual chain: the page has to be indexedStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed., the markup has to be valid, the content has to be a real dish shown on the page, and Google’s systems still have to decide it’s worth showing — the same eligibility-not-guarantee rule that governs every structured-data type. If you’ve cleared valid markup and content policy and still see no card, the common culprits are: times in free text instead of ISO 8601, an aggregateRating with no count, an image that doesn’t meet the size/aspect guidance, or expecting a carousel without an ItemList page.

For where Recipe sits in the wider structured-data picture, see the broader Schema Markup and Structured Data hubs this article nests under.

AI summary

A condensed take on the Advanced version:

• What it is: schema.org/Recipe markup (usually JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal.) that labels a recipe page’s dish name, photo, times, ingredients, steps, nutrition, video, and ratings so Google can produce the recipe rich result — a visual card (photo, stars, cook time, calories) that can appear as a carousel/grid and with recipe badges in Google Images.
• Visible payoff, not a documented ranking factor: with VideoObject, one of the two CreativeWork types that produces a genuine, mainstream, visible rich result. Google doesn’t publish ranking, CTR, or traffic numbers for it.
• Required vs. recommended: only image and name are required, but that produces a thin result. The fuller card is populated from the recommended set when Google chooses to show it: aggregateRating, author, cookTime, prepTime, totalTime, recipeYield, recipeIngredient, recipeInstructions, recipeCategory, recipeCuisine, keywords, datePublished, nutrition.calories, video.
• Image condition: crawlable, indexable, supported format, representative of the dish; Google recommends multiple images at 16:9/4:3/1:1, each at least 50,000 pixels — no separate 1,200px-wide rule as some guides claim.
• Conditional fields: nutrition.calories requires recipeYield; prepTime pairs with cookTime (or use totalTime instead of the pair); a single review (not an aggregate) needs a named Person/Organization reviewer.
• Carousel needs an ItemList page — two models: a summary page whose ListItems link to separate recipe detail pages, or an all-in-one page whose ListItems point to anchors on itself. Per-recipe markup alone earns a single card, never a carousel — the most commonly missed step.
• Times are ISO 8601 durations: PT20M, PT1H30M — not “20 minutes”. Wrong duration format is a top validation failure.
• Video: the video property takes a full VideoObject following that feature’s own required/recommended fields (name, description, thumbnailUrl, uploadDate, contentUrl/embedUrl) — a bare URL doesn’t satisfy it.
• Content policy (top reason valid markup doesn’t show): only actual dishes qualify — Google’s own counterexamples are “facial scrub” and “party ideas”. The markup must also reflect the visible page.
• Eligibility ≠ display: indexedStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. page + valid markup + real dish shown on the page + Google deciding it’s worth showing. Valid markup only makes you eligible.

Official documentation

Primary-source documentation from the search engines.

Google — structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding.

• Recipe (Recipe, HowTo) structured data — the authoritative reference: required (image, name) vs. recommended properties, the content-policy guidelines (only real dishes), and the nutrition/time/rating fields.
• Recipe host carousel / summary pages (search gallery) — where the ItemList summary-page pattern that powers the multi-recipe carousel is described.
• VideoObject structured data — the requirements for the VideoObject that nests in a recipe’s video property.
• Rich Results Test — validate the recipe markup and check rich-result eligibility.

Bing / Microsoft

• Marking up your site with structured data — Bing’s general structured-data support (schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor., JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. recommended).

Quotes from the source

On-the-record statements from Google. Where a source page exposes the text, the link is a deep link that jumps to the quoted passage.

Google docs — the point of Recipe markup

• “Help users find your recipe content by telling Google about your recipe with structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding..” Jump to quote

Google docs — content policy (only real dishes)

• “Use Recipe structured data for content about preparing a particular dish. For example, ‘facial scrub’ or ‘party ideas’ are not valid names for a dish.” Jump to quote

Recipe schema cheat sheet

Required (the bare minimum to validate)

Recipe.name + Recipe.image. That’s it — but it produces a thin card. Real dishes only.

Recommended — what builds the fuller card, when Google shows one

Single card vs. carousel

Formats that break validation

• Times must be ISO 8601 durations: PT20M, not “20 minutes”.
• Dates must be ISO 8601: 2026-07-01.
• aggregateRating needs a ratingCount/reviewCount.
• image must be crawlable/indexable/supported format; Google recommends multiple images, 16x9 / 4x3 / 1x1, each at least 50,000 pixels (not a 1,200px-wide rule).

Fast facts

• Format: JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. (recommended, most maintainable).
• Valid markup = eligible, not guaranteed to show — and not a documented ranking/CTR factor.
• Only real dishes — “facial scrub” / “party ideas” are Google’s invalid examples.
• video takes a full VideoObject, not a bare URL.
• Markup must match the visible page.

Do I get a card, a carousel, or nothing?

Work down the questions:

1. Is the page about preparing an actual dish?

• No — it’s a “recipe for success,” a DIY/craft “recipe,” a party-ideas roundup, a facial scrub → Recipe markup is not valid. Google names “facial scrub” and “party ideas” as invalid dish names. Don’t mark it up as a Recipe.
• Yes → continue.

2. Does the markup match what a user actually sees on the page?

• No (times, ingredients, or a rating in the JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. that aren’t on the page) → fix that first; a mismatch is a content-policy problem that can suppress the result even when the syntax validates.
• Yes → continue.

3. Do you have name + image, plus the recommended set?

• Just name + image → it validates, but you’ll get a thin card. Add aggregateRating, times (ISO 8601), recipeIngredient, recipeInstructions, recipeYield, nutrition.calories, recipeCategory/recipeCuisine.
• Full recommended set on a single recipe page → you’re eligible for a single recipe card.

4. Do you want the multi-recipe carousel/grid?

• Yes, and your recipes each have their own page → add an ItemList summary page (a roundup/category page) whose JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. lists, in order, the URLs of the individual recipe pages that each carry full Recipe markup.
• Yes, but you present all the recipes on one long page → use the all-in-one ItemList page model instead: each ListItem carries the item’s own markup and points to an anchor on that same page rather than a separate URL.
• No → the single recipe card from step 3 is all you need.
• Either way: per-recipe markup alone will not produce a carousel — you need one of the two ItemList page models.

5. EmbeddingEmbeddings are dense numerical vectors — lists of floating-point numbers — that represent the meaning of text in a high-dimensional space. Semantically similar content lands close together, so search and AI systems can match by meaning, not just keywords. a cooking video?

• Add the video property as a full VideoObject (name, description, thumbnailUrl, uploadDate, contentUrl/embedUrl) — not a bare URL — so it can qualify for video treatment alongside the recipe card.

Rule of thumb: per-recipe markup earns the card; the ItemList summary page earns the carousel; and none of it matters if the page isn’t a real dish matching the visible content.

Recipe schema myths and mistakes to avoid

Myth: “Adding Recipe schemaRecipe schema (schema.org/Recipe) marks up a cooking recipe's image, name, ratings, times, ingredients, and nutrition so the page can earn Google's recipe rich result — a visual card with star ratings and cook time, plus carousel and recipe-filter eligibility. guarantees a rich result.” No structured-data type guarantees display. Recipe markup makes the page eligible; the page still has to be indexedStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed., be a real dish, match the visible content, and have Google’s systems decide the card is worth showing. Valid ≠ displayed.

Myth: “Any list-style content counts as a recipe.” False, and it’s a content-policy violation. Recipe markup is for actual dishes. Google’s own counterexamples: “‘facial scrub’ or ‘party ideas’ are not valid names for a dish.” A “recipe for productivity,” a craft tutorial, or a DIY cleaner isn’t a Recipe — even if it happens to have a numbered list of steps.

Myth: “Individual recipe markup alone gets you a carousel.” False. The multi-recipe carousel/grid is a host-level feature that requires an ItemList page — either a summary page linking to separate recipe pages, or an all-in-one page linking to anchors on itself. Per-recipe markup, no matter how complete, earns at most a single card. This is the most common “my markup is perfect but no carousel” cause.

Mistake: times as free text. cookTime: "20 minutes" fails. Durations are ISO 8601: PT20M, PT1H30M. Dates are ISO 8601 too: 2026-07-01. Also pair prepTime with cookTime (or supply totalTime instead of the pair) rather than mixing them inconsistently.

Mistake: aggregateRating with no count. A rating value without a ratingCount/reviewCount is invalid — and the ratings must be genuine reader ratings actually shown on the page, not fabricated or imported from elsewhere. If you show a single review instead of an aggregate, it needs a named Person or Organization reviewer.

Mistake: nutrition.calories without recipeYield. Google’s condition is explicit — if you set nutrition.calories, recipeYield must be defined too, since the calorie figure is per serving.

Mistake: stopping at the two required properties. name + image validates but renders a thin, unattractive result. The card people click is built from the recommended set — times, ingredients, yield, rating, nutrition.

Mistake: a bare video URL. The video property takes a full VideoObject (name, description, thumbnailUrl, uploadDate, contentUrl/embedUrl), not a string. A stubbed video object usually fails validation for that enhancement.

Mistake: markup that doesn’t match the page. If the ingredients, times, yield, or rating in your JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. disagree with what the visitor sees, Google treats it as a mismatch and can suppress the result even with valid syntax.

Minimal vs. rich Recipe JSON-LD

The minimal valid recipe

Just the two required properties. This validates — but it earns, at best, a thin card with no times, no rating, no ingredients:

{
  "@context": "https://schema.org/",
  "@type": "Recipe",
  "name": "Weeknight Tomato Basil Pasta",
  "image": "https://example.com/img/tomato-basil-pasta.jpg"
}

The same recipe, done richly

Full recommended set — times in ISO 8601, ingredient and step lists, a genuine aggregate rating, nutrition paired with recipeYield, and a nested VideoObject. This is what builds the fuller card (images below meet Google’s 50,000-pixel, 16x9/4x3/1x1 guidance):

{
  "@context": "https://schema.org/",
  "@type": "Recipe",
  "name": "Weeknight Tomato Basil Pasta",
  "image": [
    "https://example.com/img/pasta-1x1.jpg",
    "https://example.com/img/pasta-4x3.jpg",
    "https://example.com/img/pasta-16x9.jpg"
  ],
  "author": { "@type": "Person", "name": "Patrick Stox" },
  "datePublished": "2026-07-01",
  "description": "A 25-minute tomato and basil pasta for busy weeknights.",
  "recipeCategory": "main course",
  "recipeCuisine": "Italian",
  "keywords": "pasta, tomato, weeknight, vegetarian",
  "prepTime": "PT10M",
  "cookTime": "PT15M",
  "totalTime": "PT25M",
  "recipeYield": "4 servings",
  "recipeIngredient": [
    "1 lb spaghetti",
    "2 cups cherry tomatoes, halved",
    "1/2 cup fresh basil, torn",
    "3 tbsp olive oil",
    "2 cloves garlic, minced"
  ],
  "recipeInstructions": [
    { "@type": "HowToStep", "text": "Boil the spaghetti until al dente." },
    { "@type": "HowToStep", "text": "Saute garlic and tomatoes in olive oil." },
    { "@type": "HowToStep", "text": "Toss with pasta and fresh basil; serve." }
  ],
  "nutrition": {
    "@type": "NutritionInformation",
    "calories": "480 calories"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "ratingCount": "312"
  },
  "video": {
    "@type": "VideoObject",
    "name": "How to make Weeknight Tomato Basil Pasta",
    "description": "A quick walkthrough of the 25-minute tomato basil pasta.",
    "thumbnailUrl": "https://example.com/img/pasta-video-thumb.jpg",
    "contentUrl": "https://example.com/video/tomato-basil-pasta.mp4",
    "uploadDate": "2026-07-01"
  }
}

The carousel needs an ItemList page — summary or all-in-one

To earn the multi-recipe carousel, you add one of two ItemList page models.

Summary page — a page (say, “15 Weeknight Pastas”) carries an ItemList that points, in order, to separate individual recipe pages — each of which has full Recipe markup like the one above:

{
  "@context": "https://schema.org/",
  "@type": "ItemList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "url": "https://example.com/recipes/tomato-basil-pasta"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "url": "https://example.com/recipes/garlic-butter-linguine"
    }
  ]
}

All-in-one page — a single page holds every recipe’s full markup itself and doesn’t link out; each ListItem carries an item with the recipe’s own data and a url that’s an anchor on that same page:

{
  "@context": "https://schema.org/",
  "@type": "ItemList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "item": {
        "@type": "Recipe",
        "name": "Weeknight Tomato Basil Pasta",
        "url": "https://example.com/recipes/roundup#tomato-basil-pasta"
      }
    },
    {
      "@type": "ListItem",
      "position": 2,
      "item": {
        "@type": "Recipe",
        "name": "Garlic Butter Linguine",
        "url": "https://example.com/recipes/roundup#garlic-butter-linguine"
      }
    }
  ]
}

Either model supplies the sequence Google needs; without one of them, you get single cards, never a carousel.

Common Rich Results Test failures → fixes

Test yourself: Recipe Schema

Five quick questions on schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor./Recipe, the required vs. recommended split, the carousel mechanics, and the content policy. Pick an answer for each, then check.

Resources worth your time

My writing on this topic

I haven’t published a standalone Recipe schemaRecipe schema (schema.org/Recipe) marks up a cooking recipe's image, name, ratings, times, ingredients, and nutrition so the page can earn Google's recipe rich result — a visual card with star ratings and cook time, plus carousel and recipe-filter eligibility. guide of my own — so rather than point you at something that doesn’t exist, the honest move is to send you to the primary sources below and to the related structured-data work on this site. For the broader vocabulary and where Recipe fits, see the Schema MarkupSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor. and Structured DataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. hubs; for the AI angle, Schema Markup for AISchema markup (structured data) is machine-readable code — usually JSON-LD — that labels what your content means using the schema.org vocabulary. For AI search it's infrastructure for entity disambiguation, not a direct citation lever: controlled studies found no meaningful uplift in AI citations from adding it..

From around the industry

• Recipe structured data (Google Search Central) — the authoritative reference for required/recommended properties, the content policy, and the nutrition/time/rating fields.
• Search gallery / recipe host carousel (Google) — where the ItemList summary-page pattern behind the carousel is documented.
• VideoObject structured data (Google) — the requirements for the VideoObject that nests in a recipe’s video property.
• Rich Results Test (Google) — validate the markup and check eligibility.

Yoast, Semrush, and AIOSEO each cover Recipe reasonably accurately at a surface level — they’ll tell you it earns stars, cook time, and an image. Where they stop short is implementation depth: the ItemList carousel mechanics, the nutrition properties, the ISO 8601 duration format, and the common validation failures. This is the one CreativeWork subtype where the competitor gap isn’t accuracy — it’s that Recipe gets one paragraph among six other types, with none of the carousel-eligibility or troubleshooting detail above. That’s the differentiator here.

Recipe Schema

Recipe schema (schema.org/Recipe) marks up a cooking recipe's image, name, ratings, times, ingredients, and nutrition so the page can earn Google's recipe rich result — a visual card with star ratings and cook time, plus carousel and recipe-filter eligibility.

Related: Schema Markup, Structured Data, Rich Results, VideoObject Schema

Recipe Schema

Recipe schema is the schema.orgSchema markup is code that uses the schema.org vocabulary to label what your content means so search engines can understand it and show rich results. It's most often written in JSON-LD, and it's not a direct ranking factor./Recipe structured-data vocabulary you add to a recipe page — usually as JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. — so search engines can read the dish’s name, image, author, description, prepTime/cookTime/totalTime, recipeYield, recipeIngredient, recipeInstructions, nutrition (including calories), video, and aggregateRating. Google uses it to power the recipe rich result: a visual card with a photo, star ratings, and cook time that can appear as a carousel or grid on the SERP and with recipe badges in Google Images. Of the CreativeWork subtypes, Recipe and VideoObject are the two that produce a genuine, mainstream, visible rich result — Google doesn’t publish a ranking, CTR, or traffic number for it.

Only two properties are strictly required — image and name — but the recommended set is what Google uses to build the fuller card, when it decides to show one: aggregateRating, author, cookTime, datePublished, description, keywords, nutrition.calories, prepTime, recipeCategory, recipeCuisine, recipeIngredient, recipeInstructions, recipeYield, totalTime, and video. Some of these are conditional: nutrition.calories requires recipeYield; prepTime pairs with cookTime (or use totalTime instead).

Two things trip people up. First, the carousel/grid is a host-level feature: an individual recipe’s markup alone can earn a single card, but the multi-recipe carousel needs an ItemList page — either a summary page linking to separate recipe pages, or an all-in-one page linking to anchors on itself. Second, Recipe markup is only valid for actual dishes — Google’s own counterexamples are that “facial scrub” or “party ideas” are not valid recipe names. As with every rich result, valid markup only makes a page eligible; Google still decides whether to show the card.

Related: Schema Markup, Structured Data, Rich Results, VideoObject Schema

Changelog