Schema Markup & JSON-LD Validator

🔎 Schema Markup & JSON-LD Validator for structured data

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. Each row returns schema.org types, JSON-LD, Microdata, RDFa, issue details, page metadata, and rich-result readiness signals, so you can find structured-data problems before a release or during an SEO audit.

🎯 Use cases

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

📊 Returned data

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

🧾 Output fields

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 a public page with no detected structured data. It shows the empty arrays and null values that can appear in a real audit row.

{
  "requestedUrl": "https://schema.org/docs/howwework.html",
  "url": "https://schema.org/docs/howwework.html",
  "title": "How we work - schema.org",
  "canonicalUrl": null,
  "statusCode": 200,
  "contentType": "text/html",
  "crawlDepth": 1,
  "auditedAt": "2026-08-01T04:29:39.998Z",
  "schemaTypes": [],
  "markupSummary": {
    "hasStructuredData": false,
    "jsonLdBlocks": 0,
    "microdataItems": 0,
    "rdfaItems": 0,
    "openGraphProperties": 0,
    "twitterCardProperties": 0,
    "metaTags": 2
  },
  "validationStatus": "valid",
  "issueCounts": {
    "errors": 0,
    "warnings": 0,
    "info": 0
  },
  "issues": [],
  "jsonLd": [],
  "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."
    }
  },
  "richResults": {
    "readiness": {
      "level": "notDetected",
      "reasons": [
        "No common rich-result candidate types were detected."
      ]
    },
    "candidates": []
  }
}

🚀 Running the Actor

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

🧾 Input fields

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 uses the public fields from a small full audit:

{
  "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.

💳 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.

🔗 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

• 0.2: Added requested and final URL provenance, audit timestamps, expanded page limits, and a clearer page-audit overview.
• 0.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é