Google Recipe Schema Update: How Image SEO Impacts Rankings

Last Updated: April 11, 2026

---

• Recipe schema images help you win rich results, carousels, Discover, and AI Overviews, but they do not fully control the thumbnail in regular search results.
• Your real power comes from how you handle the hero image in HTML: placement, size, speed, and clarity.
• Google now cares a lot about performance signals like LCP and CLS, and your main recipe image is right in the middle of those.
• Original, sharp, on-topic photos (and video) tend to earn more clicks, more trust, and more visibility across search features.

Google’s recipe schema rules around images are clearer today, but the short version is simple: schema helps Google understand and qualify your images for rich features, while your HTML, performance, and content decide what actually shows and how often it surfaces.

If you treat your hero image as a ranking asset, not a decoration, you put yourself in a much better position across regular results, carousels, Discover, and even AI Overviews.

How Google Handles Recipe Images Today

Google’s recipe docs now spell out that the image field in Recipe structured data is required for rich results and carousels, but it does not give you a hard guarantee over the thumbnail in every type of search result.

What really happens is Google looks at a mix of signals: the hero image in your HTML, the image in your schema, your image sitemap, and how users respond to that result across different surfaces.

Recipe schema tells Google which image is eligible for rich results, while your page structure and performance heavily influence what actually shows.

The old idea of “10 blue links” is gone; now you have grids, cards, visual blocks, carousels, and AI sections that all reuse your images in slightly different ways.

Rich Results vs Standard Cards vs Visual Blocks

It helps if you split search results into a few buckets, because images behave differently in each one.

• Recipe rich results: Classic recipe cards with a thumbnail, ratings, cook time, and sometimes calories, driven strongly by Recipe schema.
• Standard result cards: A regular web result with a title, URL, description, and a small thumbnail pulled from visible page images, not directly from schema.
• Recipe carousels and host carousels: Horizontally scrollable cards that heavily depend on good schema and a strong hero image.
• Visual / grid results and “From the web” blocks: Image-forward modules where Google mixes image search logic with standard search ranking.

In practice, Google likes to reuse the same strong primary image across all of these if it trusts that image and if it loads fast enough.

That is why I usually tell food publishers to pick one obvious hero image per recipe page and make it very hard for Google to miss it.

What Google Wants From Recipe Schema Images Right Now

Google’s current Recipe documentation is stricter than it used to be, especially around image fields.

If you ignore these basics, you limit yourself to plain results while your competitors show up in rich cards.

Current Recipe Image Requirements And Recommendations

The exact numbers can change, but the general pattern from Google stays pretty stable.

• Use the image property and treat it as required if you care about rich results.
• Provide images that are at least 1200 pixels wide.
• Keep a standard horizontal aspect ratio, often close to 16:9, that works well in cards.
• Use URLs that are crawlable, indexable, and not blocked by robots.txt.
• Serve high quality, sharp images; avoid heavy compression or tiny dimensions.

Google has also surfaced fields like thumbnailUrl, contentUrl, and inLanguage more often in docs, especially when recipes tie into video or multiple images.

You do not have to use every optional field, but when you have the data, giving it to Google rarely hurts.

For recipes, treat the schema image as the official hero: same image as your main on-page photo, same URL in your sitemap, and high enough resolution for Discover cards.

JSON-LD Example With Image Done Correctly

Here is a simplified Recipe JSON-LD block that lines up image signals cleanly.

