How JSON-LD Powers Recipe Sharing Across the Web

If you have ever searched for a recipe on Google and seen a neatly formatted card with the recipe title, a photo, cooking time, rating, and calorie count -- all right there in the search results before you click anything -- you have seen JSON-LD at work.

JSON-LD is the invisible scaffolding beneath most recipe websites. It is what makes recipes machine-readable, searchable, and extractable. And it is the technology that makes our URL import feature on MoveMyRecipes.com possible.

What JSON-LD Actually Is

JSON-LD stands for JavaScript Object Notation for Linked Data. In practical terms, it is a way to embed structured, machine-readable data inside a web page.

Every recipe website has two layers. There is the layer you see: the formatted text, photos, advertisements, and navigation. And there is a hidden layer -- a block of structured data tucked into the page's source code -- that describes the recipe in a format computers can parse.

That hidden layer looks something like this:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "name": "Classic Banana Bread",
  "recipeIngredient": [
    "3 ripe bananas",
    "1/3 cup melted butter",
    "3/4 cup sugar",
    "1 egg",
    "1 teaspoon vanilla",
    "1 teaspoon baking soda",
    "1 1/2 cups all-purpose flour"
  ],
  "recipeInstructions": [
    {"@type": "HowToStep", "text": "Preheat oven to 350 degrees F."},
    {"@type": "HowToStep", "text": "Mash the bananas in a mixing bowl."},
    {"@type": "HowToStep", "text": "Mix in melted butter, sugar, egg, and vanilla."},
    {"@type": "HowToStep", "text": "Stir in baking soda and flour until just combined."},
    {"@type": "HowToStep", "text": "Pour into a greased loaf pan and bake for 60 minutes."}
  ],
  "prepTime": "PT10M",
  "cookTime": "PT60M",
  "recipeYield": "1 loaf",
  "recipeCategory": "Dessert",
  "recipeCuisine": "American"
}
</script>

This block sits in the HTML source code. You never see it when browsing the page. But Google sees it. Pinterest sees it. And MoveMyRecipes sees it.

The Schema.org Standard

The vocabulary used inside JSON-LD comes from Schema.org, a collaborative project founded by Google, Microsoft, Yahoo, and Yandex in 2011. Schema.org defines standardized types and properties for describing things on the web: products, events, organizations, and -- importantly -- recipes.

The Schema.org Recipe type specifies fields for everything a recipe might contain:

• name -- the recipe title
• recipeIngredient -- an array of ingredient strings
• recipeInstructions -- step-by-step directions (as HowToStep items)
• prepTime and cookTime -- ISO 8601 duration format (like "PT30M" for 30 minutes)
• recipeYield -- servings
• recipeCategory -- meal type
• recipeCuisine -- regional cuisine
• nutrition -- calorie and macronutrient data
• aggregateRating -- user ratings
• author -- who wrote the recipe
• image -- a photo of the finished dish

When a recipe website includes this data as JSON-LD, it is essentially publishing a machine-readable version of the recipe alongside the human-readable one. The two versions contain the same information, but the JSON-LD version is structured for software to consume.

Why Google Cares About JSON-LD

Google uses JSON-LD structured data to generate rich results in search -- those enhanced listings that show recipe photos, cooking times, ratings, and calorie counts directly in the search results page.

For recipe website publishers, this is a powerful incentive. Pages with proper JSON-LD Recipe markup are eligible for prominent placement in Google's recipe search experience. Pages without it are not. This incentive has driven widespread adoption: the majority of major recipe websites now include JSON-LD structured data for their recipes.

That widespread adoption is good news for recipe portability. When most recipe sites publish structured data, it becomes possible to reliably extract recipes from across the web -- not by scraping messy HTML, but by reading clean, standardized JSON-LD.

How Our URL Import Works

When you paste a recipe URL into movemyrecipes.com/url, our system fetches the page and looks for JSON-LD structured data first. This is by far the most reliable extraction method because the data is already structured and standardized.

The extraction process works like this:

1. We fetch the HTML content of the URL you provide
2. We search for <script type="application/ld+json"> blocks in the page source
3. We parse the JSON and look for objects with "@type": "Recipe"
4. We handle common patterns: single recipes, arrays of items, and @graph structures (where the recipe is nested inside a larger structured data block)
5. We normalize the data -- cleaning up HTML entities, handling both string and array instruction formats, resolving image URLs, and standardizing author data

The result is a clean, complete recipe in our internal Schema.org format, ready to export to any of our seven output formats: JSON, CSV, Markdown, CookLang, PDF, HTML, or Open Recipe Format.

If a page does not have JSON-LD, we fall back to checking for microdata (another structured data format, less common but still used by some sites). This multi-strategy approach means our URL import works with the broadest possible range of recipe websites.

What This Means for You

The practical implication is straightforward: if a recipe website uses JSON-LD (and most major ones do), you can import that recipe into MoveMyRecipes and convert it to any format you want.

Found a recipe on a popular cooking site but want it as a Markdown file in your notes app? Paste the URL, export as Markdown.

Want to build a personal recipe collection from your favorite food blogs? Paste URLs one at a time and export each as JSON for a comprehensive archive.

Want to grab a recipe from BigOven and save it as a printable PDF? Our URL importer can extract recipes from BigOven and any other site that publishes JSON-LD or microdata.

This works because the recipe data is already there, published by the website in a standardized format. We are not guessing at which text on the page is an ingredient and which is an advertisement. We are reading the structured data the site's developers explicitly created.

The Portability Angle

JSON-LD is significant for recipe portability beyond just web extraction. When you export your recipes from MoveMyRecipes in JSON format, the output is Schema.org-compliant JSON-LD. This means:

Your exported recipes are in the same format Google uses. If you ever wanted to publish your recipes on a website with proper SEO, the JSON-LD is ready to embed.

Other tools can read your exports. Any application that understands Schema.org Recipe data can import your JSON files. You are not locked into a proprietary format.

The standard is maintained by an industry coalition. Schema.org is not controlled by any single company. It is a collaborative vocabulary maintained by representatives from multiple organizations. Standards maintained by coalitions tend to be more stable and long-lived than proprietary formats.

What JSON-LD Does Not Solve

JSON-LD is powerful, but it has limitations worth understanding.

Not every website uses it. Smaller food blogs, personal recipe pages, and older websites may not include JSON-LD markup. Our URL import has fallback strategies for some of these cases, but extraction quality varies when structured data is absent.

The data is only as good as the publisher. Some websites include incomplete JSON-LD -- missing ingredients, abbreviated instructions, or placeholder nutrition data. We extract what is there, but we cannot invent data that the publisher did not include.

It is a web standard, not a universal recipe standard. JSON-LD with Schema.org works well for web-published recipes. It is less natural for recipe data that has never been on a website -- handwritten recipes, recipes from desktop apps, recipes from proprietary databases. For those sources, MoveMyRecipes has dedicated parsers (Paprika, Cook'n, CopyMeThat, OCR, and plain text).

Ingredients are unstructured text. The Schema.org Recipe spec stores ingredients as plain text strings: "2 cups all-purpose flour". It does not separate amount, unit, and ingredient name into distinct fields. For applications that need that level of structure (shopping list generation, automated scaling), formats like Open Recipe Format or CookLang do a better job.

The Standard That Makes the Web Portable

JSON-LD is one of those technologies that works best when you do not think about it. Websites publish structured recipe data because Google rewards them for it. MoveMyRecipes reads that data because it is standardized and reliable. You benefit because recipes that were once trapped on websites -- viewable but not extractable -- become portable data you can store in any format you choose.

The next time you find a recipe on the web that you want to keep, you do not need to copy and paste it into a note. You do not need to take a screenshot. Just paste the URL into movemyrecipes.com/url and let JSON-LD do what it was built to do.