To see whether a page has schema markup, open it, view its HTML source and search for application/ld+json. That string finds JSON-LD, the format most sites use. If it returns nothing, search for itemscope, itemtype, itemprop, typeof and vocab, the attributes that mark Microdata and RDFa.

Then compare what the markup says with what a visitor sees. The headline, author, date, image and publisher in the code should match the page. The method works on a site you run and on a competitor's page, on WordPress, Shopify, Wix, Squarespace, Webflow and hand-built sites alike.

Check in this order, fastest to most complete: the page source, the rendered page in Developer Tools, a URL test with Google, Schema.org and Bing tools, and for many pages, Search Console, Bing Webmaster Tools and a crawler. These checks show what is on the page. They do not show whether a search engine has indexed or used it.

Key takeaways

  1. Search the page sourceView source with Ctrl+U or Option+Command+U and search for application/ld+json, itemscope, itemtype, itemprop, typeof or vocab.
  2. Inspect the rendered pageDeveloper Tools shows the page after scripts run, which catches JSON-LD added by a theme, plugin or tag manager.
  3. Match the tool to the questionThe Rich Results Test checks Google feature eligibility, the Schema Markup Validator checks Schema.org markup, and Bing URL Inspection shows markup Bing detects.
  4. Compare with the visible pageRead each type, then check headline, author, date, image and publisher against the page, and look for duplicate or contradictory entities.
  5. Use reports for many pagesSearch Console, Bing Webmaster Tools and crawlers cover many URLs, and a crawler reports only what it can fetch and parse.
  6. Valid is not the same as eligibleValid Schema.org markup can sit on a page that is not eligible for a Google rich result, and Google's feature support changes.

Know which formats to look for

Schema markup is structured data that describes the things on a page, such as an article, product, organization, person, event or recipe, using the Schema.org vocabulary. It comes in three formats. JSON-LD sits in a script element, Microdata adds attributes such as itemscope, itemtype and itemprop to visible HTML, and RDFa uses attributes such as vocab, typeof and property.

Google says it supports all three formats and generally recommends JSON-LD (Google's structured data introduction). Bing documents support for Schema.org in JSON-LD and Microdata, as well as Microformats, RDFa and Open Graph (Bing's structured data guidance). So, a page may use more than one format, and a full check looks for all of them. The JSON-LD syntax itself is defined by the W3C JSON-LD 1.1 specification.

One term trips people up when they search for this topic. JSON Schema is a separate standard for describing and validating the structure of JSON documents. It is not the same as Schema.org, and a JSON Schema file on a site does not describe the page to a search engine.

Search the page source

Open the page in your browser and press Ctrl+U on Windows or Option+Command+U on macOS. The browser opens the HTML the server sent, before any script changes it. Press Ctrl+F (or Command+F on macOS) and search for each of these terms in turn.

text
application/ld+json
schema.org
itemscope
itemtype
itemprop
typeof
vocab

A JSON-LD block looks like a script element with the type application/ld+json. The content inside it is the markup. Your own page will contain real values; this short pattern only shows the shape.

html
<script type="application/ld+json">
  {
    "@context": "https://schema.org",
    "@type": "Article"
  }
</script>

Microdata appears as attributes wrapped around visible content instead of a separate script. In the next example, the itemtype value names the type and itemprop marks which text is the headline. If your search finds itemscope and itemtype attributes like these, the page uses Microdata, and RDFa looks similar with vocab, typeof and property.

html
<article itemscope itemtype="https://schema.org/Article">
  <h1 itemprop="headline">Example article</h1>
</article>
A man with a short beard and glasses follows a long block of blurred lines on a laptop screen in a small office
Figure 1. Searching the page source for application/ld+json is the fastest first check.

Finding the string schema.org alone does not prove a page has markup, because it can appear in a link or a comment. Look for the script type or the attributes, then read what they describe. If none of the terms appear in the source, the markup may still be added after the page loads, which the next section covers.

Inspect the rendered page with Developer Tools

