Recipe Schema Markup: The JSON-LD That Puts Stars and Cook Times in the Results

Here is the uncomfortable fact about recipe search: the words on your page matter less than the structure around them. Two publishers can post nearly identical butter tart recipes, and the one whose page carries complete Recipe JSON-LD gets the photo, the star rating, the "55 min" label, and a shot at the carousel at the top of the results. The other gets a blue link. Same dish, same effort in the kitchen, very different outcome in the results page. This guide gives you the full picture: a complete valid example you can adapt, the rules for each property, the mistakes that quietly cancel eligibility, and a case for why restaurants, not just food bloggers, should care. In our 12 Vectors methodology this whole page lives inside Vector 6, Structure: markup that machines read with high confidence.

What recipe schema markup actually does

Recipe markup is a block of JSON-LD, a script tag containing structured data, that restates your recipe in a vocabulary defined at Schema.org and read by Google, Bing, Pinterest, and every AI assistant that crawls the web. The visible page serves the human; the markup serves the machine. When both agree, Google becomes willing to decorate your listing with the recipe rich result: an image thumbnail, star rating, total time, and calorie count directly in the search results, plus eligibility for the recipe carousel and grid on mobile.

Nothing about the markup changes your rank. Google's documentation is plain on this point, and any agency implying otherwise is selling you decoration as if it were foundation. What the markup changes is what your listing looks like when it appears, and appearance drives clicks. A result carrying stars and a photo pulls attention away from plainer neighbours above and below it. That presentation edge is the entire business case, and for food content it is a large one because recipe queries trigger visual result formats more than almost any other query class.

Who actually needs recipe markup

Three groups, in descending order of obviousness:

• Food bloggers and recipe publishers. No debate here. If recipes are the product, complete Recipe JSON-LD on every post is table stakes, and most WordPress recipe plugins emit it automatically. The work is verifying the output, not creating it.
• Restaurants that publish recipe content. This is the overlooked group. A restaurant blog that shares a house dressing, a simplified take on a menu dish, or a seasonal preserve is publishing recipe pages whether it thinks of them that way or not. Marked up properly, each one becomes a search asset that introduces the kitchen to people who have never heard the restaurant's name. More on this below, because the mechanics deserve their own section.
• CPG and food brands. The "recipes" section on a sauce or flour brand's site exists to create usage occasions. Without markup, those pages compete on domain strength alone. With it, a niche product's recipe page can earn a rich result the grocery giant's thin page does not.

Who does not need it: anyone tempted to stretch the definition. Google's guidelines are explicit that Recipe markup describes preparing a particular dish, and their documentation names "facial scrub" and "party ideas" as invalid recipe names. DIY cosmetics, craft tutorials, and cocktail "concepts" without real preparation steps belong in other schema types or none at all.

A complete, valid Recipe JSON-LD example

The block below is a full working example for a fictional Ontario classic. Every property in it is either required or recommended by Google's Recipe documentation, and the whole block passes the Rich Results Test as written. Swap in your own values, keep the shapes identical.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "name": "Maple Butter Tarts",
  "image": [
    "https://example.com/photos/butter-tarts-1x1.jpg",
    "https://example.com/photos/butter-tarts-4x3.jpg",
    "https://example.com/photos/butter-tarts-16x9.jpg"
  ],
  "author": {
    "@type": "Person",
    "name": "Jane Cormier"
  },
  "datePublished": "2026-07-19",
  "description": "Classic Ontario butter tarts with a maple syrup filling and flaky all-butter pastry.",
  "prepTime": "PT30M",
  "cookTime": "PT25M",
  "totalTime": "PT55M",
  "recipeYield": "12 tarts",
  "recipeCategory": "Dessert",
  "recipeCuisine": "Canadian",
  "keywords": "butter tarts, maple syrup, Ontario baking",
  "recipeIngredient": [
    "2 cups all-purpose flour",
    "1 cup cold butter, cubed",
    "3/4 cup maple syrup",
    "2 eggs",
    "1/2 cup brown sugar",
    "1 tsp vanilla extract",
    "1/4 tsp salt"
  ],
  "recipeInstructions": [
    {
      "@type": "HowToStep",
      "name": "Make the pastry",
      "text": "Cut the cold butter into the flour and salt until pea-sized, add ice water one spoonful at a time, and chill the dough for 30 minutes."
    },
    {
      "@type": "HowToStep",
      "name": "Fill the shells",
      "text": "Roll and cut the dough, press into a muffin tin, then whisk the maple syrup, eggs, brown sugar, and vanilla and fill each shell two-thirds full."
    },
    {
      "@type": "HowToStep",
      "name": "Bake",
      "text": "Bake at 200 C (400 F) for 20 to 25 minutes, until the filling bubbles and the pastry edges turn golden brown."
    }
  ],
  "nutrition": {
    "@type": "NutritionInformation",
    "calories": "310 calories"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "ratingCount": "127"
  }
}
</script>

