Two Google tools that older tutorials mention, the Structured Data Testing Tool and the Structured Data Markup Helper, have different replacements now. The Schema Markup Validator checks Schema.org syntax, the Rich Results Test checks eligibility for Google Search features, and Search Console URL Inspection shows how Google processed the live page.
Markup Helper was a visual generator, so its replacement is JSON-LD that you write by hand, add through your CMS or site code, or build with a reputable generator.
Google says structured data makes a page eligible for some features but does not guarantee that a feature will appear, so the last step is always to publish, inspect the live URL and watch the reports.
Pick the right tool for each check
Each current tool answers one question, and the quickest way to avoid confusion is to ask which question you have. The Rich Results Test tells you whether a page can qualify for the Google Search features that the test supports. The Schema Markup Validator checks general Schema.org syntax and vocabulary, including types that Google does not document as a Search feature.
The two overlap less than you might expect. If you mark up a type that has no Google feature, the validator can still confirm that the vocabulary is correct, while the Rich Results Test has nothing to evaluate. Google's own guidance in its tool-selection documentation sends you to the Rich Results Test for Google features and to the validator for generic Schema.org validation.

Both tools accept either a URL or pasted code. The validator can fetch a URL or check pasted markup, and it extracts JSON-LD, RDFa and Microdata, as the Schema.org validator documentation explains. When your markup is generated by JavaScript, Google recommends testing the URL instead of pasted code, because code input has JavaScript limitations.
After the page is live, Search Console takes over. Its URL Inspection tool shows what Google sees on a specific URL, and its enhancement reports show recurring problems across the site. You can also run a first syntax check in the Schema Nova schema validator or look at an existing page with the Schema Nova schema checker before you reach for the Google tools.
Create the markup without Markup Helper
Markup Helper let you highlight parts of a page and produced basic Schema.org markup, with JSON-LD or Microdata as the output format, according to Google's older Search Console Help page. Google's current starter guidance presents adding structured data by hand, and following your CMS or front-end code documentation, as the implementation paths. A generator is a third option, as long as you review what it produces.
Start by deciding what the page visibly contains: an article, a product, an event, an organization, a recipe or a video. Pick the matching Schema.org type and read its type and property definitions. Then look at Google's structured data gallery to see whether Google currently documents a Search feature for that type. Write JSON-LD using only facts that appear on the page.
JSON-LD is a W3C Recommendation for writing linked data in JSON, described in the JSON-LD 1.1 specification, and Google's guidelines list it among the supported formats. The example below is a fictional Article. Replace every value with the real details of your page; the domain example.com and the publisher name are placeholders. It is demonstration code, so keep it out of your own page's JSON-LD.
{
"@context": "https://schema.org",
"@type": "Article",
"@id": "https://example.com/articles/structured-data-tools#article",
"url": "https://example.com/articles/structured-data-tools",
"headline": "How to Test Structured Data After the Old Google Tools Changed",
"description": "A practical guide to validating Schema.org markup and checking Google Search eligibility.",
"image": [
"https://example.com/images/structured-data-tools.jpg"
],
"datePublished": "2026-10-01",
"dateModified": "2026-10-20",
"author": {
"@type": "Organization",
"name": "Example Publishing"
},
"publisher": {
"@type": "Organization",
"name": "Example Publishing",
"url": "https://example.com",
"logo": {
"@type": "ImageObject",
"url": "https://example.com/images/logo.png"
}
},
"mainEntityOfPage": {
"@type": "WebPage",
"@id": "https://example.com/articles/structured-data-tools"
}
}Google's Article documentation, updated September 8, 2026, says the Article feature has no required properties and recommends adding the ones that apply. In this example, headline, image, datePublished, dateModified, author and publisher are recommended for that Google feature. The description property and publisher.url are optional for it, and @context and @type are what make the object valid JSON-LD for the type. The vocabulary itself lives on Schema.org, for example Article, author and datePublished.
The block above is raw JSON-LD. To place it on a page, wrap it in a script element in the page's HTML, or paste it into the field your CMS or SEO plugin provides for custom code.
<script type="application/ld+json">
{ "...": "paste the JSON-LD object here" }
</script>If your theme or SEO plugin already outputs an Article or Organization object, update that output instead of adding a second description of the same item. Check the rendered HTML of the live page to see what is already there.
Run the checks in order
The order matters because each check answers a different question, and later checks assume the earlier ones pass. Work through these steps on one page at a time.
- Confirm what the page visibly contains, then choose the Schema.org type and its properties.
- Write the JSON-LD from the facts on the page.
- Add it to the page through your CMS field, theme, template or application output.
- Validate the code in the Schema Markup Validator and fix any syntax or vocabulary errors.
- If Google documents a matching feature, run the URL or the code through the Rich Results Test.
- Publish the page, then inspect the live URL in Search Console and request indexing when it makes sense.
- Watch the matching enhancement report and fix anything it lists.
- Recheck after template, content, CMS or plugin changes.
Start with the validator because it is the more forgiving, general check. A missing comma or a misspelled property name shows up there before you spend time on Google's feature requirements. A message such as a missing closing brace points at the line to fix, and you can read how Google labels field-level problems in the guide to fixing missing field schema warnings.
Then move to the Rich Results Test, but only when the type has a matching feature in Google's gallery. Its results speak about Google feature requirements, so a clean result there says nothing about Bing, Yandex or other systems. If your markup is created by JavaScript, test the live URL so the tool sees the rendered page, and compare the result with what you see in the page source.
The how to add schema markup guide covers the placement options for common platforms in more detail, and the JSON-LD schema examples guide has further types to adapt.

