Add one Recipe JSON-LD object to each recipe page, and make every value repeat what the page already shows: the dish name, the finished-dish photo, the ingredients, the steps, the times and the yield. For Google's recipe feature only name and image are required. Everything else is recommended.

Check what your recipe plugin or platform already outputs, write or adjust a single Recipe object, add an ItemList to any roundup page, then test the published URL with Google, Schema.org and Bing tools.

Valid markup does not guarantee a recipe result, a ranking or traffic, and Google says so in its Recipe documentation.

Key takeaways

  1. One Recipe per pageAdd one Recipe object to each recipe page, and repeat what the page shows: dish name, finished-dish photo, ingredients, steps, times and yield.
  2. Two required propertiesFor Google's recipe feature, only name and image are required. Everything else is recommended, and valid markup does not guarantee a recipe result.
  3. Use durations and stepsWrite times as ISO 8601 durations such as PT15M, and give prepTime and cookTime together. Describe steps as HowToStep objects and ingredients as one string each.
  4. Ratings and caloriesShow aggregateRating only for genuine ratings the page displays. Calories need recipeYield, and nutrition belongs in the markup only when the page shows it.
  5. Roundups use ItemListMark up a roundup page with an ItemList of separate recipe URLs, not one giant Recipe. Each linked recipe page carries its own Recipe object.
  6. Avoid duplicate outputRecipe plugins often print their own Recipe JSON-LD. Keep one authoritative object per page, and test the published URL with Google, Schema.org and Bing tools.

Check what your site already outputs

Before you write any code, open one published recipe page and look at its HTML for "@type": "Recipe". Most recipe plugins create a visible recipe card and emit JSON-LD for it automatically, so the markup you want may already exist. If it does, your job is to confirm it matches the page and to avoid adding a second copy.

WP Recipe Maker's WordPress listing says the plugin outputs Recipe JSON-LD, supports regular and guided recipe metadata, works with Yoast SEO and Rank Math, and outputs ItemList metadata for roundup posts. Yoast's integration documentation says the plugin can add its Recipe data to Yoast's schema graph. If you run WordPress, the WordPress schema guide shows how to see what a theme and each plugin add.

What Google requires and recommends for recipes

Google's Recipe documentation lists two required properties for its recipe feature: name, the name of the dish, and image, a photo of the finished dish. The image URL must be crawlable and indexable. Google lists the other supported properties as recommended, which means they give Google more context but are not needed for eligibility.

The recommended properties are aggregateRating, author, cookTime, datePublished, description, keywords, nutrition.calories, prepTime, recipeCategory, recipeCuisine, recipeIngredient, recipeInstructions and recipeYield. Note that schema.org allows more properties than Google's recipe feature documents, so a property can be valid vocabulary and still have no effect on a Google display.

Google also expects the markup to follow its general structured data policies. The markup must describe content that visitors can see, must not contain made-up facts, and must not misrepresent reviews or ratings. If the visible recipe says 12 muffins, the markup says 12 muffins.

Keep four meanings of "correct" apart. The JSON can be syntactically valid, the vocabulary can be valid schema.org, the page can meet one Google feature's requirements, and the page can actually be indexed and shown. Passing one does not mean passing the next.

Recipe properties and their status for Google

Hover over or tap a row to highlight it. On small screens the table scrolls sideways.

PropertyStatus for Google's recipe featureWhat it holds
nameRequiredThe name of the dish
imageRequired; the URL must be crawlable and indexableA photo of the finished dish
recipeIngredient and recipeInstructionsRecommendedIngredient text with amounts, and the steps, preferably as HowToStep objects
prepTime and cookTimeRecommended; use them togetherISO 8601 durations such as PT15M
nutrition.caloriesRecommended; requires recipeYieldCalories per serving
aggregateRatingRecommended, only for genuine ratings shown on the pageThe average of real ratings

Start from a complete Recipe example

The example below describes a fictional recipe on a reserved example domain. It includes both required Google properties and every recommended property except aggregateRating, which is left out because the fictional page shows no ratings.

