Schema Markup & JSON-LD Validator

🔎 Validate schema markup on public pages

SEO specialists, developers, and site owners can use Schema Markup & JSON-LD Validator to check public pages. It saves one audit row for each page it successfully fetches and checks, with schema.org types, JSON-LD, Microdata, RDFa, issue details, page metadata, and rich-result readiness signals. Use these rows to find structured-data problems before a release or during an SEO audit.

• Run a markup check before Google's official eligibility test with Google Rich Results Test.
• Check public pages and filter rows by schema types or issue counts with Schema Validator.
• Run a focused JSON-LD check with Schema Testing Tool.
• Compare JSON-LD, Microdata, and RDFa with Structured Data Testing Tool.
• Validate schema markup on public pages with Schema Markup Validator.

📊 Schema markup audit data

The results output field links to an Apify dataset. Each saved row is one audit of a page that was fetched successfully. Full, Schema.org, and JSON-LD focus use the same top-level row shape; fields that do not apply can be empty or null.

🚀 Run a schema markup audit

1. Add one or more public page URLs in Page URLs.
2. Choose Full structured-data audit, Schema.org markup only, or JSON-LD only.
3. Choose Submitted URLs only for exact page checks, or Follow same-site links to discover more pages on the same site.
4. Set Maximum pages when you want a work limit. Leave it empty to return all available page results until the source is exhausted.
5. Run the Actor and open the dataset from the results output field.

The prefilled Schema.org Article and Product URLs are public pages you can use to inspect the output before adding your own pages.

⚙️ Input

Field	Type	What it does
startUrls	array of URL objects	Add up to 1,000 public page URLs to check for structured data and rich-result signals.
startUrls[].url	string	URL in each page entry.
auditFocus	string	Choose full, schemaOrg, or jsonLd to set how much structured data to check.
crawlScope	string	Choose submittedUrls to check only added URLs, or sameSite to follow links on the same site.
maxPages	integer, optional	Stops after this many submitted and discovered pages. Leave it empty to return all available page results until the source is exhausted.

Input example

This example is copied from the public input of a successful full audit run using the prefilled pages:

{
  "startUrls": [
    {
      "url": "https://schema.org/Article"
    },
    {
      "url": "https://schema.org/Product"
    }
  ],
  "auditFocus": "full",
  "crawlScope": "sameSite",
  "maxPages": 10
}

Audit focus

• full checks JSON-LD, Microdata, RDFa, Open Graph, Twitter Cards, canonical data, and meta tags.
• schemaOrg focuses on Schema.org markup in JSON-LD, Microdata, and RDFa.
• jsonLd runs a focused JSON-LD check.

Pages to check

• submittedUrls checks only the URLs in startUrls.
• sameSite follows links on the same site from submitted pages while respecting maxPages.

🧾 Output

Run output

Field	Type	What it does
results	string	Opens the Apify dataset with one row for each saved public page audit.

Page audit row

