JSON-LD for Recipes: The Complete Guide

1. JSON-LD in Plain English

JSON-LD stands for JavaScript Object Notation for Linked Data. That's a mouthful, so let's break it down: it's a standardized way to describe things on the internet so that computers can understand them. For recipes, it means there's an agreed-upon format for saying "this is a recipe, these are the ingredients, this is how long it takes to cook, and here are the steps."

When a food blog includes JSON-LD on their recipe page, they're essentially writing a machine-readable version of the recipe alongside the human-readable one. You can't see it on the page (it's embedded in the HTML source code), but search engines, recipe apps, and tools like Flour Power can read it and extract the full recipe with perfect structure.

What Does Recipe JSON-LD Look Like?

Here's an example of a well-structured recipe in JSON-LD format:

{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "name": "Classic Banana Bread",
  "description": "A moist, tender banana bread with a golden crust. Uses overripe bananas for maximum flavor.",
  "author": {
    "@type": "Person",
    "name": "Jane Cook"
  },
  "datePublished": "2025-09-15",
  "image": [
    "https://example.com/banana-bread-1x1.jpg",
    "https://example.com/banana-bread-4x3.jpg",
    "https://example.com/banana-bread-16x9.jpg"
  ],
  "prepTime": "PT15M",
  "cookTime": "PT60M",
  "totalTime": "PT1H15M",
  "recipeYield": "1 loaf (10 slices)",
  "recipeCategory": "Dessert",
  "recipeCuisine": "American",
  "keywords": "banana bread, quick bread, baking, ripe bananas",
  "recipeIngredient": [
    "3 ripe bananas",
    "1/3 cup melted butter",
    "3/4 cup sugar",
    "1 egg, beaten",
    "1 teaspoon vanilla extract",
    "1 teaspoon baking soda",
    "Pinch of salt",
    "1 1/2 cups all-purpose flour"
  ],
  "recipeInstructions": [
    {
      "@type": "HowToStep",
      "text": "Preheat oven to 350°F (175°C). Grease a 9x5 inch loaf pan."
    },
    {
      "@type": "HowToStep",
      "text": "Mash bananas in a large mixing bowl until smooth."
    },
    {
      "@type": "HowToStep",
      "text": "Stir in melted butter, sugar, egg, and vanilla extract."
    },
    {
      "@type": "HowToStep",
      "text": "Mix in baking soda and salt. Fold in flour until just combined."
    },
    {
      "@type": "HowToStep",
      "text": "Pour batter into prepared pan. Bake for 60 minutes or until a toothpick inserted in the center comes out clean."
    }
  ],
  "nutrition": {
    "@type": "NutritionInformation",
    "calories": "196 calories",
    "fatContent": "6 g",
    "carbohydrateContent": "33 g",
    "proteinContent": "3 g"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "ratingCount": "237"
  }
}

Every field has a specific meaning defined by Schema.org, the vocabulary maintained by Google, Microsoft, Yahoo, and Yandex. This means any tool that speaks Schema.org can read any recipe written in this format, no matter who created it.

This is a simplified version. Below we cover the full spec and real-world variations.

Why Should Home Cooks Care?

Better Recipe Imports

When you import a recipe from a URL into Flour Power (or any modern recipe app), the app looks for JSON-LD first. If it finds it, the import is clean and structured: ingredients, steps, times, and photos all land in the right fields. Without JSON-LD, the app has to guess where the recipe content starts and the blog post ends, which often leads to messy imports with ads and life stories mixed into your recipe.

Data Portability

Recipes stored as JSON-LD can be moved between apps without losing structure. If your recipe manager exports in JSON-LD format, any other app that supports the standard can import it perfectly. It's the difference between a universal file format (like PDF for documents) and a proprietary one that only works with one app.

Google Rich Results

If you share recipes publicly (like Flour Power's public recipe sharing feature), JSON-LD is what tells Google to show your recipe with a photo, star rating, cook time, and calorie count right in the search results. These "rich results" get significantly more clicks than plain blue links.

JSON-LD vs. Other Recipe Formats

2. The Complete Schema.org Recipe Spec

The Schema.org Recipe type defines dozens of properties. Google only requires a handful for rich results, but the more you include, the better your recipes travel between systems. Here's the full breakdown.

Required Properties (for Google Rich Results)

Without these four properties, Google will not generate a rich result card for your recipe.

Recommended Properties

These properties significantly improve how your recipe appears in search results and how well it imports into recipe apps.

Optional Properties

The suitableForDiet property accepts the following Schema.org RestrictedDiet values:

• https://schema.org/DiabeticDiet
• https://schema.org/GlutenFreeDiet
• https://schema.org/HalalDiet
• https://schema.org/HinduDiet
• https://schema.org/KosherDiet
• https://schema.org/LowCalorieDiet
• https://schema.org/LowFatDiet
• https://schema.org/LowLactoseDiet
• https://schema.org/LowSaltDiet
• https://schema.org/VeganDiet
• https://schema.org/VegetarianDiet

HowToStep vs. HowToSection

There are two ways to structure recipe instructions in JSON-LD. The flat pattern uses a simple array of steps:

"recipeInstructions": [
  {
    "@type": "HowToStep",
    "text": "Preheat oven to 350°F."
  },
  {
    "@type": "HowToStep",
    "text": "Cream butter and sugar until fluffy."
  },
  {
    "@type": "HowToStep",
    "text": "Add eggs one at a time, beating well after each addition."
  }
]

For complex recipes with distinct phases, you can group steps into sections using HowToSection:

"recipeInstructions": [
  {
    "@type": "HowToSection",
    "name": "For the Crust",
    "itemListElement": [
      {
        "@type": "HowToStep",
        "text": "Combine graham cracker crumbs and melted butter."
      },
      {
        "@type": "HowToStep",
        "text": "Press into the bottom of a 9-inch springform pan."
      },
      {
        "@type": "HowToStep",
        "text": "Bake at 325°F for 10 minutes. Let cool."
      }
    ]
  },
  {
    "@type": "HowToSection",
    "name": "For the Filling",
    "itemListElement": [
      {
        "@type": "HowToStep",
        "text": "Beat cream cheese until smooth."
      },
      {
        "@type": "HowToStep",
        "text": "Add sugar, eggs, and vanilla. Mix until just combined."
      },
      {
        "@type": "HowToStep",
        "text": "Pour over crust and bake at 325°F for 55 minutes."
      }
    ]
  }
]

Most recipe apps handle flat HowToStep arrays well. Support for HowToSection groupings is less consistent, so many food blogs stick with the flat pattern even when sections would be more logical.

ISO 8601 Duration Quick Reference

Recipe times in JSON-LD use the ISO 8601 duration format. The P prefix stands for "period" and T separates date components from time components.

3. Real-World JSON-LD

The Schema.org spec is one thing. What food blogs actually ship in their markup is another. We surveyed popular recipe sites to see which fields they include in their JSON-LD. The results are revealing.

Field Coverage Across Popular Sites

What the Data Tells Us

Almost nobody uses suitableForDiet. Despite Schema.org defining eleven diet types, not a single major food blog we surveyed includes this field. The information often exists in the blog post text ("this recipe is gluten-free!") but never makes it into the structured data. This is a missed opportunity for both search engines and recipe apps.

Image array compliance varies wildly. Google recommends three images in different aspect ratios (1:1, 4:3, 16:9). Some sites ship all three. Others include a single image URL as a string rather than an array. Recipe apps handle both patterns, but the three-image approach gives Google more options for displaying your recipe in different contexts.

Video is rare despite Google prioritizing it. Google gives a ranking boost to recipes with structured video data, yet only the largest publishers (Serious Eats, Allrecipes) consistently include VideoObject markup. For smaller blogs, producing recipe videos is a significant investment that most skip.

Instructions format varies. All the major sites now use proper HowToStep objects, which is a big improvement from a few years ago when many shipped instructions as a single block of HTML text. WordPress recipe plugins (like WP Recipe Maker and Tasty Recipes) deserve much of the credit for this standardization.

Annotated Example: Full-Featured JSON-LD

Here is a complete, annotated JSON-LD block showing every recommended field. This is the level of detail that produces the best results in Google and the cleanest imports in recipe apps.

{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "name": "Classic Banana Bread",
  "description": "A moist, tender banana bread with a golden crust. The secret is using very ripe bananas and not overmixing the batter.",
  "author": {
    "@type": "Person",
    "name": "Jane Cook",
    "url": "https://example.com/about"
  },
  "datePublished": "2025-09-15",
  "image": [
    "https://example.com/images/banana-bread-1x1.jpg",
    "https://example.com/images/banana-bread-4x3.jpg",
    "https://example.com/images/banana-bread-16x9.jpg"
  ],
  "prepTime": "PT15M",
  "cookTime": "PT60M",
  "totalTime": "PT1H15M",
  "recipeYield": "1 loaf (10 slices)",
  "recipeCategory": "Dessert",
  "recipeCuisine": "American",
  "cookingMethod": "Baking",
  "keywords": "banana bread, quick bread, baking, ripe bananas, breakfast",
  "recipeIngredient": [
    "3 very ripe bananas, mashed",
    "1/3 cup (75g) unsalted butter, melted",
    "3/4 cup (150g) granulated sugar",
    "1 large egg, beaten",
    "1 teaspoon pure vanilla extract",
    "1 teaspoon baking soda",
    "1/4 teaspoon fine sea salt",
    "1 1/2 cups (190g) all-purpose flour"
  ],
  "recipeInstructions": [
    {
      "@type": "HowToStep",
      "name": "Prepare pan",
      "text": "Preheat oven to 350°F (175°C). Grease a 9x5 inch loaf pan with butter or cooking spray."
    },
    {
      "@type": "HowToStep",
      "name": "Mash bananas",
      "text": "In a large bowl, mash the bananas with a fork until mostly smooth with a few small chunks remaining."
    },
    {
      "@type": "HowToStep",
      "name": "Mix wet ingredients",
      "text": "Stir in melted butter, sugar, beaten egg, and vanilla extract until well combined."
    },
    {
      "@type": "HowToStep",
      "name": "Add dry ingredients",
      "text": "Sprinkle baking soda and salt over the mixture and stir. Add flour and fold gently until just combined. Do not overmix."
    },
    {
      "@type": "HowToStep",
      "name": "Bake",
      "text": "Pour batter into prepared pan. Bake for 55-65 minutes, until a toothpick inserted in the center comes out clean. Let cool in pan for 10 minutes, then transfer to a wire rack."
    }
  ],
  "nutrition": {
    "@type": "NutritionInformation",
    "servingSize": "1 slice",
    "calories": "196 calories",
    "fatContent": "6 g",
    "saturatedFatContent": "3.5 g",
    "carbohydrateContent": "33 g",
    "sugarContent": "19 g",
    "fiberContent": "1 g",
    "proteinContent": "3 g",
    "sodiumContent": "200 mg"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "ratingCount": "237",
    "bestRating": "5",
    "worstRating": "1"
  },
  "tool": [
    "9x5 inch loaf pan",
    "Large mixing bowl",
    "Wire cooling rack"
  ]
}

4. The Same Recipe in Every Format

To understand what you gain and lose with each format, here is the same Classic Banana Bread recipe represented six different ways.

1. Schema.org JSON-LD

The gold standard. Every field is explicitly typed and machine-readable.

{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "name": "Classic Banana Bread",
  "description": "Moist banana bread with a golden crust.",
  "prepTime": "PT15M",
  "cookTime": "PT60M",
  "totalTime": "PT1H15M",
  "recipeYield": "1 loaf (10 slices)",
  "recipeCategory": "Dessert",
  "recipeCuisine": "American",
  "recipeIngredient": [
    "3 ripe bananas",
    "1/3 cup melted butter",
    "3/4 cup sugar",
    "1 egg, beaten",
    "1 tsp vanilla extract",
    "1 tsp baking soda",
    "Pinch of salt",
    "1 1/2 cups all-purpose flour"
  ],
  "recipeInstructions": [
    { "@type": "HowToStep", "text": "Preheat oven to 350°F. Grease a 9x5 loaf pan." },
    { "@type": "HowToStep", "text": "Mash bananas. Stir in butter, sugar, egg, vanilla." },
    { "@type": "HowToStep", "text": "Mix in baking soda, salt, and flour until just combined." },
    { "@type": "HowToStep", "text": "Pour into pan. Bake 55-65 min until toothpick comes out clean." }
  ]
}

2. Paprika Export (.paprikarecipes)

Paprika uses a proprietary JSON format inside a gzipped archive. The structure is close to Schema.org but diverges in key ways.

{
  "uid": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "name": "Classic Banana Bread",
  "description": "Moist banana bread with a golden crust.",
  "prep_time": "15 min",
  "cook_time": "1 hr",
  "total_time": "1 hr 15 min",
  "servings": "1 loaf (10 slices)",
  "categories": ["Dessert"],
  "ingredients": "3 ripe bananas\n1/3 cup melted butter\n3/4 cup sugar\n1 egg, beaten\n1 tsp vanilla extract\n1 tsp baking soda\nPinch of salt\n1 1/2 cups all-purpose flour",
  "directions": "Preheat oven to 350°F. Grease a 9x5 loaf pan.\n\nMash bananas. Stir in butter, sugar, egg, vanilla.\n\nMix in baking soda, salt, and flour until just combined.\n\nPour into pan. Bake 55-65 min until toothpick comes out clean.",
  "source": "example.com",
  "source_url": "https://example.com/banana-bread",
  "hash": "abc123def456",
  "photo_data": "(base64-encoded image)"
}

What's lost: Ingredients become a single newline-separated string instead of a structured array. Cooking times lose their ISO 8601 format. No nutrition data, no ratings, no cuisine type. The format is only readable by Paprika itself. Full Paprika comparison.

3. CopyMeThat HTML Export

CopyMeThat exports recipes as HTML files inside a ZIP archive. The structure relies on CSS classes and HTML elements.

<div class="recipe">
  <h1>Classic Banana Bread</h1>
  <p class="description">Moist banana bread with a golden crust.</p>
  <div class="times">
    <span>Prep: 15 min</span>
    <span>Cook: 1 hr</span>
  </div>
  <div class="servings">Servings: 1 loaf (10 slices)</div>
  <h2>Ingredients</h2>
  <ul>
    <li>3 ripe bananas</li>
    <li>1/3 cup melted butter</li>
    <li>3/4 cup sugar</li>
    <li>1 egg, beaten</li>
    <li>1 tsp vanilla extract</li>
    <li>1 tsp baking soda</li>
    <li>Pinch of salt</li>
    <li>1 1/2 cups all-purpose flour</li>
  </ul>
  <h2>Directions</h2>
  <ol>
    <li>Preheat oven to 350°F. Grease a 9x5 loaf pan.</li>
    <li>Mash bananas. Stir in butter, sugar, egg, vanilla.</li>
    <li>Mix in baking soda, salt, and flour until just combined.</li>
    <li>Pour into pan. Bake 55-65 min until toothpick comes out clean.</li>
  </ol>
</div>

What's lost: No standardized schema. Times are human-readable strings, not parseable durations. No nutrition, no ratings, no cuisine metadata. Any app importing this has to parse custom HTML. Full CopyMeThat comparison.

4. PDF

Looks beautiful. Completely opaque to any app trying to import it. A PDF is a visual document, not structured data. The recipe title, ingredients, and steps are all just positioned text and images on a rendered page. There is no way for software to reliably distinguish "1/3 cup melted butter" as an ingredient versus a photo caption or a paragraph of text.

Some recipe apps attempt OCR (optical character recognition) to extract text from PDFs, but the results are inconsistent. Ingredient quantities, fractions, and special characters (like the degree symbol in "350°F") are frequent sources of errors.

5. Screenshot or Photo

The most common "format" for saving recipes from social media. Someone posts a recipe on Instagram or TikTok, and you screenshot it. The recipe now lives as pixels on your camera roll.

There is no structure at all. No app can reliably extract ingredients, quantities, or steps from a photo of text. AI-powered tools are getting better at this, but they still struggle with handwritten recipes, unusual fonts, and photos taken at angles. Every screenshot is a dead end for data portability.

6. Plain Text

Classic Banana Bread

Prep: 15 min | Cook: 1 hr | Servings: 1 loaf (10 slices)

Ingredients:
3 ripe bananas
1/3 cup melted butter
3/4 cup sugar
1 egg, beaten
1 tsp vanilla extract
1 tsp baking soda
Pinch of salt
1 1/2 cups all-purpose flour

Directions:
1. Preheat oven to 350°F. Grease a 9x5 loaf pan.
2. Mash bananas. Stir in butter, sugar, egg, vanilla.
3. Mix in baking soda, salt, and flour until just combined.
4. Pour into pan. Bake 55-65 min until toothpick comes out clean.

Readable by humans, but there is no reliable way for software to parse this. Where does the ingredient list end and the directions begin? Is "Pinch of salt" one ingredient or two? Does "1 1/2 cups" mean one and a half cups or one cup and then two cups? Every plain-text recipe requires custom parsing logic that breaks on the next recipe.

5. Which Recipe Apps Support JSON-LD?

Almost every modern recipe app can read JSON-LD from a URL. Far fewer can write it back. This table shows the current state of JSON-LD support across popular recipe managers.

The asymmetry is the problem. Almost every app can read JSON-LD from the web, which means importing recipes is easy. But very few apps write JSON-LD back when you export. This creates a one-way door: recipes flow in but can't flow out in the same structured format. That's the core lock-in mechanism, even in apps that technically offer "export."

Self-hosted apps lead on export. Mealie and Tandoor, both self-hosted and open-source, tend to have the best export support. Their communities prioritize data ownership, and their codebases are open for contributors to add export formats. If you're technically inclined, these are strong options.

Flour Power and MoveMyRecipes together cover the full pipeline. Flour Power imports JSON-LD, stores recipes in a structured format, exports Schema.org-compliant JSON, and embeds JSON-LD in shared recipes. For migrations from other apps, MoveMyRecipes.com converts proprietary formats (Paprika, CopyMeThat, and others) into JSON-LD that Flour Power (or any standards-compliant app) can import.

6. Interactive Inspector

Paste any recipe URL below to see its JSON-LD markup, or drop in raw JSON-LD to validate it against the Schema.org Recipe spec.