{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "name": "Classic Apple Pie",
  "image": [
    "https://www.example.com/images/apple-pie/apple-pie-hero-1200.jpg"
  ],
  "thumbnailUrl": "https://www.example.com/images/apple-pie/apple-pie-thumb-600.jpg",
  "author": {
    "@type": "Person",
    "name": "Alex Baker"
  },
  "inLanguage": "en",
  "description": "Homemade apple pie with flaky crust and cinnamon filling.",
  "prepTime": "PT25M",
  "cookTime": "PT50M",
  "totalTime": "PT1H15M",
  "recipeYield": "8 servings",
  "recipeCategory": "Dessert",
  "recipeCuisine": "American",
  "nutrition": {
    "@type": "NutritionInformation",
    "calories": "380 calories"
  },
  "recipeIngredient": [
    "2 1/2 cups all-purpose flour",
    "1 cup unsalted butter",
    "6 cups sliced apples",
    "3/4 cup sugar",
    "2 tsp cinnamon"
  ],
  "recipeInstructions": [
    {
      "@type": "HowToStep",
      "text": "Prepare the pie dough and chill.",
      "image": "https://www.example.com/images/apple-pie/step1-dough-800.jpg"
    },
    {
      "@type": "HowToStep",
      "text": "Fill crust with apples and bake.",
      "image": "https://www.example.com/images/apple-pie/step2-filling-800.jpg"
    }
  ]
}

Notice how the main hero image appears in image, while the step photos sit inside individual HowToStep entries.

That pairing is what makes you eligible for both recipe cards and step-by-step formats on some devices.

Where Schema Image Actually Matters

Schema images are critical for some surfaces and almost irrelevant for others.

Element	Affects	Key image expectations
Recipe image in JSON-LD	Recipe rich cards, carousels, Discover, AI Overviews eligibility	1200px+, clear dish, matches hero image on page
HTML hero <img> or <picture>	Standard result thumbnail, LCP, user engagement	Above the fold, fetchpriority high, not lazy loaded
Image sitemap entry	Faster discovery in Search & Images	Accurate URLs, titles, captions
Open Graph / Twitter image	Social, Discover cards, messaging previews	Matches hero, 1200×630 or similar, not blocked
Step images in HowToStep	Step-by-step rich formats, smart displays	Vertical or square, clear action or step state

If you only wire up schema but your hero image is hidden, tiny, or slow in HTML, you get half the benefit at best.

That is where many recipe sites fall short: good schema, bad presentation.

HTML Image SEO: Getting The Hero Image Right

Schema is not enough; Google still has to see a real image element in the HTML that looks like the main attraction.

Think of your hero photo as both your thumbnail source and your main performance object.

Placement, Markup, And Relevance

Google is more likely to choose an image that is visible, prominent, and close to your page heading.

• Place the hero image near the top of the recipe page, close to the recipe title.
• Put it in a simple <figure> with a <figcaption> where it makes sense.
• Use a descriptive file name like classic-apple-pie-hero.jpg instead of IMG_1234.jpg.
• Write natural alt text: “Slice of classic apple pie with golden crust.”
• Avoid hiding the hero image in tabs, accordions, or sliders.

<figure class="recipe-hero">
  <picture>
    <source srcset="/images/apple-pie/apple-pie-hero-1200.avif" type="image/avif">
    <source srcset="/images/apple-pie/apple-pie-hero-1200.webp" type="image/webp">
    <img
      src="/images/apple-pie/apple-pie-hero-1200.jpg"
      alt="Slice of classic apple pie with golden crust"
      width="1200"
      height="675"
      loading="eager"
      fetchpriority="high"
    >
  </picture>
  <figcaption>Classic apple pie with flaky crust and cinnamon filling.</figcaption>
</figure>

This setup tells Google, users, and browsers that this is the image that matters.

It also keeps your Core Web Vitals in better shape, which many sites still ignore.

Modern Lazy Loading And Core Web Vitals

Older advice often said “be careful with lazy loading” as if you should avoid it completely; that is not accurate anymore.

Native lazy loading is fine when you use it smartly.

• Never lazy load the above-the-fold hero recipe image.
• Use loading="lazy" for images below the fold like step photos and gallery shots.
• Add width and height (or CSS aspect-ratio) to reduce layout shifts.
• Avoid JavaScript scroll-event lazy loaders that hide images from Google if scripts fail.
• Use fetchpriority="high" on the hero image if it is usually your LCP element.