json
{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "@id": "https://example.com/recipes/sunrise-oat-muffins#recipe",
  "url": "https://example.com/recipes/sunrise-oat-muffins",
  "name": "Sunrise Oat Muffins",
  "image": [
    "https://example.com/images/sunrise-oat-muffins-1x1.jpg",
    "https://example.com/images/sunrise-oat-muffins-4x3.jpg",
    "https://example.com/images/sunrise-oat-muffins-16x9.jpg"
  ],
  "author": { "@type": "Person", "name": "Example Recipe Author" },
  "datePublished": "2026-06-15",
  "description": "Tender oat muffins with orange zest and dried cranberries.",
  "prepTime": "PT15M",
  "cookTime": "PT22M",
  "totalTime": "PT37M",
  "recipeYield": "12 muffins",
  "recipeCategory": "Breakfast",
  "recipeCuisine": "American",
  "keywords": "oat muffins, breakfast muffins, cranberry muffins",
  "recipeIngredient": [
    "2 cups rolled oats",
    "1 cup all-purpose flour",
    "1 teaspoon baking powder",
    "1/2 teaspoon ground cinnamon",
    "1/4 teaspoon fine salt",
    "2 large eggs",
    "3/4 cup plain yogurt",
    "1/3 cup maple syrup",
    "1/4 cup vegetable oil",
    "1 teaspoon orange zest",
    "1/2 cup dried cranberries"
  ],
  "recipeInstructions": [
    { "@type": "HowToStep", "name": "Prepare the pan", "text": "Heat the oven to 190 degrees Celsius and line a 12-cup muffin pan." },
    { "@type": "HowToStep", "name": "Mix the dry ingredients", "text": "Whisk the oats, flour, baking powder, cinnamon and salt in a large bowl." },
    { "@type": "HowToStep", "name": "Mix the wet ingredients", "text": "Whisk the eggs, yogurt, maple syrup, oil and orange zest in a separate bowl." },
    { "@type": "HowToStep", "name": "Combine the batter", "text": "Fold the wet mixture and dried cranberries into the dry ingredients until just combined." },
    { "@type": "HowToStep", "name": "Bake the muffins", "text": "Divide the batter among the muffin cups and bake for 22 minutes, until the tops spring back when lightly pressed." }
  ],
  "nutrition": { "@type": "NutritionInformation", "calories": "240 calories" }
}

Replace every value with what your recipe page displays. Change @id and url to the canonical address of the page, point image at photos of the finished dish that search engines can fetch, and use the real author name and publication date. Swap the ingredients, steps, times and yield for your own, and remove nutrition entirely if your page does not show calories.

The properties @id, url, totalTime and the step name values are valid schema.org vocabulary but optional for Google's recipe feature. They are useful for connecting entities and for other consumers, and they do no harm when they match the page.

When the object is ready, place it in the page's HTML inside a script element. This minimal version is the smallest object that meets Google's two required properties; a real page should carry the fuller version above.

html
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "name": "Sunrise Oat Muffins",
  "image": "https://example.com/images/sunrise-oat-muffins-4x3.jpg"
}
</script>

The Next.js documentation recommends rendering JSON-LD with a native script tag of this type in layout.js or page.js, and sanitizing any dynamic strings you insert. If your recipes live in a database, that matters: a stray quotation mark in a recipe title would otherwise break the JSON. The JSON-LD examples guide shows more patterns for placing and structuring blocks.

Write ingredients, steps, times, yield and nutrition

Each of these properties has one job, and the values should read the same as the visible recipe card.

Put every ingredient in recipeIngredient as one text string with its amount, as in the example. Put the cooking process in recipeInstructions. Google recommends describing each step as a HowToStep object, and the example does exactly that. If a single recipe has distinct stages, such as a dough, a filling and a glaze, wrap each stage's steps in a HowToSection and keep the whole thing inside one Recipe. Do not mark up one dish as several recipes just to separate its stages.

Times use ISO 8601 durations. PT15M means 15 minutes, PT1H means one hour and PT1H20M means one hour and 20 minutes. Plain text such as "about 20 mins" is not a duration. Google recommends supplying prepTime and cookTime together, so a page that lists only one of them is incomplete. totalTime is optional and should equal the sum when you include it.

Calories belong in nutrition, as a NutritionInformation object with a calories value. Google says calories are per serving and that they need recipeYield, so set the yield whenever you publish a calorie figure. Publish nutrition only when your page displays it; a plugin that outputs nutrition the visitor cannot see creates a mismatch.

A woman in a flour-dusted apron holds a printed recipe sheet and points a pen at a laptop beside a tray of muffins in a home kitchen
Figure 1. Every value in the markup should read the same as the recipe card visitors see.

Ratings follow the same rule. aggregateRating is recommended for Google's recipe feature, but only for genuine ratings that appear on the page. A recipe with no ratings should have no aggregateRating, and the property is not required for any recipe. The rules for counts, scales and what Google accepts sit in the review and AggregateRating guide, so check them there before adding stars.