Source markup is the HTML the server returns before browser JavaScript runs. Rendered markup is the page structure after scripts have run and updated the document. A theme, plugin, tag manager or CMS feature can add JSON-LD during rendering, so it appears in the second version and not the first. Google says it can process JSON-LD injected into the rendered page when it can render that page, and it also says that not every crawler or search service executes JavaScript the same way (Google's JavaScript SEO basics).

Open Developer Tools (usually F12, or right-click and choose Inspect), switch to the Elements panel and search the DOM for the same terms. The Elements panel shows the document as it stands now, scripts included. If a term appears there and not in the page source, scripts added it.

The Console is quicker for JSON-LD. Paste this line and press Enter to list the text of every JSON-LD block currently in the page.

javascript
[...document.querySelectorAll('script[type="application/ld+json"]')]
  .map(element => element.textContent)

An empty list means the current page has no JSON-LD script elements. For Microdata and RDFa, each of these lines returns a count of matching elements, and a count of zero means none were found.

javascript
document.querySelectorAll('[itemscope][itemtype]').length
document.querySelectorAll('[typeof], [vocab][property]').length
Two page cards joined by a line, the right one carrying extra bracket tiles added by a gear icon, with a checked card below
Figure 2. Scripts can add markup after the page loads, so the rendered page can differ from the source.

These snippets identify markup present in the current DOM. They do not prove that a search engine has indexed or used it. If markup shows up only in the rendered page, confirm that the scripts and data that produce it are available to the crawler you care about. Rendered markup also has to describe content visitors can see; hidden, inaccurate or unrelated information does not belong in it.

Test the URL with Google, Schema.org and Bing tools

Each tool answers a different question, so pick the one that matches yours. Google's Rich Results Test checks a public URL or pasted code for eligibility for Google-supported rich result features, and Google's help page says it can show the rendered HTML it tested. The Schema Markup Validator checks Schema.org markup without applying Google's feature requirements. For a detailed comparison of the two, read Rich Results Test vs Schema Markup Validator.

Bing has its own view. After you verify a site in Bing Webmaster Tools, URL Inspection has a Markup card that can display the JSON-LD, Microdata, Microformats and Open Graph that Bing detects, and a live URL view that shows what Bingbot receives. DuckDuckGo says it keeps its own crawler and indexes while sourcing most traditional links and images largely from Bing (DuckDuckGo Help), which is one more reason to look at Bing's view. For Apple, the App Search API Validation Tool checks the data Applebot can extract for Apple search experiences.

Schema Nova has two free tools for this step. The Schema Nova schema checker takes a page URL and reads the structured data in the HTML it retrieves from that address, so use the Console method above for markup that scripts add later. For code you have copied from a page, the Schema Nova schema validator tests it directly.

Browser extensions can also list the markup on a page. If you use one, install it from an official browser store listing, review the publisher and the permissions it asks for, and treat it as a convenience. Confirm anything important with the relevant provider's own validator or inspection tool.

Read what the markup says

Once you have a block of JSON-LD in front of you, read it as a description of things and how they relate. Each part has a job.

  • @context names the vocabulary, usually https://schema.org.
  • @type names the Schema.org type, such as BlogPosting.
  • @id gives an entity a stable identifier that other entities can reference.
  • Properties such as headline, author, datePublished, image and publisher describe the entity.
  • Nested objects describe related entities, and arrays hold several values.
  • @graph groups several entities in one document, and several script blocks can each describe a related entity.

Here is a complete, fictional BlogPosting that shows those parts together. Every URL and name uses the reserved domain example.com or fictional names. If you copy it for your own page, replace each value with one that matches your page.

json
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "@id": "https://example.com/blog/example-guide/#article",
  "url": "https://example.com/blog/example-guide/",
  "headline": "A Fictional Guide to Example Data",
  "description": "A fictional explanation of example data for demonstration purposes.",
  "image": [
    "https://example.com/images/example-guide-1x1.jpg",
    "https://example.com/images/example-guide-4x3.jpg",
    "https://example.com/images/example-guide-16x9.jpg"
  ],
  "datePublished": "2026-10-01T09:00:00-05:00",
  "dateModified": "2026-10-08T14:30:00-05:00",
  "author": {
    "@type": "Person",
    "@id": "https://example.com/about/alex-example/#person",
    "name": "Alex Example",
    "url": "https://example.com/about/alex-example/"
  },
  "publisher": {
    "@type": "Organization",
    "@id": "https://example.com/#organization",
    "name": "Example Publishing",
    "url": "https://example.com/",
    "logo": {
      "@type": "ImageObject",
      "url": "https://example.com/images/example-publishing-logo.png"
    }
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/blog/example-guide/"
  },
  "about": {
    "@type": "Thing",
    "name": "Example data"
  }
}

