Recipe Schema for WordPress: The Complete 2026 Guide

Recipe schema is one of the most visually rewarded types of structured data you can add to a WordPress site, and one of the most demanding, because Google actually checks whether your markup matches what's genuinely on the page. Done right, it can put your dish into Google's recipe card results with a photo, star rating, and cook time, into Google Images with a recipe badge, and increasingly into the AI Mode recipe panels people now use to decide what to cook.

This guide covers everything: the required and recommended fields, ISO 8601 timing formatted correctly, a complete JSON-LD example, star ratings (recipes are one of the few types allowed to show them on your own site), nutrition, video, and the specific way AI systems process your recipe that most guides skip entirely: they read your text, not your photo. Let's get your recipes seen.

What Recipe schema gets you

Recipe structured data tells Google a page describes preparing a specific dish, and hands over the facts (ingredients, steps, timing, servings, nutrition) in a form search and AI systems can display and extract rather than infer from your prose.

The headline payoff is Google's recipe rich result: an eye-catching card with a photo, star rating, and cook time that stands out in a results page full of plain blue links. Recipes with complete markup are also eligible to appear with a recipe badge in Google Images, and if you run a recipe hub, a properly configured host carousel can showcase several of your recipes together at the top of results for broader queries.

There's a newer payoff worth understanding on its own terms, because it's changed fast in 2026. Google's AI Mode now generates dedicated recipe panels for meal-idea queries like "easy dinners for two," and the fields those panels pull are, functionally, your Recipe schema: cook time, prep time, author, aggregate rating, and a hero image. Google rolled this out through the year specifically in response to creator backlash over AI summaries that answered the question without sending any traffic back to the source, and a March 2026 update from Google's VP of Search Product put clickable recipe images and direct links back in front of the AI-generated summary rather than buried beneath it. Google hasn't stated that schema is required for this treatment, but the property-for-property overlap with Recipe markup is close enough that a clean schema audit is the most defensible thing you can do right now if recipes are part of your traffic.

One placement rule up front: Recipe schema belongs on the individual recipe's own page, describing one dish. It's not for a roundup post like "10 Easy Pasta Recipes," that's a job for ItemList, which we cover separately below, alongside your regular recipe markup.