Check the live page in Search Console
Search Console becomes useful once Google can crawl or index the page. URL Inspection lets you inspect a specific URL and see how Google crawled and processed it, and Google's general structured data guidelines point to it for checking a published page. If you have just added or corrected markup, request indexing from the same screen when it is appropriate.
For a whole site, the enhancement reports and the report for unparsable structured data show recurring problems at scale. A report appears for a feature type once Google has processed pages that use it, so an empty report on a new page is not a sign that the markup is wrong. Look again after Google has had time to recrawl.
When a report lists a warning, read which field it names and which feature it belongs to. A missing recommended property is a different level of problem from invalid JSON, and an error for one Google feature does not make the Schema.org type invalid. The guide to fixing missing field schema warnings walks through that distinction field by field.
Make a habit of rechecking after changes to your theme, a plugin update or a template edit. Those are the moments when output changes without anyone touching the markup on purpose.
Why the old tutorial steps stopped working
Google announced the change on December 15, 2020. The old Structured Data Testing Tool would be refocused around open Schema.org standards and moved to the Schema.org community, and it would no longer test Google Search rich result features. Google pointed people to the Rich Results Test for that job.
A May 11, 2021 update named the Schema Markup Validator as the tool's new home. On August 9, 2021, Google said the validator had stabilized and that the old tool redirected to a landing page explaining which tool to use. All of this is in Google's announcement about the Structured Data Testing Tool. That is why a tutorial step such as "paste your code into the testing tool" now lands on a tool-selection page.
Test in Bing and Yandex, and open the page to AI crawlers
Bing Webmaster Tools offers URL Inspection with a Markup card that identifies JSON-LD, Microdata, Microformats and Open Graph markup and reports issues that affect Bing's ability to read the page. Bing's structured data guidance says annotations do not guarantee a visually rich result and that the markup must match the page content.
Yandex provides a structured data validator that supports Microformats, Schema.org, Open Graph, Microdata and RDFa. Its semantic markup FAQ says it does not support every Schema.org type, and that recognized markup can still need indexing and moderation before it appears.
If you want ChatGPT search to reach the page, allow OAI-SearchBot; OpenAI says placement is not guaranteed (crawler documentation). Keep the facts visible in the page text and the pages crawlable. See whether AI uses schema markup for the full comparison.
After a clean result: publish and monitor
A clean result in the validator means the Schema.org data was extracted and is syntactically valid. A clean result in the Rich Results Test means the markup meets the documented conditions for a feature that the test supports. Neither one says the feature will appear, that rankings will change, or that an AI system will cite the page.
Google's gallery also changes over time, so a feature that a tutorial describes may no longer be shown. If a result you expected does not appear, read the guide to rich results and rich snippets for the checks that can change the diagnosis, from page content and eligibility to indexing.
Do not remove markup only because one provider says it does not use it. Search systems differ, they change, and valid markup that matches the visible page remains useful for the consumers that do read it. Finish with the next action: publish, inspect the live URL, request indexing when appropriate, then watch the enhancement report.
Questions people ask
What replaced Google's Structured Data Testing Tool?
Google split the job in two. The Rich Results Test checks eligibility for Google Search features, and the Schema Markup Validator checks general Schema.org markup. After you publish, Search Console URL Inspection and its reports show how Google processed the page.
Does the Schema Markup Validator test Google rich results?
No. It checks Schema.org syntax and vocabulary, including types that Google does not document as a Search feature. For Google feature requirements, use the Rich Results Test and read the result as eligibility, not as a promise of display.
Should I test a URL or paste code?
Paste code while you are still drafting, because it gives quick feedback before the page exists. Switch to the URL once the page is live or when JavaScript generates the markup, since Google recommends URL testing in that case.
Is Markup Helper still the way to generate markup?
It is not a testing tool and is not the current starting point. Choose the Schema.org type, write JSON-LD from the facts on the page, add it through your CMS or code, and validate it. A generator can help if you review its output before publishing.
Should I remove FAQ or HowTo markup?
Not on that basis alone. Google changed how it shows HowTo and FAQ results in 2023 and lists further FAQ changes in its documentation updates, including that FAQ rich results stopped showing in May 2026. FAQPage remains a valid Schema.org type, and other consumers may still read it.
Does valid JSON-LD guarantee a rich result?
No. Google says structured data makes a page eligible for some features but does not guarantee that a feature will appear. Bing makes the same kind of statement about visually rich results, and both say the markup must match the content of the page.