This markup says the page describes a blog post titled "A Fictional Guide to Example Data," written by a person named Alex Example and published by an organization named Example Publishing. By itself it does not prove that Google will show an article enhancement.

Compare each important value with the visible page. The headline should match the page title, the author should be identified on the page, the dates should be visible and accurate, the image should belong to the page, and the publisher name should match the site.

Look for duplicate or contradictory entities too, and for ratings or reviews that are not genuine and visible on the page. A theme and a plugin can each describe the same article, and duplicate schema markup from plugins and themes covers how to find and remove the extra copy.

Two layers of rules apply to what you just read. Schema.org defines the vocabulary, so Article, BlogPosting, Person and Organization list the properties that exist. Google's feature documentation defines which properties and policies matter for a specific Google Search feature. Google's Article documentation lists Article, NewsArticle and BlogPosting as compatible types and currently states that there are no required properties, only recommended ones. When a validator flags a missing field, fixing missing field warnings walks through the next step.

Article properties: vocabulary versus Google feature status

Hover over or tap a row to highlight it. On small screens the table scrolls sideways.

PropertySchema.org basisGoogle Article feature status
@typeNames the type, such as BlogPostingIdentifies an Article-compatible type: Article, NewsArticle or BlogPosting
headlineDefined on ArticleRecommended for this Google feature
imageDefined on ArticleRecommended for this Google feature
datePublished and dateModifiedDefined on CreativeWorkRecommended for this Google feature
author name and urlDefined on Person or OrganizationRecommended for this Google feature
publisher and logoDefined on CreativeWork and OrganizationNot in Google's list for this feature; still valid Schema.org

Check many pages with reports and crawlers

Page-level inspection answers questions about one URL. For a whole site, add reports. In Google Search Console, open the relevant enhancement or rich result report after Google has crawled your pages, and use URL Inspection to examine one address and test the live page. Search Console can show structured data issues it detects, but its reports cover Google's systems and supported features, not every Schema.org type.

Look again after you publish structured data for the first time, change a theme, template, plugin or CMS setting, change how JavaScript renders, migrate a domain or platform, or notice a drop in valid items or rich result appearances.

Bing Webmaster Tools works the same way. Verify the site, then use URL Inspection for individual addresses and the Markup card for what Bing detected.

A crawler can collect the URLs that contain JSON-LD, the Schema.org types in use, missing or malformed JSON-LD, duplicate entities, inconsistent canonical URLs and pages whose markup differs from the rest. It reports only what it can fetch and parse, though. JavaScript rendering, robots rules, logins, rate limits and templates all change the result. Sample each important template, then open a few representative URLs and inspect them by hand.

Check the markup your platform adds

Many platforms write markup for you, so inspect the published page before you assume a setting is active or add another block. Squarespace says it automatically generates BlogPosting, Event, LocalBusiness, Organization, Product and WebSite markup (Squarespace Help). Wix supports manual JSON-LD and automatic or AI-generated markup for some page types (Wix Help Center).

Webflow provides a Schema markup field and custom code options, in a help article updated January 27, 2026 (Webflow Help Center). The Next.js documentation, last updated February 27, 2026, recommends rendering JSON-LD in a script tag in layout.js or page.js (Next.js JSON-LD guide).

WordPress, Shopify and HubSpot sites may get markup from a theme, a platform feature or a plugin, and the combination differs from one install to the next. The published page is the only reliable record of what is live. Platform-specific installation steps are in the guides for WordPress, Shopify, Wix, Squarespace, Webflow, HubSpot and Next.js and React.

Follow the checks in order

When you are not sure where to start, run the checks in this order and stop as soon as you have the answer you need. Each step adds a layer that the previous one cannot show.

