Recipe Schema Markup: A Step-by-Step Tutorial

If you’ve ever searched for a recipe on Google, you’ve probably noticed those eye-catching recipe cards that show a beautiful photo, star ratings, cooking time, and calorie information right in the search results. Those aren’t random—they’re the result of recipe schema markup, and they can transform how your recipes appear in search.

Recipe schema is a type of structured data that tells search engines exactly what’s in your recipe: the ingredients, cooking steps, nutrition facts, and more. When implemented correctly, this recipe structured data enables Google to display your recipes as rich, visually appealing rich results in Google Search that stand out from ordinary text links.

Why Recipe Structured Data Matters

In the crowded world of food content, recipe schema gives your recipes a competitive edge. Here’s what proper implementation can do for you:

• Visual rich results: Your recipes can appear with images, ratings, cook times, and calorie counts directly in search results
• Recipe carousel inclusion: Properly marked-up recipes can appear in Google’s dedicated recipe carousels
• Voice search compatibility: Google Assistant and other voice assistants use recipe schema to read back cooking instructions
• AI search integration: Recipe data feeds into Google’s AI features and conversational search experiences

Impact on Click-Through Rates

Recipe rich results are among the most visually striking in search. A recipe result showing a mouth-watering image, 4.8-star rating, 30-minute cook time, and 350 calories naturally attracts more attention than a plain text listing.

While we can’t guarantee specific CTR improvements (results vary by niche and competition), food bloggers consistently report that recipe schema implementation correlates with increased organic traffic and engagement.

Important: Having valid recipe schema makes you eligible for rich results—it doesn’t guarantee them. Google decides when and whether to display rich results based on many factors.

Understanding Recipe Structured Data

Understanding Recipe Structured Data refers to using structured data (Recipe schema) to clearly define your recipe content for search engines. It helps Google understand key details like ingredients, cooking steps, time, and nutrition making your content eligible for rich results such as recipe cards, ratings, and carousels. This improves visibility, enhances user experience, and supports AI-driven search and voice assistants.

What Is Recipe Schema?

Recipe schema is structured data vocabulary defined by Schema.org specifically for culinary content. It provides a standardized way to describe recipes so that search engines can understand and display recipe information accurately.

According to Schema.org, the Recipe type is defined as “A recipe for a food dish.” It includes properties for everything from basic information (name, description) to detailed cooking data (ingredients, instructions, nutrition).

How Google Interprets Recipe Schema

When Googlebot crawls a page with recipe schema, it extracts the structured data and uses it to:

1. Understand the recipe content (what dish, how long to make, ingredients needed)
2. Determine eligibility for recipe rich results
3. Display appropriate information in search results (image, time, ratings)
4. Include recipes in specialized features (recipe carousel, Google Assistant)

Google specifically looks for certain required and recommended properties to enable recipe rich results.

Required vs. Recommended Properties

JSON-LD vs. Microdata

Recipe structured data can be implemented in multiple formats, but Google recommends JSON-LD:

JSON-LD (Recommended): A JavaScript-based format that sits in a <script> tag, separate from your HTML content. It’s easier to implement, maintain, and debug. This is what we’ll use throughout this tutorial.

Microdata: HTML attributes embedded directly in your content markup. While functional, it’s more complex to implement and harder to maintain because changes to your HTML structure can break the schema.

For food bloggers and recipe sites, JSON-LD is almost always the better choice. It keeps your recipe schema clean and separate from your visual presentation.

Eligibility for Recipe Rich Results

Eligibility for Recipe Rich Results means meeting Google’s requirements so your recipe can appear as enhanced search results. Your page must contain a complete, original recipe with visible ingredients, step-by-step instructions, and a high-quality image. The structured data must match the on-page content exactly, and required properties like name and image must be included. Even with valid schema, appearance depends on content quality, relevance, and Google’s evaluation.

Google’s Content Guidelines

Not every page with recipe schema will display rich results. Google has specific guidelines your content must follow:

