Schema.org: The Recipe Standard the Web Already Uses

The recipe app world has a standards problem. Paprika uses its own format. Cook'n uses its own format. CopyMeThat uses its own format. BigOven does not offer bulk export at all. Every app is an island, and moving between them requires translation.

But there is a standard for recipe data that is already in widespread use. You interact with it every time you search for a recipe on Google and see that neat card with ingredients, cook time, and a photo. It is called Schema.org, and specifically the Recipe type within it.

What Schema.org Actually Is

Schema.org is a collaborative vocabulary for structured data on the web. It was founded in 2011 by Google, Microsoft, Yahoo, and Yandex -- the four major search engines at the time -- to create a shared language for describing things on web pages. Not just recipes, but events, products, articles, people, organizations, and hundreds of other types.

The idea is straightforward: if a web page contains a recipe, there should be a standardized way to mark up that recipe so that any software -- a search engine, a recipe app, a screen reader, a migration tool -- can extract and understand the data.

Schema.org defines a Recipe type with specific properties. Here are the ones that matter most for recipe portability:

• name -- the recipe title
• description -- a summary of the dish
• recipeIngredient -- an array of ingredient strings
• recipeInstructions -- the cooking steps, ideally as an array of HowToStep objects
• prepTime and cookTime -- durations in ISO 8601 format (like PT30M for 30 minutes)
• totalTime -- the combined duration
• recipeYield -- servings or yield
• recipeCategory -- type of dish (appetizer, main course, dessert, etc.)
• recipeCuisine -- cuisine type
• nutrition -- a NutritionInformation object with calories, fat, protein, etc.
• image -- a photo of the dish
• author -- who created the recipe
• datePublished -- when it was published

This vocabulary is detailed enough to represent a complete recipe with all its metadata, and flexible enough to handle recipes from any cuisine or cooking style.

How It Appears on the Web

Schema.org data is typically embedded in web pages using JSON-LD (JavaScript Object Notation for Linked Data). If you view the source of almost any recipe page on a major food site, you will find a <script type="application/ld+json"> tag containing something like this:

{
  "@type": "Recipe",
  "name": "Classic Banana Bread",
  "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. Mash bananas in a mixing bowl."
    },
    {
      "@type": "HowToStep",
      "text": "Mix in melted butter, sugar, egg, and vanilla."
    }
  ],
  "prepTime": "PT10M",
  "cookTime": "PT60M",
  "recipeYield": "1 loaf"
}

This data is invisible to the casual reader -- it does not appear in the visible content of the page. It exists specifically for machines to read.

Why Google Made It Matter

Google uses Schema.org Recipe data to generate the rich recipe cards you see in search results -- the ones with the photo, star rating, cook time, and calorie count displayed right in the search page. These rich results get significantly more clicks than plain text listings, which means food bloggers and recipe sites have a strong financial incentive to include Schema.org markup on their pages.

The result is that Schema.org Recipe has become the de facto standard for recipe data on the web. Major food sites like AllRecipes, Food Network, Serious Eats, Bon Appetit, Epicurious, and BBC Good Food all include it. Most WordPress recipe plugins (WP Recipe Maker, Tasty Recipes, and others) automatically generate it. BigOven includes it on their public recipe pages.

This is important for recipe portability because it means structured, standardized recipe data already exists on millions of web pages. Any tool that can read JSON-LD can extract well-structured recipes from these sites.

The Gap Between Web and App

Here is the frustrating part: the web has a working recipe standard, but recipe apps mostly ignore it.

Paprika, Cook'n, CopyMeThat, and BigOven all store recipes internally in their own proprietary formats. When they export, they export in their own formats. None of them offer Schema.org JSON as an export option.

This is the core portability problem. The standard exists. The data model is rich enough. The specification is public and free to implement. But app developers choose proprietary formats because there is no business incentive to make leaving easy.

How Schema.org Powers Recipe Migration

This is where migration tools bridge the gap. A good converter can read proprietary formats and write Schema.org-compliant JSON, giving you recipes in the standard that the rest of the web already uses.

MoveMyRecipes does exactly this. When you upload a Paprika .paprikarecipes file, the parser extracts each recipe from the gzip-compressed JSON inside the archive and maps Paprika's fields to Schema.org properties. name maps to name. Paprika's ingredients string gets split into a recipeIngredient array. prep_time becomes prepTime in ISO 8601 format. Categories, ratings, notes, and source URLs all get mapped to their Schema.org equivalents. Fields that do not have a Schema.org match get preserved with an x- prefix so nothing is silently lost.

The same mapping happens for Cook'n, CopyMeThat, and every other supported input format. Regardless of where your recipes started, they come out as standardized, structured data.

Schema.org for URL Import

The Schema.org standard also powers the URL import feature on MoveMyRecipes. When you paste a recipe URL, the tool fetches the page and looks for JSON-LD data first. If it finds a Schema.org Recipe object, extraction is clean and reliable -- the data is already structured exactly the way we need it.

If the page does not have JSON-LD, the tool falls back to microdata (an older structured data format) and then to HTML scraping as a last resort. But JSON-LD produces the best results because the data is explicitly structured with labeled fields.

This is how MoveMyRecipes handles BigOven recipes. BigOven does not offer bulk export, but their individual recipe pages include JSON-LD. The URL import page can extract any BigOven recipe URL into a portable format -- one recipe at a time, but with clean, structured results.

What This Means for You

Schema.org is not a silver bullet. It does not solve the problem of apps refusing to export. It does not help with bulk extraction from services that lock down their data. And it does not preserve every possible piece of metadata -- personal notes, custom categories, and app-specific features fall outside the standard.

But it is the closest thing the recipe world has to a universal format. It is already on millions of web pages. It is rich enough to represent real recipes with ingredients, steps, times, nutrition, and photos. And it is an open standard that no single company controls.

When you export your recipes as Schema.org JSON, you are storing them in a format that Google, recipe apps, self-hosted tools, and future software you have not heard of yet can all understand. That is as close to future-proof as recipe data gets.