One caution before you copy it: the aggregateRating block is only legitimate when those 127 ratings genuinely exist on your page from real users. We cover why in the disqualifiers section.

Name, image, author: the properties that gate eligibility

name must be the dish itself, nothing more. "Maple Butter Tarts" works; "Maple Butter Tarts You NEED This Summer!" invites Google to rewrite or distrust the field. Match it to your visible H1 as closely as sanity allows.

image is where the most recipes quietly fail. Google wants high-resolution photos of the finished dish, minimum 50,000 pixels when width is multiplied by height, and favours coverage of three aspect ratios: 1:1, 4:3, and 16:9. That is why the example supplies an array of three URLs rather than a single photo. A recipe with no image is flatly ineligible for the carousel. A recipe with one low-resolution image sits in a grey zone where Google may show a text-only result even when everything else is perfect.

author costs you thirty seconds and signals accountability. A named Person beats a brand string, and if the author has a profile page on your site, linking the two entities together strengthens the whole graph. Our walkthrough on how to add schema markup covers connecting author entities across page types.

Times and yield: the ISO 8601 trap

All three time fields use ISO 8601 duration format: PT30M for thirty minutes, PT1H15M for an hour and a quarter. Writing "30 minutes" as the value is one of the most frequent hard errors in recipe validation, and it is invisible to the eye because the rendered recipe card on the page shows human-readable times regardless. Two rules keep the fields honest. First, if you supply cookTime you must supply prepTime alongside it; the pair travels together in Google's requirements. Second, totalTime should equal the sum of the two, or stand alone without them. A recipe claiming a 55-minute total over a 30-minute prep and 45-minute cook reads as sloppy to a parser and to an attentive cook alike.

recipeYield takes a plain string: "12 tarts", "4 servings", "one 9-inch pie". Give the unit, not just a number. Assistants answering "how many does this make" quote this field directly.

Ingredients and instructions: arrays, not paragraphs

recipeIngredient is a flat array of strings, one ingredient per entry, each including quantity and preparation state: "1 cup cold butter, cubed", not "butter". Do not include section headers or steps in this array; parsers treat every entry as a purchasable item.

recipeInstructions is where publishers leave the most value on the table. The property accepts a plain text blob, and a plain text blob is what many hand-rolled implementations supply. But Google's step-by-step display, the format where each step gets its own card with an optional image, only activates when instructions arrive as an array of HowToStep objects with distinct name and text fields, as in the example above. For long recipes, HowToSection objects can group steps under headings like "For the pastry" and "For the filling". The rule of thumb: if your visible recipe has numbered steps, your markup should have the same number of HowToStep objects, in the same order, with matching text.

Nutrition and aggregateRating: the trust fields

nutrition takes a NutritionInformation object, and while the vocabulary supports over a dozen sub-properties, Google's recipe rich result surfaces exactly one: calories, expressed as a string with the unit, "310 calories". Supplying it is worth doing because the calorie figure prints directly in the search result, and health-conscious searchers filter with their eyes before they click.