• Actual recipes only: The page must contain a genuine, complete recipe—not just recipe discussion or food photos
• Food dishes: Recipe schema is for food recipes, not cocktail recipes or non-food items
• Complete content: Include full ingredients and instructions, not just a teaser with “full recipe in comments”
• Original content: Don’t copy recipes from other sites and add schema—create original or properly attributed content

Required Visible Content Elements

Everything in your recipe schema must be visible on the page. Users should be able to see:

• The recipe name and description
• A photo of the finished dish
• Complete ingredient list
• Step-by-step instructions
• Cooking times (if included in schema)
• Ratings and reviews (if included in schema)

Structured Data Content Alignment

Your schema must accurately reflect your visible content. Common alignment issues include:

• Time mismatches: Schema says 30 minutes but page shows 45 minutes
• Ingredient differences: Schema lists different ingredients than visible recipe
• Missing content: Schema includes nutrition data not shown on page
• Inflated ratings: Schema shows higher rating than actual user reviews

Common Policy Violations

These violations can result in lost rich results or manual actions:

• Adding recipe schema to non-recipe content (food photography, restaurant reviews)
• Fake or self-generated ratings
• Recipe schema on pages with gated content (“Sign up to see full recipe”)
• Marking up video as a recipe without actual recipe content

Step-by-Step Implementation Guide

Let’s build a complete recipe schema from scratch. We’ll create a real example you can adapt for your own recipes. For non-recipe tutorials, learn how to implement HowTo schema markup for step-by-step guides.”

Complete JSON-LD Example

Here’s a comprehensive recipe schema for a Classic Chocolate Chip Cookies recipe:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "name": "Classic Chocolate Chip Cookies",
  "image": [
    "https://example.com/photos/cookies-1x1.jpg",
    "https://example.com/photos/cookies-4x3.jpg",
    "https://example.com/photos/cookies-16x9.jpg"
  ],
  "author": {
    "@type": "Person",
    "name": "Sarah Baker"
  },
  "datePublished": "2025-01-15",
  "description": "Perfectly chewy chocolate chip cookies with crispy edges and gooey centers. This family recipe has been perfected over 20 years.",
  "prepTime": "PT20M",
  "cookTime": "PT12M",
  "totalTime": "PT32M",
  "recipeYield": "24 cookies",
  "recipeCategory": "Dessert",
  "recipeCuisine": "American",
  "keywords": "chocolate chip cookies, cookies, baking, dessert",
  "recipeIngredient": [
    "2 1/4 cups all-purpose flour",
    "1 tsp baking soda",
    "1 tsp salt",
    "1 cup (2 sticks) butter, softened",
    "3/4 cup granulated sugar",
    "3/4 cup packed brown sugar",
    "2 large eggs",
    "2 tsp vanilla extract",
    "2 cups chocolate chips"
  ],
  "recipeInstructions": [
    {
      "@type": "HowToStep",
      "text": "Preheat oven to 375°F (190°C). Line baking sheets with parchment paper."
    },
    {
      "@type": "HowToStep",
      "text": "Whisk together flour, baking soda, and salt in a medium bowl. Set aside."
    },
    {
      "@type": "HowToStep",
      "text": "Beat butter and sugars together until light and fluffy, about 3 minutes."
    },
    {
      "@type": "HowToStep",
      "text": "Add eggs one at a time, then vanilla. Mix until combined."
    },
    {
      "@type": "HowToStep",
      "text": "Gradually add flour mixture, mixing on low. Fold in chocolate chips."
    },
    {
      "@type": "HowToStep",
      "text": "Drop rounded tablespoons of dough onto prepared baking sheets, spacing 2 inches apart."
    },
    {
      "@type": "HowToStep",
      "text": "Bake for 10-12 minutes until edges are golden but centers still look slightly underdone."
    },
    {
      "@type": "HowToStep",
      "text": "Cool on baking sheet for 5 minutes, then transfer to wire rack."
    }
  ],
  "nutrition": {
    "@type": "NutritionInformation",
    "calories": "180 calories",
    "servingSize": "1 cookie"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": 4.8,
    "ratingCount": 347
  }
}
</script>