The required fields (and why they're the bare minimum)

Google's Recipe rich result has just two required properties:

• name, the name of the dish
• image, an image of the completed dish

That's genuinely it for eligibility. But treat that as the floor, not the target. Google is explicit that the more recommended properties you provide, the higher-quality result users get, and that shows up directly in ranking consideration for the rich result. A page with only name and image is technically eligible; a page with the full recommended set is competitive.

So build toward this recommended set as part of the job, not as optional polish:

• author, the person or organization who wrote the recipe
• datePublished, in ISO 8601 format
• description, a short summary of the dish
• prepTime, cookTime, totalTime, in ISO 8601 duration format
• recipeYield, servings produced
• recipeCategory and recipeCuisine, meal type and regional style
• recipeIngredient, each ingredient as its own list item
• recipeInstructions, the steps, ideally as HowToStep objects
• nutrition, at minimum, calories per serving
• aggregateRating, genuine review data
• video, a video of the steps, if you have one
• keywords, descriptive terms beyond category and cuisine

Fill these in and you're giving Google, and now AI Mode, the complete picture rather than the bare minimum that gets you in the door.

A complete Recipe example

Here's a fully-populated Recipe block showing how the pieces connect:

{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "name": "Classic Apple Pie",
  "image": [
    "https://example.com/photos/apple-pie-1x1.jpg",
    "https://example.com/photos/apple-pie-4x3.jpg",
    "https://example.com/photos/apple-pie-16x9.jpg"
  ],
  "author": {
    "@type": "Person",
    "name": "Maria Santos"
  },
  "datePublished": "2026-09-02",
  "description": "A classic double-crust apple pie with a golden, flaky crust and a warmly spiced filling.",
  "prepTime": "PT30M",
  "cookTime": "PT45M",
  "totalTime": "PT1H15M",
  "recipeYield": "8 servings",
  "recipeCategory": "Dessert",
  "recipeCuisine": "American",
  "keywords": "cinnamon apple pie, homemade pie crust",
  "recipeIngredient": [
    "1 (15 ounce) package double crust ready-to-use pie crust",
    "6 cups thinly sliced, peeled apples",
    "3/4 cup sugar",
    "2 tablespoons all-purpose flour",
    "3/4 teaspoon ground cinnamon",
    "1/4 teaspoon salt",
    "1 tablespoon lemon juice"
  ],
  "recipeInstructions": [
    {
      "@type": "HowToStep",
      "name": "Preheat",
      "text": "Heat oven to 425°F.",
      "url": "https://example.com/apple-pie#step1",
      "image": "https://example.com/photos/apple-pie/step1.jpg"
    },
    {
      "@type": "HowToStep",
      "name": "Prepare crust",
      "text": "Place one pie crust in an ungreased 9-inch glass pie plate, pressing firmly against the sides and bottom.",
      "url": "https://example.com/apple-pie#step2",
      "image": "https://example.com/photos/apple-pie/step2.jpg"
    },
    {
      "@type": "HowToStep",
      "name": "Bake",
      "text": "Bake 40 to 45 minutes, until the apples are tender and the crust is golden brown.",
      "url": "https://example.com/apple-pie#step3",
      "image": "https://example.com/photos/apple-pie/step3.jpg"
    }
  ],
  "nutrition": {
    "@type": "NutritionInformation",
    "calories": "320 calories"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "ratingCount": "156"
  }
}

A few things to notice, because they're the details that trip people up. The image array uses three aspect ratios (1x1, 4x3, 16x9): Google recommends all three for the best chance of display, each at least 50,000 total pixels (width × height). The timing fields use ISO 8601 duration format, not plain English. And nutrition.calories only makes sense alongside recipeYield, since calories are calculated per serving. If you specify one, you need the other.

ISO 8601 timing: the format Google actually requires

This is the single most common technical mistake in Recipe markup, so it's worth being precise about the format.

Google requires prepTime, cookTime, and totalTime in ISO 8601 duration format, not "30 minutes" or "1 hour 15 min." The pattern is PT followed by hours (H), minutes (M), and seconds (S):

• PT30M = 30 minutes
• PT1H = 1 hour
• PT1H15M = 1 hour 15 minutes
• PT2H30M = 2 hours 30 minutes

The P marks the start of the duration, and T marks the start of the time component. You'll always see PT at the front for cook and prep times, since you're never expressing a duration in days or months here. Google pairs prepTime and cookTime together when both apply, and you can use totalTime on its own or alongside them, but not neither. A recipe with no timing information at all is technically still eligible (timing is recommended, not required), but it's a weak, incomplete entry next to competitors who included it, and it's exactly the kind of detail AI Mode's recipe panels are now surfacing directly. This is the same ISO 8601 discipline that matters for Event schema's start and end times: get comfortable with the format once and it applies everywhere duration or datetime shows up in schema.

Instructions: HowToStep, HowToSection, and what not to include

recipeInstructions accepts three formats, and Google's clear recommendation is HowToStep, a distinct object for each step, as shown in the example above.

You can also submit instructions as a single plain-text block, and Google will attempt to auto-split it into steps, but that's a fallback, not a strategy. Auto-splitting has to guess where one step ends and the next begins, and it tries to strip out section names, step numbers, and other text that doesn't belong in the instruction itself. Marking up explicit HowToStep objects avoids that guesswork entirely.

Only use HowToSection if your recipe genuinely has sections. Google is explicit that most recipes don't. A pizza recipe with a distinct crust-making phase and a topping phase is a legitimate case for sections; a straightforward one-pot dinner isn't. Don't add structure that doesn't reflect how the recipe is actually organized.

One rule that's easy to miss: keep instruction text to the instruction itself. Don't write "Step 1. Heat oven to 425°F." The "Step 1." belongs in your visible page design, not in the text property. Google's own guidance flags this exact pattern as something to avoid. The same goes for phrases like "Watch the video" or "Directions," put those outside the structured data.

Star ratings: Recipe is one of the few types that can self-serve

Here's good news that a lot of business schema guides won't tell you, because it's specific to certain content types: Recipe is one of the types explicitly allowed to carry aggregateRating for reviews about itself, on your own site.

This matters because Google's broader "self-serving review" rule blocks most business types. A LocalBusiness or Organization can't mark up reviews about itself and expect a star snippet. Recipe, along with Product, Book, Course, SoftwareApplication, and a handful of other item types, is exempt from that restriction, because these are reviews of a specific item rather than a business reviewing itself. If your site collects genuine reader ratings on the recipe ("4.7 stars, 156 ratings"), marking that up with aggregateRating is exactly what the star display is for.

The catch that applies regardless of type: your ratingValue and ratingCount must match what a visitor genuinely sees on the page. If your markup claims 156 ratings and the page shows 40, or your rating widget only renders after JavaScript runs, the numbers don't agree and the rich result becomes ineligible. This is also where the July 2026 rule change on incentivized reviews applies: a review written for a discount or free product needs that incentive clearly disclosed, or it shouldn't be marked up at all. We cover the full mechanics of eligible types, the self-serving trap, and the new incentivized-review rule in our guide to getting star ratings in Google Search, worth a read if ratings matter to your recipe traffic, which for most food sites they genuinely do.

Nutrition and yield

nutrition.calories is the one nutrition property Google explicitly supports for the rich result, and the rule tying it to recipeYield is easy to get backwards: if you specify calories, you must also specify how many servings the recipe yields, because calories are inherently a per-serving figure. Without a stated yield, a calorie count is meaningless to a machine trying to display it accurately.

Write recipeYield as a plain number of servings, or add a second value if you also want to express yield another way (say, "24 cookies" alongside "6 dozen"). Keep the calorie figure itself simple: "320 calories" is the expected format, not a breakdown of macros, since Google's supported schema for this rich result only reads the calorie count.

Video: a real payoff, worth the extra field

If you have a video showing the recipe steps, attach it with the video property, following the same required and recommended fields as standalone VideoObject markup: name, description, thumbnailUrl, contentUrl or embedUrl, and uploadDate at minimum. Google's own guidance encourages linking video to specific steps: if your video shows each stage of the process, you can attach a video or clip to the individual HowToStep rather than only at the recipe level, so a viewer can jump straight to the step they need.

Video is worth the extra implementation effort for recipes specifically, because recipe content is genuinely well-suited to it: showing a fold, a knead, or a plating technique communicates in a way text alone doesn't. It also gives you a second surface (Google Videos, video rich results) beyond the recipe card itself.

The host carousel: ItemList for recipe collections

If you run a "Best Chocolate Desserts" roundup or a recipe index page, that page can be eligible for Google's host carousel, a scrollable strip of your own recipes shown together, but it needs its own markup, separate from any individual recipe's Recipe block.

Add ItemList structured data to the summary page, with each recipe as a ListItem carrying a position and a url:

{
  "@context": "https://schema.org",
  "@type": "ItemList",
  "itemListElement": [
    { "@type": "ListItem", "position": 1, "url": "https://example.com/apple-pie.html" },
    { "@type": "ListItem", "position": 2, "url": "https://example.com/blueberry-pie.html" },
    { "@type": "ListItem", "position": 3, "url": "https://example.com/cherry-pie.html" }
  ]
}

For this to work, the summary page has to be a genuine landing page that lists the recipes, not just a keyword-stuffed page that happens to contain some recipe links. Google follows the click from the carousel to this page, so it needs to actually deliver what the carousel promised.

AI reads the text, not the photo

Here's the point most Recipe schema guides skip entirely, and it changes how you should think about your markup.

Your photography sells the dish to a human reader: the golden crust, the glossy glaze, the steam coming off the plate. It does none of that work for an AI system. Language models and AI crawlers process your page's text and structured data; they don't "see" your hero image the way a person scrolling Pinterest does. If the facts that make your recipe distinctive (the exact bake time, the specific substitution, the reason this crust technique works) live only in a photo caption or, worse, only in the visual composition of the shot, an AI summarizing or citing your recipe has nothing to work with. The same logic applies well beyond recipes: our playbook for getting cited by ChatGPT covers the broader pattern of making your content legible to AI systems, not just search engines.

This is exactly why the required and recommended Recipe properties matter more than they might seem to at a glance. prepTime, cookTime, recipeYield, recipeIngredient, and recipeInstructions aren't just rich-result eligibility checkboxes, they're the explicit, machine-readable version of the facts your photo is silently implying to a human. When a food-focused AI answer synthesizes "how long does this take" or "what's actually in it," it's pulling from your markup and your prose, not inferring from a photograph of a finished pie. A visually stunning recipe page with thin or missing structured data is legible to a person and largely illegible to a machine, and as more people ask AI assistants for meal ideas rather than scrolling image results, that gap has a real cost.

The practical takeaway: don't let your best information live exclusively in an image or a caption. State your key facts in text and in schema, and let the photography do what it does best: making a human want to click.

Common mistakes to avoid

Plain-English timing instead of ISO 8601. "45 minutes" isn't valid cookTime; it needs to be PT45M. This is the single most common syntax error in Recipe markup.

Calories without a stated yield. nutrition.calories requires recipeYield alongside it, since calories are per-serving.

Recipe schema on a roundup page. A "10 Best Cookie Recipes" page needs ItemList, not a Recipe block describing ten different dishes as if they were one.

Step numbers baked into instruction text. "Step 1: Preheat the oven" should just be "Preheat the oven," put step numbering in your visible design, not the markup.

Rating counts that don't match the page. If your aggregateRating claims more reviews than a visitor can actually see, the snippet becomes ineligible, and it's the most common reason star ratings quietly disappear after a redesign.

Adding HowToSection to a recipe that doesn't have sections. Most recipes don't need it. Forcing structure that isn't genuinely there adds complexity without benefit.

Missing multiple image aspect ratios. A single square photo works, but Google recommends 1x1, 4x3, and 16x9 for the best chance of display across different result formats.

Markup that doesn't match the page. As always, your schema has to reflect what's genuinely on the page: the real ingredients, the real steps, the real ratings.

Implementing it on WordPress

Most WordPress recipe sites run a recipe plugin, WP Recipe Maker, Tasty Recipes, or similar, that outputs some Recipe schema automatically. That's a reasonable starting point, but it's worth checking what it actually produces: view source on a live recipe page and confirm you're getting the full recommended set (ISO 8601 timing, nutrition.calories paired with recipeYield, HowToStep instructions, aggregateRating if you collect reviews) rather than just the two required fields.

The gap that shows up most often is exactly the one this guide has walked through: plugins built primarily around the visible recipe card sometimes under-populate the schema layer, especially newer fields like keywords or properly-typed instruction steps, and they don't connect your recipe author to a broader entity your site is building elsewhere.

This is where generating markup from your actual content helps. AI Schema Gen reads your recipe pages and produces complete Recipe schema across the recommended fields, timing in correct ISO 8601 format, ingredients and instructions structured properly, nutrition tied to yield, and because it generates from your live content, it stays accurate as you update a recipe rather than drifting out of sync the way a hand-edited JSON-LD block can. It also connects your recipe's author into your site's broader entity profile, which is part of what makes AI systems confident about who's behind the recipe, not just what the recipe contains.

Whatever route you take, the test is the same: does it cover the recommended fields, not just the two required ones; is your timing in valid ISO 8601; and does your aggregateRating, if present, genuinely match what's visible on the page.

Validating your Recipe schema

Google's Rich Results Test confirms eligibility and flags errors. Test a few real recipe pages, including one with a video and one without, since different fields are present in each.

The URL Inspection tool in Search Console shows how Google actually sees a live, indexed page, which is useful for catching JavaScript-rendering issues the Rich Results Test alone might not surface.

Search Console's Recipe rich result status report tracks valid and invalid items across your whole site over time, the place to watch after a plugin update or theme change, since a template-level bug shows up as a spike in invalid items across every recipe at once.

The Schema Markup Validator at validator.schema.org checks broader schema.org syntax validity beyond just the properties Google's rich result reads.

Running a recipe site on WordPress? AI Schema Gen generates complete Recipe schema, ISO 8601 timing, structured instructions, nutrition tied to yield, and rating data, straight from your recipe pages, and connects your recipe authors into your site's entity profile.