Most recipe pages have the hero dish photo as the LCP element, so loading it fast is not a nice-to-have, it is central to your performance.

When I see a recipe site with weak Core Web Vitals, nine times out of ten the hero images are bloated, not preloaded, or pushed down the page by ads.

That is not a “content” problem, it is a technical and layout problem.

Image Formats: AVIF, WEBP, And Fallbacks

The earlier version of this topic treated WebP as somewhat experimental; that is not the case anymore.

Today, you should assume support for modern formats and still keep a clean fallback.

• AVIF: Great compression and quality for photos, but can be slow to encode; use it where your tooling can handle it.
• WEBP: Very solid default modern format for the web, especially for food photos.
• JPG/JPEG: Still a valid fallback for legacy or edge cases.
• PNG: Use it only when you need transparency or sharp UI elements, not for big food photos.

The earlier code example with the <picture> element is the pattern I like for recipe heroes: AVIF, then WEBP, then JPG.

If you use a CDN or image service that serves the best format per device, that is fine too, as long as search can crawl the final image URLs.

Performance And Core Web Vitals Impact

Your images affect all three major Core Web Vitals, not just one.

• LCP (Largest Contentful Paint): Usually your hero photo; heavy files and slow servers here hurt your scores.
• CLS (Cumulative Layout Shift): Missing width/height on images and ads pushing content around are common causes.
• INP (Interaction to Next Paint): Overly complex JavaScript-driven sliders or galleries around images can slow interaction.

If your LCP is stubbornly high, look directly at:

• Hero image file size.
• Whether you preload or set fetchpriority on that image.
• Whether you delay key CSS that controls image layout.

People talk a lot about “great content,” but a slow page with a gorgeous photo still loses clicks to a fast page with a slightly less polished image.

How Recipe Images Show Up In AI Overviews, Discover, And Visual Search

Search is not just a list of links anymore; a lot of your traffic will come from AI Overviews, Discover, and visual features you cannot fully control.

You can, though, make your recipes a strong candidate when Google needs an image to feature.

How Recipe Images Appear In AI Overviews

Google’s AI Overviews and related generative features often show one or a few large images next to the generated text, and those images usually come from pages that already rank well and have clear hero photos.

You cannot “tag” an image for AI, but you can send strong hints.

• Keep one obvious hero image near the top of the recipe, near the title.
• Use consistent URLs across HTML, schema, and image sitemap.
• Make alt text descriptive, not stuffed with keywords.
• Ensure the hero image clearly shows the final dish, not just ingredients.
• Avoid using a step image as the first or most prominent photo if it looks confusing out of context.

AI Overviews tend to favor the cleanest, most relevant hero image from high-trust pages, so focus on one strong visual instead of cluttering the top with many small photos.

I have noticed that when a recipe page has multiple competing “main” images above the fold, AI features sometimes pick a less ideal one, like a half-prepped bowl or a close-up of a single ingredient.

So I would rather see one clear hero and move step shots lower.

Google Discover And Large Recipe Images

Discover is still one of the best traffic sources for food content, and it is very image heavy.

If your images do not meet basic quality and size thresholds, your recipes might never show there, even if the content is strong.

• Use large images that are at least 1200 pixels wide.
• Do not block large previews with max-image-preview:noimage or similar directives.
• Set Open Graph and Twitter card images to match the hero recipe image.
• Avoid noisy overlays, heavy watermarks, or big logos that distract from the food.
• Use high contrast and good lighting so the dish looks good on mobile cards.

Google has said many times that high quality, large images help Discover performance, and I do not see that changing.

You still need good titles and topics, but the image is doing a lot of the work.

Visual Search, Lens, And Step Images

Lens and visual search keep getting better at understanding what your food actually is, not just what the file is named.

If you mislabel images, or if the photo does not match the recipe, that gap is more obvious now.