aggregateRating is the highest-stakes property in the entire type. Those gold stars move click-through more than any other element of the rich result, which is precisely why Google polices them. The ratings must come from actual users of your site, be visible on the page, and be collectible by any visitor. Ratings imported from another platform, invented outright, or gated so only positive reviews save are all violations of the structured data policies, and the penalty is not proportionate: a manual action for review markup abuse can strip rich result eligibility from the whole domain. If your page has no rating mechanism, omit the property. An honest recipe card without stars outperforms a domain-wide penalty every week of the year.

The disqualifiers: how valid markup still loses

Passing the Rich Results Test is the start of eligibility, not the end. These are the failure patterns we see most when auditing food and restaurant sites:

The pattern underneath all six: rich results are a trust exchange. Google shows your data above its own snippet logic only while your data proves reliable. Every shortcut spends that trust, and it does not refill quickly.

The restaurant tie-in: recipe pages as a front door

Now the part almost none of the ranking guides on this keyword address. Restaurants treat recipes as trade secrets, and for the true signature dish that instinct is right. But a restaurant that publishes even a handful of secondary recipes, the house vinaigrette, the brine for the wings, a home-scale version of a brunch dish, acquires something a menu page can never earn: query surface. Nobody searches "restaurant near me that has a good vinaigrette". Thousands of people in your delivery radius search "how to make honey garlic wings" every month, and a marked-up recipe page puts your kitchen's name, photography, and voice in front of them at the exact moment they are thinking about that flavour.

Matt has watched this play out in audits of Ontario hospitality sites. His observation from that work: "The restaurant sites we review almost always have the ingredients of a recipe program already sitting in a neglected blog, chef posts, seasonal write-ups, dishes explained in prose. What they never have is the markup. It is the closest thing to free inventory I see in local search: content already written, eligibility already earned, and nobody has flipped the switch that makes engines treat it as recipes."

The implementation stack for a restaurant is straightforward: Recipe JSON-LD on the recipe posts, LocalBusiness or Restaurant markup on the core site (our local business schema guide walks through that layer), and internal links from each recipe to the menu and reservation pages so the borrowed attention has somewhere to land. The recipe ranks, the reader clicks through, and a percentage of them notice the kitchen is twenty minutes away. That funnel is a core pattern in our SEO for restaurants playbook, and it compounds further once AI assistants start answering food queries for your city, which is the territory covered by our GEO for restaurants solution.

A YMYL note for this audience: no markup guarantees a rich result, and Google decides eligibility per query. Plan recipe content as a durable asset with variable decoration, not as a promised placement.

Testing, monitoring, and keeping the markup honest

Three habits keep a recipe library healthy:

• Test before publishing. Run each new page through Google's Rich Results Test and treat warnings as a to-do list, not background noise. Warnings mark missing recommended properties, and recommended properties are what separate carousel candidates from plain-card recipes.
• Watch Search Console's enhancement reports. The Recipes report surfaces items with errors and warnings across the whole site. A plugin update that silently changes markup output shows up here first, usually as a sudden spike in one error type across every recipe at once.
• Re-verify after redesigns. Theme changes are the most common moment recipe markup silently breaks or duplicates. Budget an hour of validation into every redesign, because the rich results you lose take weeks to return after the fix.

If you want a second set of eyes before you invest, we run this exact review as part of our audit; the form at the bottom of this page starts it. Or browse the rest of the structured data series in our research library first and do the pass yourself.

What recipe structure earns beyond Google

The same JSON-LD Google reads also feeds Pinterest rich pins, some smart display cooking modes, and grocery-list features in various apps. And while Google has said generative AI features do not require structured data, the editorial discipline that markup enforces, one dish per URL, explicit quantities, ordered steps, stated yield and times, is exactly the shape retrieval systems quote most accurately. When an assistant reconstructs your recipe for a user, a structured page gets reproduced faithfully with attribution far more often than a rambling prose page where the ingredients hide inside a story. Write for the card format and both audiences, crawler and chatbot, get served by the same work.

Prefer to talk it through with a person first? Reach out and we will look at your recipe pages together.