Finally, keep recipe markup distinct from the markup for the post around it. A recipe page that also has a story, a byline and a published date can carry Article or BlogPosting data for that content. The Article schema guide covers it, and the JSON-LD graph guide explains how to connect the two objects so they describe one page cleanly.

Mark up a recipe roundup with ItemList

A roundup or category page lists several recipes, and it needs different markup from a single recipe. Google's Recipe documentation uses ItemList for its recipe host carousel. Each entry in itemListElement is a ListItem with a numeric position and the canonical url of one recipe page. For this Google feature, itemListElement, position and url are required, and the list's own name, url and @id are optional.

json
{
  "@context": "https://schema.org",
  "@type": "ItemList",
  "@id": "https://example.com/recipes#itemlist",
  "url": "https://example.com/recipes",
  "name": "Example Recipe Collection",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "url": "https://example.com/recipes/sunrise-oat-muffins"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "url": "https://example.com/recipes/moonlit-bean-soup"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "url": "https://example.com/recipes/garden-herb-rice"
    }
  ]
}

Replace the collection name and address with your own, then list one entry per recipe in the order the page presents them. Every URL should be the canonical address of a real recipe page, unique within the list and linked visibly from the roundup page. Each linked recipe page carries its own Recipe object.

A common error is to mark up a roundup as one giant Recipe. Recipe describes a single dish, while ItemList describes an ordered collection of pages, so the two are not interchangeable. If you use WP Recipe Maker, its listing says it outputs ItemList metadata for roundup posts, so look at the plugin's output before adding your own.

A wide collection card with three markers, each linked by a line to its own smaller recipe card
Figure 2. A roundup page lists separate recipe URLs in order, and each recipe page carries its own Recipe object.

Fix duplicate output from plugins and platforms

The most frequent recipe markup problem is not missing code but doubled code. Two plugins, or a plugin plus a theme, can each emit a Recipe object for the same dish, and the two may disagree about the image, the times or the yield. Keep one authoritative Recipe output per page. If you add markup by hand, turn the other source off or confirm it is not already doing the same job.

Platform behavior differs, so confirm it on your own published pages.

On WordPress, use the recipe plugin's preview or output, then test the live page. If you also run an SEO plugin, decide which one owns the recipe data. The Yoast versus Rank Math guide compares how the two handle schema output.

On Wix, the structured data documentation says you can add JSON-LD manually, up to five markups per page, and that Wix can generate structured data for Wix Blog posts. Look at a blog page before adding a recipe block to see what is already present.

On Shopify, the Shopify SEO documentation says supported themes include structured data automatically, and it describes mainly product microdata. A recipe blog should inspect its published HTML before adding custom Recipe JSON-LD.

On Squarespace, the SEO documentation lists automatic Blog post, Event, Local business, Organization, Product and Website structured data, and Recipe is not on that list. Squarespace custom code, last updated August 27, 2026, is the route for adding your own block.

On Webflow, the schema markup documentation says custom schema can stay in custom code, and it recommends keeping schema in one place to avoid duplication. On HubSpot, view the published page's HTML and confirm whether Recipe JSON-LD is already present before you add custom markup. On a hand-built site, you control the output completely, so keep the template as the single place that prints the object.

Test the page before and after you publish

Test in layers, because each tool answers a different question. Start with Google's Rich Results Test on the URL or on pasted code, which shows whether the page meets the requirements of Google's recipe feature. Then run the Schema.org Markup Validator, which checks JSON-LD syntax and extracts the structured data graph. It does not decide eligibility for any search feature.

You can also paste your code into the Schema Nova Schema Validator to catch JSON syntax mistakes early, such as a missing comma. Treat any tool's result as a statement about that tool's checks. A clean result means the checks found nothing wrong; it does not promise a display.

After the page is live, use URL Inspection in Google Search Console and in Bing Webmaster Tools. Bing's URL Inspection documentation says it includes a Markup card for JSON-LD, Microdata and other markup, so you can see what Bing read from the published page. Finally, open the page's HTML and search for "@type": "Recipe". More than one match on the same page means duplicate output that needs attention.

If a fix does not show up, fixing missing-field warnings walks through the common messages and the properties behind them. Give Google time to crawl and index changes, and test again after any change to your recipe template or plugin.

Setup steps from page to test

  1. Publish the recipe pageThe dish name, the finished-dish photo, the ingredients and the steps are all visible to visitors.
  2. Check existing outputLook in the published HTML for Recipe markup from a plugin, theme or platform before adding more.
  3. Add one Recipe objectInclude name and image, then the recommended properties that match what the page shows.
  4. ValidateUse the Rich Results Test for Google's requirements and the Schema.org Validator for vocabulary.
  5. Inspect the live URLUse URL Inspection in Google Search Console and in Bing Webmaster Tools.
  6. Retest after changesRun the checks again whenever the recipe template or a recipe plugin changes.

What Google shows for recipes today

Google's Recipe documentation describes recipe rich results, Google Images and the recipe host carousel. In its May 2020 announcement, Google documented Guided Recipes for Google Assistant, with Search Console reports and a preview in the Rich Results Test for smart displays. Check the current feature list on Google's Recipe page when you publish.

Do not add Guided Recipe markup in the hope of triggering Assistant behavior. Keep complete, visible ingredients and instructions in the ordinary Recipe object. A recipe plugin may still show a "guided" setting for older output or for another consumer; treat it as a plugin option, not a requirement of Google Search.

Google also announced in its 2023 changes to How-to and FAQ results that How-to rich results no longer appear on desktop, as of September 13, 2023. That affects the page-level HowTo type as a Google feature. It does not affect HowToStep inside recipeInstructions, which Google's Recipe documentation still recommends for describing recipe steps.

Bing lists JSON-LD as a supported annotation format and recipes among supported content types, so the same Recipe object serves it (Bing's structured data documentation). Yandex's Recipe documentation lists name and recipeIngredient as required for its recipe partner program, and its Webmaster tools include a structured data validator.

To make a recipe eligible for ChatGPT search, allow OAI-SearchBot to crawl it (ChatGPT search documentation, crawler documentation). Perplexity's crawler documentation describes its robots.txt controls. Keep the recipe in visible HTML. See whether AI systems use schema markup.

Common mistakes and a maintenance routine

Most recipe markup problems come from a short list. Scan your pages for these before you publish and after every template or plugin change.

  • Two plugins, or a plugin and a theme, emit duplicate Recipe objects.
  • Ratings or nutrition appear in the markup but not on the page.
  • The name, ingredients, image or times differ between the page and the JSON-LD.
  • The image is a placeholder, is blocked from crawling, or the recipe URL is not the canonical one.
  • Durations are plain text instead of ISO 8601, such as PT20M.
  • cookTime appears without prepTime, or calories appear without recipeYield.
  • Instructions are incomplete, duplicated or hidden from visitors.
  • A roundup page is marked up as one Recipe instead of an ItemList of separate recipe URLs.

Recipes change. When you edit an ingredient, a time or a photo, update the markup in the same edit, or let your plugin do it and confirm the published page afterward. Re-test whenever the recipe template changes, because a template edit can silently alter every recipe page at once.

Questions people ask

What properties are required for Google recipe rich results?

For Google's recipe feature, name and image are required. The other supported properties, including recipeIngredient, recipeInstructions, prepTime, cookTime and recipeYield, are recommended. Meeting the requirements makes a page eligible, and Google decides whether to show a result.

Is aggregateRating required for recipes?

No. Google lists aggregateRating as recommended, and only for genuine ratings that the page displays. A recipe with no ratings should leave it out rather than invent a score.

Can I use plain text for recipeInstructions?

Google's documentation recommends HowToStep objects for the instructions, and the Sunrise Oat Muffins example uses them. Each step becomes its own object with a text value, and a recipe with several stages can group steps in HowToSection. Match the steps to the ones visitors can read on the page.

Can I add Recipe schema manually if my platform already outputs structured data?

You can, but check first for an existing Recipe object in the published HTML. Wix allows manual JSON-LD, Squarespace does not list Recipe among its automatic types, and Webflow recommends keeping schema in one place. Replace or turn off the other source rather than running two copies.

Does Schema.org validation mean my recipe is eligible for Google?

No. The Schema.org Validator checks syntax and extracts the structured data it finds, and it does not decide eligibility for Google's recipe feature. Use Google's Rich Results Test for Google's requirements and Bing's URL Inspection for how Bing reads the page.

Quick check: required, optional and collections

Choose an answer to see feedback. Nothing is scored or saved.

Question 1 of 3

Which properties does Google's recipe feature require?

Question 2 of 3

A recipe has no ratings on its page. What should the markup do about aggregateRating?

Question 3 of 3

Which type describes a roundup page that links to several recipe URLs?

Terms used in recipe markup

Select a term to see its definition.

Recipe. The schema.org type for one dish and its preparation.