• Align filenames and alt text with what the image really shows.
• Use step images for real steps, not random lifestyle shots.
• Try vertical or square crops for step images that might appear in Stories or smart displays.
• Avoid stock photos that show a completely different version of the dish.

I know it is tempting to grab a generic “nice looking” stock photo of pasta and call it a specific recipe, but visual systems will keep getting better at spotting those distortions.

That usually does not help long term.

Beyond Static Images: The Role Of Video In Recipe SEO

Right now, a lot of top recipe results feature both a hero image and a short video on the same page, with video included in Recipe schema.

If you ignore video completely, you leave some visibility on the table.

• Create short, focused recipe videos in the 60 to 120 second range.
• Embed the video above the fold, near the hero image and recipe title.
• Add the video property in your Recipe schema with proper fields.
• Use a static thumbnail that matches the hero image or at least the same dish.

"video": {
  "@type": "VideoObject",
  "name": "Classic Apple Pie Recipe Video",
  "description": "Step-by-step video for baking a classic apple pie.",
  "thumbnailUrl": [
    "https://www.example.com/images/apple-pie/apple-pie-video-thumb-1200.jpg"
  ],
  "uploadDate": "2024-09-01",
  "contentUrl": "https://www.example.com/videos/apple-pie.mp4",
  "embedUrl": "https://www.example.com/recipes/apple-pie#video"
}

Video is not just for YouTube; it can give you a video badge in search, extra carousels, and better engagement on the page.

People often scan the image, then tap the video, then scroll for the written instructions, so all three pieces should match each other.

Image SEO Systems: Sitemaps, CDNs, Accessibility, And Myths

Instead of fixing images one recipe at a time, it is smarter to build a system that keeps things consistent across the whole site.

That sounds boring, but it saves a lot of time later.

Image Sitemaps That Actually Help

An image sitemap is not magic, but it does help Google discover your recipe photos faster, especially on big sites.

The main mistake I see is partial information or missing key URLs.

<url>
  <loc>https://www.example.com/recipes/apple-pie</loc>
  <image:image>
    <image:loc>https://www.example.com/images/apple-pie/apple-pie-hero-1200.jpg</image:loc>
    <image:title>Classic Apple Pie</image:title>
    <image:caption>Classic apple pie with flaky crust and cinnamon filling.</image:caption>
  </image:image>
</url>

Keep the URLs consistent with your HTML and schema, and do not forget to submit the sitemap in Search Console.

If your images live on a CDN domain, make sure that domain is also crawlable and allowed.

CDNs, Folder Structure, And Caching

As your recipe library grows, image management can get messy fast.

I like to treat folder structure and naming as part of SEO, not just housekeeping.

• Group recipe images in clear folders, like /images/recipes/chicken-parmesan/.
• Use consistent naming: chicken-parmesan-hero.jpg, chicken-parmesan-step1.jpg.
• Serve images through a CDN that supports WEBP/AVIF conversion and responsive resizing.
• Set long cache lifetimes and use filename-based cache busting when you replace an image.
• Check robots.txt for both your main domain and CDN so nothing blocks images.

A messy image architecture might not kill your rankings, but it makes debugging and large-site improvements much harder than they need to be.

You do not need fancy tooling to get this right; clear folders, consistent names, and correct headers already put you ahead of many sites.

If you run a large recipe site, this is also where you can standardize on aspect ratios and target sizes.

Accessibility, Alt Text, And Semantics

Accessible image practices help real people first, and they also give search engines clearer signals.

When you do this right, your image descriptions stop sounding like keyword soup.

• Describe what is in the image in plain language: “Bowl of spaghetti carbonara with crispy pancetta.”
• Avoid stuffing terms like “best,” “easy,” “quick,” all in one alt text.
• Use alt="" for purely decorative images that do not add meaning.
• Wrap the main image with <figure> and an optional <figcaption> that adds context.

For step images, you can be a bit more detailed, because those are describing actions.

For example, “Mixing eggs and cheese in a glass bowl for carbonara sauce.”

Myths, FAQs, And Common Mistakes