Property-by-Property Breakdown

Let’s understand each property in detail:

@context and @type

"@context": "https://schema.org",
"@type": "Recipe",

These are required for all schema. @context tells processors this uses Schema.org vocabulary, and @type identifies this as a Recipe.

name

"name": "Classic Chocolate Chip Cookies",

The recipe title. This should match your visible recipe heading exactly. Keep it descriptive but concise.

image

Google recommends providing multiple images in different aspect ratios:

• 1:1 (square) – minimum 1200px wide
• 4:3 – minimum 1200px wide
• 16:9 – minimum 1200px wide

Always use high-quality photos of the finished dish. Avoid stock photos or unrelated images.

author

"author": {
  "@type": "Person",
  "name": "Sarah Baker"
},

The recipe creator. Use Person for individuals or Organization for brands. This builds credibility and attribution.

Time Properties (prepTime, cookTime, totalTime)

Times use ISO 8601 duration format:

• PT20M = 20 minutes
• PT1H = 1 hour
• PT1H30M = 1 hour 30 minutes
• P1D = 1 day (for recipes with overnight steps)

Only include times you can reasonably estimate. If prep time varies widely, use a reasonable average.

recipeIngredient

An array where each ingredient is a separate string. Include quantities and measurements:

"recipeIngredient": [
  "2 1/4 cups all-purpose flour",
  "1 tsp baking soda",
  "2 cups chocolate chips"
],

Each ingredient should be self-containeddon’t combine multiple ingredients in one string.

recipeInstructions

Use HowToStep objects for each instruction. This gives Google maximum understanding of your cooking process:

"recipeInstructions": [
  {
    "@type": "HowToStep",
    "text": "Preheat oven to 375°F (190°C)."
  },
  {
    "@type": "HowToStep",
    "text": "Whisk together flour, baking soda, and salt."
  }
],

Each step should be a complete action. Avoid combining multiple actions in one step.

nutrition

Nutritional information helps users make dietary decisions. Always include servingSize:

"nutrition": {
  "@type": "NutritionInformation",
  "calories": "180 calories",
  "servingSize": "1 cookie",
  "fatContent": "9g",
  "carbohydrateContent": "24g",
  "proteinContent": "2g"
},

Only include nutrition data you’ve actually calculated. Don’t guess—use a nutrition calculator or recipe analysis tool.

aggregateRating

Only include this if you collect genuine user ratings:

"aggregateRating": {
  "@type": "AggregateRating",
  "ratingValue": 4.8,
  "ratingCount": 347
}

Never fake ratings. If you don’t have a rating system, simply omit this property.

WordPress Implementation Options

If you’re running a food blog on WordPress, you have several ways to implement recipe schema:

Option 1: Recipe Plugins (Easiest)

Dedicated recipe plugins handle schema automatically:

• WP Recipe Maker: Free and premium versions with comprehensive recipe schema support
• Tasty Recipes: Popular among food bloggers, includes schema and nutrition
• Recipe Card Blocks: Gutenberg-based plugin with built-in schema
• Yoast SEO: The Schema Pro add-on supports recipe markup

These plugins create a recipe card interface where you enter ingredients and steps, and the schema is generated automatically.

Option 2: Manual Theme Implementation

For custom control, add schema via your theme’s functions.php:

<?php
/**
 * Output recipe schema for posts with recipe content.
 *
 * @return void
 */
