Recipe schema markup is the structured data type for food and cooking content. When implemented correctly, it can dramatically change how your recipe pages appear in search results — surfacing the dish image, aggregate rating, total cook time, and calorie count directly in the SERP before a user ever clicks. Recipe schema markup is one of the few schema types where the rich result is visually rich enough to have a measurable click-through impact, especially in the recipe carousel and image search filter. The prerequisite is that the full recipe — ingredients, step-by-step instructions, and ideally nutritional information — must be on the page. A blog post that mentions a recipe in passing does not qualify, and marking it up as if it does will cost you eligibility.

What is recipe schema markup?

The schema.org/Recipe type is a machine-readable description of a complete recipe. It connects all the components — name, author, image, timing, ingredients, instructions, nutrition — into a single structured object that Google can parse across multiple surfaces: standard search results, the recipe carousel, Google Images’ recipe filter, and voice assistants. When Google validates the markup and the page meets its content guidelines, it can display a rich result that includes the recipe image, star rating (if present), total time, and calorie count. The Recipe type also feeds Google Discover and Lens, where structured data on food content improves surfacing in visual contexts. It is one of the more complete structured data types in terms of the number of properties it supports, which is part of why thin or incomplete implementations rarely unlock the full rich result.

What properties are required for recipe rich results?

Google’s documentation distinguishes between properties required to be eligible for a rich result and recommended properties that improve completeness. For the recipe rich result:

  • name (required) — must match the visible recipe heading on the page
  • image (required) — one or more high-quality images of the finished dish; Google recommends multiple aspect ratios (1×1, 4×3, 16×9); this is required — without it, the markup validates but no rich result will appear
  • author (required) — a Person or Organization with a name; the recipe creator, matching what is shown on the page
  • datePublished (recommended) — ISO 8601 date; helps Google assess freshness
  • description (recommended) — a brief summary of the dish
  • prepTime (recommended) — ISO 8601 duration for prep; e.g., PT20M for 20 minutes
  • cookTime (recommended) — ISO 8601 duration for active cooking
  • totalTime (recommended) — sum of prep and cook time; include all three for best coverage
  • recipeYield (recommended) — number of servings or pieces produced
  • recipeIngredient (recommended) — array of ingredient strings exactly as written on the page
  • recipeInstructions (recommended) — array of HowToStep objects; structured steps unlock step-by-step rich results
  • nutrition (recommended) — a NutritionInformation object; include at minimum calories to unlock the calorie display
  • aggregateRating (recommended, only if real ratings exist on the page) — AggregateRating with ratingValue and ratingCount; do not include if you have no visible user ratings

A working recipe schema JSON-LD example

Here is a complete Recipe JSON-LD block. Every value should be pulled from what is actually on the page — do not invent timing or yield values to populate the markup.

{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "name": "Classic Sourdough Bread",
  "image": [
    "https://example.com/images/sourdough-1x1.jpg",
    "https://example.com/images/sourdough-4x3.jpg",
    "https://example.com/images/sourdough-16x9.jpg"
  ],
  "author": {
    "@type": "Person",
    "name": "Terry Samuels"
  },
  "datePublished": "2025-09-01",
  "description": "A straightforward sourdough loaf with an open crumb and chewy crust, built around a 75% hydration dough.",
  "prepTime": "PT12H",
  "cookTime": "PT45M",
  "totalTime": "PT12H45M",
  "recipeYield": "1 loaf (about 900g)",
  "recipeIngredient": [
    "450g bread flour",
    "325g water",
    "90g active sourdough starter",
    "9g salt"
  ],
  "recipeInstructions": [
    {
      "@type": "HowToStep",
      "name": "Autolyse",
      "text": "Mix flour and water in a large bowl until no dry flour remains. Cover and rest 30 minutes."
    },
    {
      "@type": "HowToStep",
      "name": "Add starter and salt",
      "text": "Add starter and salt. Work into the dough with wet hands, then fold every 30 minutes for 3 hours."
    },
    {
      "@type": "HowToStep",
      "name": "Shape and proof",
      "text": "Shape the dough, place in a floured banneton, and refrigerate overnight (8 to 12 hours)."
    },
    {
      "@type": "HowToStep",
      "name": "Bake",
      "text": "Preheat oven to 500F with a Dutch oven inside for 45 minutes. Score, bake covered 20 minutes, then uncovered 25 minutes."
    }
  ],
  "nutrition": {
    "@type": "NutritionInformation",
    "calories": "180 calories",
    "servingSize": "1 slice (60g)"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "ratingCount": "134",
    "bestRating": "5",
    "worstRating": "1"
  }
}