A lot of advice about recipe images is either outdated or simply wrong, so let me push back on a few ideas here.

• “More images always boost rankings.” No. After one strong hero and relevant step photos, extra images usually have tiny impact and can slow the page.
• “Changing my hero image will destroy my rankings.” Not usually. Google may reprocess the page, but if the new image is clear, fast, and relevant, you are fine.
• “EXIF data is a big ranking factor.” There is no solid evidence this matters much for search; focus on what users see instead.
• “Schema image fully controls the thumbnail.” It helps, but HTML context and performance still carry a lot of weight.

If your recipe traffic is weak, fixing titles, structure, and speed will usually beat spending hours tweaking EXIF or micro-details in image metadata.

One area where I think many people go wrong is chasing minor tricks instead of fixing obvious problems like blurry photos or 3 MB hero images.

Those basics still matter more than clever hacks.

Original, Stock, And AI-Generated Images

The conversation around AI images is more complicated now than a simple “good” or “bad.”

For recipes, authenticity and trust still matter a lot.

• Original photography signals real experience and supports the “experience” and “trust” parts of E-E-A-T.
• Heavy reuse of the same stock photo across many sites can feel low quality and generic.
• Fully AI-generated food images for actual recipes can undermine trust if the result looks unrealistic.
• AI-assisted edits or background tweaks are usually fine if the dish itself is honest.

If you run a recipe site, I would keep AI images for concept pieces, collections, or abstract visuals, not the core “this is what you will cook” hero shots.

People want to see something that looks like what they will plate in their own kitchen.

Debugging, Step Images, And A Practical Workflow

When you change images or markup, Google does not always respond the way you expect, so you need a repeatable way to check what is going on.

Without that, you are guessing.

Debug Workflow For Recipe Images

When a client tells me “Google is using the wrong photo,” I go through the same steps almost every time.

1. Search the recipe by name and brand in Google and check the thumbnail in the main result.
2. Open Google Images for the same query and see which images show first from that domain.
3. Use Search Console’s URL Inspection, render the page, and look at the screenshot to confirm which image loads first and above the fold.
4. Run the page through the Rich Results Test to see if image fields in Recipe schema are valid.
5. Check the image sitemap entry for that URL and image to confirm the URL is indexed and consistent.

Usually, when Google picks a weird step image, one of two things is true: the hero is slow or hidden, or the step image looks more prominent or more relevant.

Fix that, then wait for recrawl; it is boring, but it works.

Adding Images To Individual Recipe Steps

Step images used to be mostly a UX nice-to-have, but now they help feed step-by-step search formats and smart displays.

They also keep users engaged longer on the page.

• Break instructions into clear HowToStep blocks in your schema.
• Add a relevant image to steps where the visual really helps, like tricky textures or assembly.
• Keep step image sizes smaller than the hero, to protect speed.
• Use descriptive, action-focused alt text like “Spreading tomato sauce over pizza dough.”

Do not feel forced to add images to every single step; focus on the ones that users actually need help with.

Too many step images above the fold can crowd out the hero and confuse both users and search.

Where To Focus Your Effort First

If this all feels like a lot, you probably do not need to implement every tactic at once.

Start with the pieces that change outcomes the most.

• Pick one strong, sharp hero image per recipe and put it near the title.
• Compress and convert that hero to WEBP or AVIF, and fix its width/height.
• Align that hero image across HTML, Recipe schema, and your image sitemap.
• Clean up alt text so it is descriptive and natural, not keyword-stuffed.
• Then add video and step images on your top recipes where they can move the needle.

If you only fix your hero images and how they load, you will often see a bigger lift than from any single change in your schema.

I know it is tempting to chase every new feature or tweak, but most recipe sites still win or lose on the basics: fast pages, clear photos, and honest, well-structured content.

Get those parts right, and your schema and technical tweaks finally have something strong to support.

Need a quick summary of this article? Choose your favorite AI tool below: