No Rich Results Detected in This URL: What It Means and How to Fix It
When Google's Rich Results Test finishes and says no rich results were detected, it means nothing on the page qualifies for one of the enhanced search features the test checks for. That can be a real problem, such as markup that is missing, broken, added too late by JavaScript or missing a required property. It can also be completely expected, because many valid schema.org types have no rich result at all, and Google has withdrawn some, such as HowTo, and limited others, such as FAQ. This guide shows you how to tell which case you are in, check the HTML Google actually rendered, choose a type that is supported, fill the required properties and retest.
What the result actually means
The Rich Results Test answers one narrow question: does this page contain structured data that makes it eligible for a rich result that Google currently supports? Depending on the version of the tool, a no answer is worded as No rich results detected in this URL or as the page not being eligible for rich results known by the test.
It does not say your structured data is wrong, and it does not say the page has none. It only says none of what it found qualifies. There are four possible reasons:
| Reason | How to tell | Is it a problem? |
|---|---|---|
| No markup in the rendered page | No application/ld+json in the tested HTML, and the Schema Markup Validator finds nothing | Yes, if you meant to have markup |
| Markup uses a type with no rich result | The Schema Markup Validator lists the types, but none are supported rich result types | Usually not; the markup still describes the page |
| A supported type that Google has limited | Valid FAQPage or HowTo markup on an ordinary site | No; this is expected |
| A supported type missing required properties or unreadable | The validator finds the type; the test shows errors or nothing | Yes; this is the one to fix |
Use both tools side by side. The Schema Markup Validator shows every type on the page, whether or not it has a rich result. The Rich Results Test shows only the types Google supports. The gap between their answers tells you which row you are in.
Which types produce rich results
Google supports rich results for a limited set of types, and the set changes over time. The most useful for small businesses are these, each with its own required properties:
| Type | Typical use | Required properties (main ones) |
|---|---|---|
| Product | Shop product pages | name, plus an offers block with price and priceCurrency for merchant listings |
| BreadcrumbList | Any page with a breadcrumb trail | itemListElement with position, name and item |
| Article | News and blog posts | None strictly required; headline, image, datePublished and author recommended |
| Event | Concerts, classes, talks | name, startDate, location |
| Recipe | Recipe pages | name, image |
| VideoObject | Pages with a main video | name, thumbnailUrl, uploadDate |
| LocalBusiness | Business details | name, address |
Types such as WebPage, WebSite, Service, Person and Place are valid and useful for describing a page, but on their own they do not produce a rich result. A page carrying only those will always show none detected, and that is fine.
Types Google has limited or removed
In 2023 Google restricted FAQ rich results to government and health websites and stopped showing HowTo rich results, and on 7 May 2026 it stopped showing FAQ rich results for all sites. Valid FAQPage or HowTo markup on other sites now shows no rich result. You do not need to remove it, because it still describes the page, but do not expect it to appear in search. Google has also retired several less common types since then, so check its current search gallery before building markup for a new feature. The details for FAQ are in FAQ rich result fixes.
How to check what Google actually saw
The Rich Results Test loads the page with Google's smartphone crawler by default, runs its JavaScript and tests the result. So the first question is whether your markup was in that result.
- In the test, choose View tested page.
- Open the HTML tab and search for
application/ld+json, or foritemscopeif you use microdata. - Open More info and check Page resources for files that could not be loaded, and the JavaScript console for errors.
If the markup is in your template but not in the tested HTML, it is either not printed for that page or added by a script that did not run for the crawler. Compare with the HTML your server sends before any JavaScript runs:
curl -sS -A "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Mobile Safari/537.36 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)" \
https://example.com/recipe/lemon-cake/ | grep -c "application/ld+json"A count of zero means the block is not in the server HTML at all. That is fine for Google if a script adds it reliably, but many other crawlers and AI systems do not run JavaScript, so markup in the server HTML is the safer choice.
Next, check the markup itself. Paste the URL into the Schema Markup Validator. If it reports a syntax error, fix that first; see structured data syntax errors. If it lists your type with no errors, compare the properties with the table above.
The key changes
Print the markup in the server HTML
Put the JSON-LD in the page template so it arrives with the HTML, rather than adding it later with a script, a tag manager or a consent tool. A minimal Recipe block that meets the required properties looks like this:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Recipe",
"name": "Lemon Drizzle Cake",
"image": ["https://example.com/images/lemon-drizzle-1x1.jpg",
"https://example.com/images/lemon-drizzle-4x3.jpg",
"https://example.com/images/lemon-drizzle-16x9.jpg"],
"author": {"@type": "Person", "name": "Sam Baker"},
"datePublished": "2026-10-01",
"recipeYield": "8 slices",
"totalTime": "PT1H",
"recipeIngredient": ["225 g self-raising flour", "225 g butter", "4 eggs", "2 lemons"],
"recipeInstructions": [
{"@type": "HowToStep", "text": "Heat the oven to 180°C and line a loaf tin."},
{"@type": "HowToStep", "text": "Beat the butter and sugar, then add the eggs and flour."}
]
}
</script>Only name and image are required for a Recipe, but the recommended properties such as ingredients, instructions and times are what make the result useful. Fill them where the content exists on the page.
Match what visitors see
Every value in the markup must match the visible page. A price, date or ingredient that appears only in the markup goes against Google's guidelines and can lead to a manual action. If the page does not show a value, leave the property out.
Make the files Google needs crawlable
If the markup is built by a script, the script must not be blocked by robots.txt, and any API it calls must answer the crawler. Check the Page resources list in the test for anything marked as blocked.
Platform notes
- WordPress. SEO plugins add
WebPageandWebSitemarkup on every page, which is why most pages show none detected. Product, recipe and event markup normally comes from WooCommerce, a recipe plugin or an events plugin. See rich snippets in WordPress. - Shopify. Most themes print Product markup on product pages, but some leave out
offersdetails on variant pages or print nothing on collection pages, which is expected. See rich snippets in Shopify. - Next.js and other JavaScript frameworks. Render JSON-LD on the server in the page component, so it is part of the first HTML response, not added in a client-side effect.
- Page builders and tag managers. Markup added through a tag manager depends on the container loading for the crawler. If a consent banner holds the container back until a visitor clicks, the crawler never sees the markup.
A worked example
A recipe blog shows no rich results detected for its recipe pages. The Schema Markup Validator, given the URL, finds nothing. The owner's template does contain a Recipe block, so they open View tested page in the Rich Results Test and search the HTML tab: no application/ld+json at all.
The recipe plugin was set to load its markup through the site's tag manager, and the tag manager only loads after a visitor accepts cookies. The crawler never accepts, so the markup never appears. Switching the plugin to print the block directly in the page fixes that. A second test then finds the Recipe item but reports image as missing, because the recipe photo is set as a background in CSS rather than chosen in the plugin. After adding the photo in the plugin's image field, the Rich Results Test shows a valid Recipe item, and the owner requests indexing for the main recipes.
The fix, step by step
Step 1
Run both tests on the URL
Run the URL through the Rich Results Test and the Schema Markup Validator at the same time. Note what each reports. If the validator finds no structured data, the markup is missing or not rendered. If it finds types but the Rich Results Test does not, those types are either unsupported, limited or incomplete. If either tool reports a syntax error, fix that first, because broken markup is ignored entirely by both.
Step 2
Check the rendered HTML
In the Rich Results Test, choose View tested page, open the HTML tab and search for application/ld+json. This is the page after Google ran its scripts. If the block is missing, check whether your template prints it on this page type and whether a script, tag manager or consent tool adds it later. Compare with the server HTML from curl to see whether it arrives with the page or not.
Step 3
Move the markup into the server HTML
Change your template, plugin setting or framework component so the JSON-LD is printed in the HTML the server sends, rather than injected after load. In WordPress or Shopify, use the plugin or theme option that outputs markup directly. In a JavaScript framework, render it on the server. Fetch the page again with curl and count the application/ld+json blocks to confirm the markup is now present before scripts run.
Step 4
Confirm the type supports a rich result
List the types the Schema Markup Validator found and compare them with Google's search gallery of supported features. Types such as WebPage, WebSite and Service produce no rich result, and FAQPage and HowTo are now limited or retired for most sites. If your page only carries those, the result is expected and no fix is needed. If the page suits a supported type, add markup for it.
Step 5
Add the required properties
Open Google's documentation for the type you are using and list its required properties, such as name and image for a Recipe or name, startDate and location for an Event. Fill every required property with values taken from the visible page. Add recommended properties where the content exists. Leave out anything visitors cannot see, then test the URL again and check every required property is now reported.
Step 6
Unblock the files Google needs
Open More info in the tested page view and check the Page resources list for scripts, stylesheets or API calls that could not be loaded. Remove any robots.txt rules that block files used to build the markup, and check security rules are not challenging the crawler. Run URL Inspection's live test as well to confirm Googlebot can fetch the page and its resources without errors.
Step 7
Retest and check every template
Run the Rich Results Test again on the fixed URL and confirm it now lists a valid item for your type, with no errors. Then test one page from every other template that uses the same markup, such as a long product, a short product and a product with variants. Differences between templates are common, and a fix that works on one page often misses another.
Step 8
Request indexing and monitor
For important pages, use URL Inspection and choose Request indexing so Google recrawls them sooner. Over the next few weeks, watch the matching enhancement report in Search Console, such as Product snippets or Recipes, for the valid item count rising. Remember that eligibility does not guarantee a rich result in search; Google decides per query, so judge success by the report rather than by a single search of your own.
Edge cases worth knowing
- Eligible is not shown. A valid, eligible item may still never appear as a rich result. Google decides per search whether it helps. See eligible but not shown.
- Blocked or login-protected pages. The test cannot read a page behind a login, a bot challenge or a
robots.txtblock. Test with the code option instead to check the markup itself. - Different markup on mobile. The test uses the smartphone crawler by default. If your mobile template prints less markup than desktop, the mobile version is the one that counts.
- Wrong type for the page. Marking a category page as a Product, or a service page as an Event, does not make it eligible and can break guidelines. Choose the type that describes the main content; see choosing a schema type.
- Nested items. A supported type nested deep inside another, such as a Product inside a WebPage
mainEntity, is still detected if it is complete. Missing a required property at that level still fails.
Keeping your pages eligible
- Keep structured data in the server HTML, generated from the same fields that print the visible content.
- Test one page of each template in the Rich Results Test after any theme, plugin or app change.
- Check the enhancement reports in Search Console, such as Product snippets or Breadcrumbs, monthly for new errors.
- Review Google's search gallery once or twice a year, because supported types and requirements change.
- Do not chase rich results with markup that does not describe the page. Accurate markup still helps search engines and AI systems understand you, even with no rich result.
For a wider view of markup across your site, the JSON-LD coverage guide shows how to find templates with none at all.
1. What does No rich results detected in this URL mean?
It means the Rich Results Test found nothing on the page that makes it eligible for a rich result Google currently supports. That can be because the page has no structured data, the markup was not in the rendered HTML, it uses a type that has no rich result, or a supported type is missing required properties. Run the Schema Markup Validator on the same URL to see whether any structured data exists, then compare the results to find which case you are in.
2. Why does the Schema Markup Validator find my schema but the Rich Results Test does not?
The Schema Markup Validator shows every schema.org type on the page, while the Rich Results Test only shows types that qualify for Google rich results. If your markup appears in the validator but not the test, it is valid but not eligible. Usually the type has no rich result, such as WebPage or Service, or it is a supported type with a required property missing. Check the type against Google's search gallery and its required properties.
3. Why is my FAQ schema not showing rich results?
Google limited FAQ rich results in 2023 to well-known, authoritative government and health websites, so most sites no longer get them. Valid FAQPage markup on an ordinary business site is expected to show no rich result in Google search. You do not need to remove it, because it still describes the questions and answers on the page for search engines and AI systems. HowTo rich results were withdrawn at the same time, so the same applies to HowTo markup.
4. Does Google see JSON-LD added by JavaScript?
Google can see JSON-LD added by JavaScript when it renders the page, but only if the script runs for its crawler. Markup added after a consent click, a user interaction or a slow API call that fails is often missed. Many other crawlers and AI systems do not run JavaScript at all. Printing the markup in the server HTML avoids all of these problems, and you can check what Google rendered in the HTML tab of the Rich Results Test.
5. Which schema types give rich results?
Google supports rich results for a limited set of types, including Product, BreadcrumbList, Article, Event, Recipe, VideoObject and LocalBusiness, among others. Each has its own required and recommended properties, and the list changes as Google adds, limits or retires features. Many valid schema.org types, such as WebPage, WebSite, Service and Person, describe a page well but produce no rich result. Check Google's search gallery for the current list before you build markup for any new feature.
6. My markup passes the test but no rich result shows in search. Why?
Passing the test means the page is eligible, not that Google will show a rich result. Google decides for each search whether a rich result helps, and it may choose not to show one for your page, your site or that query. The page must also be indexed, and the markup must follow Google's guidelines, including matching visible content. Give it a few weeks after the page is recrawled, and check the enhancement report in Search Console for valid items.
7. Is structured data worth adding if there is no rich result?
Yes, structured data is still worth adding where it accurately describes the page, even with no rich result. It tells search engines and AI systems what the page is about, who published it and how its parts relate, in a form they can read without guessing. That helps with understanding and can help with how your pages are cited. Keep it accurate, match the visible content, and avoid adding types just to chase a feature.
The rich snippets checker reads the markup on your page, shows which types Google supports for rich results, and names any required properties that are missing.
Open Rich Snippet Fixes →