How to add recipe schema in WordPress

For food bloggers and recipe sites using WordPress, a dedicated recipe plugin is almost always the right choice. Two that generate well-formed Recipe schema automatically: WP Recipe Maker (clean JSON-LD output, supports multiple images, HowToStep instructions, and NutritionInformation) and Tasty Recipes (used by many large food blogs, known for reliable schema output and good block editor integration). Both handle ISO 8601 duration formatting automatically, which is one of the most common manual implementation errors. If you are not using a recipe plugin and are writing JSON-LD manually, paste it into a Custom HTML block in the WordPress editor or inject it via a wp_head hook in your child theme. For the general mechanics of adding schema to WordPress, see my guide on how to add schema markup.

One note on plugin-generated schema: always validate the output after setup. I have reviewed sites where the plugin had missing author fields, plain-string recipeInstructions instead of HowToStep arrays, or no image at all — all of which suppress the rich result. Do not assume a recipe plugin means you have valid recipe schema. Test it.

How to test recipe schema markup

Run your page URL through Google’s Rich Results Test and look for the Recipe type in the detected structured data. The test will flag missing required properties — most commonly a missing image or a plain-string recipeInstructions — and show a preview of the potential rich result. For structural validation, the Schema Markup Validator will catch type-level issues like incorrect ISO 8601 duration formatting. Common duration errors I see in audits: writing P12H instead of PT12H (the T is required before time components), or writing 45 minutes as a plain string instead of PT45M. After publishing, check Google Search Console under Enhancements > Recipes for coverage errors. For my full testing methodology, see how to test schema markup.

Why recipe schema matters for AI search and voice

Voice assistants regularly read recipe steps aloud to users cooking in the kitchen. When a user says “next step,” the assistant needs to know exactly where one step ends and the next begins. That is what HowToStep objects provide: clear, discrete, machine-readable steps. Without structured instructions, a voice assistant has to parse the prose of your recipe body and guess where the steps are. With them, it can navigate the recipe programmatically. This is a practical reason to use structured steps — not a soft SEO benefit.

For AI Overviews, recipe schema provides explicit anchors: total time, calorie count, ingredient list, serving size. When a user asks for a quick recipe under a certain calorie count, an AI system reading your structured data can answer from the schema properties alone rather than parsing the article. Pages with complete Recipe markup — including nutrition and totalTime — are more likely to be surfaced accurately in AI-generated recipe recommendations. See my article on structured data for SEO and my overview of rich snippets.

Common mistakes in recipe schema markup

  • Omitting image entirely. Image is required for recipe rich results — without it, the markup validates but no rich result will appear. Include at least one image, ideally in multiple aspect ratios.
  • Using a plain string for recipeInstructions. Both are technically valid schema, but a plain string produces no step-by-step rich result and no voice-navigable steps. Always use an array of HowToStep objects.
  • Getting ISO 8601 duration format wrong. Twelve hours is PT12H, not P12H. Forty-five minutes is PT45M. Most duration errors come from manually written JSON-LD; use a plugin or a duration formatter to avoid them.
  • Including aggregateRating without visible user ratings. If you have no rating system on the page, do not include aggregateRating. This is a policy violation that can result in a manual action.
  • Marking up a recipe not fully on the page. If you summarize a recipe or reference one from another source without showing the full ingredient list and instructions, the markup does not apply. Google expects the structured data to describe content visible to the user on that specific URL.

Recipe schema is one of the higher-ROI structured data implementations for food and cooking content — the visual rich result has a measurable impact on click-through rate when it appears. If your recipe content is not generating rich results, or if you are getting coverage errors in Search Console, I can review the implementation through my schema markup consulting service or a dedicated schema audit. For aggregate rating markup that works inside recipe schema, see AggregateRating schema markup.