Inspection path for any page

  1. Open the pageLoad the public URL in a browser.
  2. View the sourceSearch for application/ld+json, itemscope, itemtype, itemprop, typeof and vocab.
  3. Inspect the rendered DOMLook in Developer Tools for markup that scripts add after load.
  4. Run the validatorsTest the URL in the Rich Results Test, then in the Schema Markup Validator.
  5. Compare with the pageCheck each value in the markup against the visible content.
  6. Scale upFor many pages, use Search Console, Bing Webmaster Tools or a crawler.

Bing's Markup card, described above, shows the JSON-LD, Microdata and RDFa it detected, so use it when you want to confirm Bing sees what you found. Yandex does not support every Schema.org type, so check the type you use in Yandex's documentation.

For AI search, access matters most. OpenAI says OAI-SearchBot is used to surface websites in ChatGPT search features and that allowing or disallowing it affects ChatGPT search visibility (OpenAI crawler overview). Keep important information visible, accurate and crawlable in ordinary HTML, and do not add markup that is invisible or inconsistent with the page. For more, see whether AI systems use schema markup.

Know what a passing result does and does not mean

Valid Schema.org markup can sit on a page that is not eligible for a Google rich result. Google's general structured data guidelines say markup enables eligibility but does not guarantee a particular display, ranking, traffic or citation (Google's general guidelines). A positive result in the Schema Markup Validator likewise says nothing about whether Google, Bing, Apple, Yandex or an AI system will show anything.

Google's feature support also changes, so the current feature page decides what to add. Google's documentation updates page says FAQ rich results stopped appearing on May 7, 2026, and that the FAQ documentation was removed in June 2026. FAQPage remains a valid Schema.org type. Google's earlier HowTo and FAQ changes retired HowTo rich results, and its sitelinks search box announcement set the retirement date for that feature at November 21, 2024.

If your markup is valid and Google shows nothing, read why schema rich results are not showing. For a full quality pass on what you have, use the schema markup best practices checklist, and for a direct page-level look at any URL, run it through the Schema Nova schema checker.

Questions people ask

How do I check if a website has schema markup?

View the page source with Ctrl+U or Option+Command+U and search for application/ld+json, itemscope, itemtype, itemprop, typeof and vocab. Then inspect the rendered DOM in Developer Tools and test the URL with the Rich Results Test and the Schema Markup Validator.

Can I see schema markup on a site I do not own?

Yes. Anyone can view a public page's source, inspect it in the browser and test its URL in Google's Rich Results Test or the Schema Markup Validator. You can read what a competitor's page declares, though you can only change markup on pages you control.

What is the difference between the Rich Results Test and the Schema Markup Validator?

The Rich Results Test checks eligibility for Google-supported rich result features, so it reports on the types Google uses. The Schema Markup Validator checks Schema.org markup without Google's feature rules, so it can read types that have no Google feature.

Why does the page source differ from the Elements panel?

The source is the HTML the server returned. The Elements panel shows the page after scripts have run, so JSON-LD added by a theme, plugin or tag manager appears there and may be missing from the source.

Does valid markup guarantee a rich result or an AI citation?

No. Google's guidelines say structured data enables eligibility but does not guarantee display, ranking, traffic or citation, and Bing's guidelines say it does not guarantee visibility or grounding. Validity describes the markup, and display is each provider's decision.

What is the difference between JSON-LD and JSON Schema?

JSON-LD is a format for embedding linked data, often Schema.org markup, in a page. JSON Schema is a separate standard for describing and validating the structure of JSON documents, and it does not describe page content for search engines.

Quick check

Choose an answer to see feedback. Nothing is scored or saved.

Question 1 of 3

A page contains valid BlogPosting JSON-LD, but Google shows no article enhancement. Which conclusion is correct?

Question 2 of 3

JSON-LD appears in the Elements panel but not in the page source. What is the most likely reason?

Question 3 of 3

Which tool checks Schema.org markup without applying Google's feature-specific requirements?

Terms used in this check

Select a term to see its definition.

Structured data. Machine-readable information that describes the meaning of page content.