Field	Type	What it does
requestedUrl	string	URL sent in the HTTP request before redirects.
url	string	Final URL of the audited page after redirects.
title	string or null	HTML title text, or null when it is not available.
canonicalUrl	string or null	Canonical URL declared by the page, or null when absent.
statusCode	integer	HTTP status code returned for the fetched page.
contentType	string or null	HTTP content type returned for the page, or null when unavailable.
crawlDepth	integer	Depth from the submitted URL: 0 for submitted pages and higher for same-site discoveries.
auditedAt	date-time string	Time when the page audit finished.
schemaTypes	array of strings	Schema.org type names found in all markup formats.
markupSummary	object	Counts and presence flags for structured-data and metadata surfaces.
markupSummary.hasStructuredData	boolean	Whether JSON-LD, Microdata, or RDFa markup is present.
markupSummary.jsonLdBlocks	integer	Number of JSON-LD blocks found.
markupSummary.microdataItems	integer	Number of Microdata items found.
markupSummary.rdfaItems	integer	Number of RDFa items found.
markupSummary.openGraphProperties	integer	Number of Open Graph properties found.
markupSummary.twitterCardProperties	integer	Number of Twitter Card properties found.
markupSummary.metaTags	integer	Number of general meta tags found.
validationStatus	string	Page-level status: valid, warning, or error.
issueCounts	object	Issue totals grouped by severity.
issueCounts.errors	integer	Number of errors found.
issueCounts.warnings	integer	Number of warnings found.
issueCounts.info	integer	Number of informational findings.
issues	array of objects	Findings that explain what to fix and where it was found.
issues[].severity	string	Severity of the finding: error, warning, or info.
issues[].code	string	Stable code for the finding type.
issues[].message	string	Short explanation of the finding and what to fix.
issues[].format	string or null	Markup format linked to the finding, or null.
issues[].schemaType	string or null	Schema.org type linked to the finding, or null.
issues[].property	string or null	Markup property linked to the finding, or null.
issues[].evidence	string or null	Short source detail that helps locate the finding, or null.
jsonLd	array of objects	Parsed JSON-LD blocks with status, types, and issues.
jsonLd[].index	integer	One-based position of the JSON-LD block.
jsonLd[].valid	boolean	Whether the JSON-LD block passed its checks.
jsonLd[].context	string, array, object, or null	JSON-LD context value, or null when missing.
jsonLd[].types	array of strings	Schema.org types found in the block.
jsonLd[].data	object	Parsed JSON-LD value from the block. It keeps the source fields found in that block.
jsonLd[].issues	array of strings	Issue codes linked to the block.
microdata	array of objects	Microdata items with types, properties, and issues.
microdata[].index	integer	One-based position of the Microdata item.
microdata[].types	array of strings	Schema.org types found in the Microdata item.
microdata[].properties	object	Properties parsed from the Microdata item. It keeps source fields.
microdata[].issues	array of strings	Issue codes linked to the Microdata item.
rdfa	array of objects	RDFa items with types, properties, and issues.
rdfa[].index	integer	One-based position of the RDFa item.
rdfa[].types	array of strings	Schema.org types found in the RDFa item.
rdfa[].properties	object	Properties parsed from the RDFa item. It keeps source fields.
rdfa[].issues	array of strings	Issue codes linked to the RDFa item.
metadata	object	Open Graph, Twitter Card, and meta tag values found on the page.
metadata.openGraph	object	Open Graph names and values found on the page.
metadata.twitterCard	object	Twitter Card names and values found on the page.
metadata.metaTags	object	General meta tag names and values found on the page.
richResults	object	Rich-result checks based on the markup and its issues.
richResults.readiness	object	Overall rich-result readiness level and its reasons.
richResults.readiness.level	string	Readiness level: ready, needsFixes, or notDetected.
richResults.readiness.reasons	array of strings	Reasons for the readiness level.
richResults.candidates	array of objects	Rich-result candidates found in the markup.
richResults.candidates[].type	string	Schema.org type used for the candidate.
richResults.candidates[].eligible	boolean	Whether the Actor's known required fields are present.
richResults.candidates[].requiredMissing	array of strings	Required properties that are missing.
richResults.candidates[].recommendedMissing	array of strings	Recommended properties that are missing.
richResults.candidates[].issueCodes	array of strings	Issue codes linked to the candidate.

The data, properties, and metadata objects keep source fields that the page provides. Their extra field names can vary by page.

Example page audit

This complete row comes from a successful full audit of https://schema.org/. It shows a valid WebSite block and the page-level fields saved with it.