function output_recipe_schema() {
    if ( ! is_singular( 'post' ) ) {
        return;
    }
    // Check if this post has recipe data (using ACF or custom fields).
    $recipe_name = get_field( 'recipe_name' );
    if ( empty( $recipe_name ) ) {
        return;
    }
    $schema = array(
        '@context'          => 'https://schema.org',
        '@type'             => 'Recipe',
        'name'              => esc_html( $recipe_name ),
        'image'             => get_field( 'recipe_image' ),
        'author'            => array(
            '@type' => 'Person',
            'name'  => get_the_author(),
        ),
        'datePublished'     => get_the_date( 'c' ),
        'description'       => get_field( 'recipe_description' ),
        'prepTime'          => 'PT' . get_field( 'prep_minutes' ) . 'M',
        'cookTime'          => 'PT' . get_field( 'cook_minutes' ) . 'M',
        'recipeYield'       => get_field( 'recipe_yield' ),
        'recipeIngredient'  => get_field( 'ingredients' ), // ACF repeater.
        'recipeInstructions'=> array(),
    );
    // Build instructions array.
    $steps = get_field( 'instructions' );
    if ( $steps ) {
        foreach ( $steps as $step ) {
            $schema['recipeInstructions'][] = array(
                '@type' => 'HowToStep',
                'text'  => esc_html( $step['step_text'] ),
            );
        }
    }
    echo '<script type="application/ld+json">';
    echo wp_json_encode( $schema, JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT );
    echo '</script>';
}
add_action( 'wp_head', 'output_recipe_schema' );
?>

Validation and Testing

Validation and Testing ensures your recipe schema is correctly implemented and eligible for rich results. By using tools like Google Rich Results Test and Schema Validator, you can identify errors, fix warnings, and confirm that your structured data matches visible content improving your chances of appearing in enhanced search results.

How to Test Recipe Structured Data

Always validate your recipe schema before publishing. Use these tools:

Google Rich Results Test: The most important tool. It shows exactly what Google sees and whether your recipe qualifies for rich results. Available at search.google.com/test/rich-results.

Schema Markup Validator: Use a schema markup validator to validate against the full Schema.org vocabulary

Fixing Common Errors and Warnings

Common recipe schema issues and solutions:

If issues persist, check why your schema markup isn’t showing rich results and how to fix it.

Monitoring Performance

After implementing recipe schema, monitor its performance:

1. Go to Google Search Console > Enhancements > Recipes
2. Review valid items, items with warnings, and items with errors
3. Click into issues to see affected URLs
4. Fix errors and use “Validate Fix” to confirm
5. Monitor impression and click data for recipe pages

Common Mistakes to Avoid

Avoid errors like incomplete recipes, mismatched schema and content, fake ratings, or over-optimization. These issues can prevent your recipe from appearing in rich results and may even lead to search penalties. Keep your structured data accurate, complete, and aligned with visible content.

Marking Up Incomplete Recipes

Don’t add recipe schema to pages with incomplete recipes:

• Recipe intros without actual recipes (“Here’s why I love cookies…”)
• Recipe roundups (“10 Cookie Recipes”—use ItemList instead)
• Recipes with missing ingredients or instructions
• Video-only content without written recipe

Adding Fake Ratings

This is a serious violation. Never:

• Add aggregateRating without an actual rating system
• Inflate ratings beyond what users actually submitted
• Generate fake reviews to boost rating counts
• Copy ratings from other sites

If you don’t have a rating system, simply don’t include the aggregateRating property. Your recipe can still qualify for rich results without ratings.

Missing Required Properties

At minimum, your recipe schema needs:

• name – What’s the recipe called?
• image – What does the finished dish look like?

Without these, you won’t qualify for recipe rich results. For best results, also include ingredients, instructions, and times.

Structured Data Mismatch

Your schema must match what’s visible on the page. Common mismatches:

• Different recipe names: Schema says “Chocolate Chip Cookies” but page title says “The Best Cookies Ever”
• Time discrepancies: Schema shows 30 minutes, but recipe card shows 45 minutes
• Invisible nutrition: Schema includes calories, but page doesn’t display nutrition info

Over-Optimization

Don’t stuff your schema with unnecessary data:

• Adding every possible Schema.org property regardless of relevance
• Keyword stuffing in description or name fields
• Adding schema to non-recipe pages hoping for rich results

AI Search and Future Optimization

How Recipe Schema Appears in AI-Powered Results

As Google integrates more AI features like AI overviews, recipe structured data becomes increasingly valuable. AI systems use your schema to:

• Summarize recipes in conversational responses
• Answer specific questions (“How long do I bake the cookies?”)
• Compare recipes based on time, ingredients, or nutrition
• Generate meal planning suggestions

Well-structured recipe data positions your content to be featured in AI-generated summaries and recommendations.

Voice Search Compatibility

Google Assistant and other voice assistants use recipe schema to guide users through cooking:

• Ingredient lists: Voice assistants can read your ingredient list for hands-free shopping lists
• Step-by-step instructions: Each HowToStep becomes a voice prompt during cooking
• Times and yields: Users can ask “How long does this take?” and get instant answers

For voice optimization, make each instruction step clear and complete. Avoid steps that require visual context (“until it looks like the photo”).

Entity Clarity

Help search engines understand your recipe as a distinct entity:

• Use specific recipe names: “Classic Chocolate Chip Cookies” is better than “My Cookies”
• Include cuisine type: recipeCuisine helps categorize your recipe
• Add recipe category: recipeCategory (“Dessert”, “Main Course”) aids classification

Best Practices for Long-Term SEO Success

Focus on creating high-quality, original content, keep your pages updated, follow structured data guidelines, and regularly monitor performance. Consistency, accuracy, and user-focused content are key to maintaining strong rankings and long-term visibility in both search and AI-driven results.

Keeping Structured Data Updated

Recipe schema isn’t a one-time task. Maintain it by:

• Updating schema when you revise recipes (new ingredients, different times)
• Removing rating data if you disable reviews
• Adjusting nutrition info when you reformulate recipes
• Checking for broken image URLs periodically

Ensuring Content Accuracy

Your recipe content should be genuinely helpful:

• Test your recipes before publishing—accuracy builds trust
• Include helpful tips and variations
• Respond to user questions and update recipes based on feedback
• Clearly note any substitutions or modifications

Using High-Quality Images

Recipe images significantly impact both rich results and user engagement:

• Use original photography, not stock photos
• Show the finished dish clearly and appetizingly
• Provide multiple aspect ratios (1:1, 4:3, 16:9)
• Ensure images are at least 1200px wide
• Use descriptive alt text for accessibility

Mobile-First Optimization

Most recipe searches happen on mobile devices. Ensure your recipe pages:

• Load quickly on mobile connections
• Display recipe content without excessive scrolling
• Use legible font sizes for ingredient lists
• Include a “Jump to Recipe” button to skip blog content
• Test schema validation on mobile page versions

Frequently Asked Questions

This FAQ section is optimized for featured snippets and can be marked up with FAQ schema markup.

Recipe Schema Implementation Checklist

Use this checklist for every recipe page you publish.

Required Elements:

• Recipe name matches visible page title
• At least one high-quality image (1200px+ wide)
• @context and @type declarations included
• JSON-LD placed in <head> or end of <body>

Recommended Elements:

• Author information (Person or Organization)
• Prep time, cook time, and/or total time (ISO 8601 format)
• Complete ingredient list (array format)
• Step-by-step instructions (HowToStep objects)
• Recipe yield/servings
• Recipe category and cuisine type
• Nutrition information (if calculated)

Validation Steps:

• Test with Google Rich Results Test
• Validate with Schema.org Validator
• Verify all schema content is visible on page
• Check for errors AND warnings

Ongoing Maintenance:

• Monitor Search Console Recipes enhancement report
• Update schema when recipes are modified
• Check image URLs remain valid
• Review and respond to user ratings/comments

By implementing Recipe Schema correctly, you can improve your search visibility, attract more clicks, and enhance user experience across both traditional and AI-powered search results.