{
  "requestedUrl": "https://schema.org/",
  "url": "https://schema.org/",
  "title": "Schema.org - Schema.org",
  "canonicalUrl": null,
  "statusCode": 200,
  "contentType": "text/html",
  "crawlDepth": 0,
  "auditedAt": "2026-08-02T05:53:56.338Z",
  "schemaTypes": [
    "WebSite"
  ],
  "markupSummary": {
    "hasStructuredData": true,
    "jsonLdBlocks": 1,
    "microdataItems": 0,
    "rdfaItems": 0,
    "openGraphProperties": 0,
    "twitterCardProperties": 0,
    "metaTags": 4
  },
  "validationStatus": "valid",
  "issueCounts": {
    "errors": 0,
    "warnings": 0,
    "info": 0
  },
  "issues": [],
  "jsonLd": [
    {
      "index": 1,
      "valid": true,
      "context": "https://schema.org",
      "types": [
        "WebSite"
      ],
      "data": {
        "@context": "https://schema.org",
        "@type": "WebSite",
        "url": "https://schema.org",
        "name": "Schema.org",
        "potentialAction": {
          "@type": "SearchAction",
          "target": {
            "@type": "EntryPoint",
            "urlTemplate": "https://schema.org/docs/search_results.html?q={query}"
          },
          "query-input": "required name=query"
        },
        "about": {
          "@type": "Project",
          "name": "Schema.org Project",
          "description": "Schema.org is a collaborative, community activity with a mission to create, maintain, and promote schemas for structured data on the Internet, on web pages, in email messages, and beyond.",
          "logo": "https://schema.org/docs/schemaicon.png",
          "sameAs": "https://github.com/schemaorg/schemaorg/",
          "foundingDate": "2011-06-2",
          "founder": [
            {
              "@type": "Corporation",
              "name": "Google",
              "url": "https://google.com"
            },
            {
              "@type": "Corporation",
              "name": "Microsoft",
              "url": "https://microsoft.com"
            },
            {
              "@type": "Corporation",
              "name": "Yahoo",
              "url": "https://yahoo.com"
            },
            {
              "@type": "Corporation",
              "name": "Yandex",
              "url": "https://yandex.com"
            }
          ],
          "publishingPrinciples": "https://www.w3.org/community/about/process/cla/"
        },
        "author": {
          "@type": "Organization",
          "name": "Schema.org Community Group",
          "sameAs": "https://www.w3.org/community/schemaorg/"
        }
      },
      "issues": []
    }
  ],
  "microdata": [],
  "rdfa": [],
  "metadata": {
    "openGraph": {},
    "twitterCard": {},
    "metaTags": {
      "viewport": "width=device-width, initial-scale=1",
      "description": "Schema.org is a set of extensible schemas that enables webmasters to embed\n    structured data on their web pages for use by search engines and other applications.",
      "theme-color": "#990000",
      "google-site-verification": "sF2wOoEXHr7h_vTNkOOJXQxDWw2h-B4QwizxbkoIQC0"
    }
  },
  "richResults": {
    "readiness": {
      "level": "notDetected",
      "reasons": [
        "No common rich-result candidate types were detected."
      ]
    },
    "candidates": []
  }
}

💳 Pricing

This Actor uses pay-per-event pricing. A page-audit charge applies when a public page is fetched, audited, and saved to the dataset. The current price is shown in the Pricing tab.

🔌 Integrations

Use the Apify dataset or API to read saved audits and connect them to your workflow. For an Apify integrations walkthrough, see:

❓ FAQ

Does this run Google's official Rich Results Test?

No. The Actor checks markup in the fetched HTML. Use Google's official tool as the final authority for Google-specific eligibility.

What happens when a page uses client-side JavaScript?

The Actor checks the initial public HTML response. Markup added later by client-side JavaScript or hidden behind a private login may not appear.

What happens if one page cannot be fetched?

The Actor continues with the other submitted or discovered pages. It saves an audit row for each page that is fetched and checked successfully.

Should I use submitted URLs or same-site links?

Use Submitted URLs only when your input list already contains every page to check. Use Follow same-site links when one or more public pages should lead to more pages on the same site within maxPages.

Which markup formats can it check?

A full audit checks JSON-LD, Microdata, RDFa, Open Graph, Twitter Cards, canonical data, and meta tags. A Schema.org audit focuses on Schema.org markup, and a JSON-LD audit focuses on JSON-LD.

What happens if I leave Maximum pages empty?

The Actor returns all available page results until the source is exhausted. Set a number when you want to limit submitted and discovered pages.

Does it repair markup or return raw HTML?

No. It reports findings from fetched markup. It does not generate or repair Schema.org markup, and it does not save complete raw page HTML.

Can I audit private pages?

No. The input is for public page URLs. Pages behind a login are outside this Actor's scope.

Why can a row have a warning status?

A warning is a finding in the page audit, not a missing row. Use issueCounts and issues to see the severity and details.

📝 Changelog

v0.2

• Added requested and final URL provenance.
• Added audit timestamps.
• Expanded page limits.
• Clarified the page-audit overview.

v0.1

• Initial release.

🆘 Support

For issues, questions, or feature requests, file a ticket and I'll fix or implement it in less than 24h 🫡

🔗 Related Actors

• Website URL Crawler & Link Extractor — Build a public page list from links and sitemaps before choosing URLs for schema audits.
• Sitemap Sniffer — Find public sitemap files and their URL lists for audit inputs.
• XML Sitemap Health Validator — Check sitemap-listed page status and redirects before structured-data checks.
• Website Change Monitor & Diff Checker — Track later changes to JSON-LD, metadata, and links on public pages.
• Seobility SEO Checker — Run a separate on-page SEO check for pages selected for structured-data review.

Made with ❤️ by Maxime Dupré