AnyTool
Your files never leave your device. All processing happens locally in your browser.

How do I test ALL the structured data on a page without uploading the page to a server?

Open AnyTool’s Structured Data Tester, open your page and copy its HTML source (View Source / Ctrl+U), and paste it in. The tester inventories everything a search engine would find: it extracts every JSON-LD <script type="application/ld+json"> block (expanding @graph and arrays) and validates each, and it detects Microdata (itemscope / itemtype / itemprop) and RDFa (vocab / typeof / property) presence with counts and the type URLs. You get a page report — a summary (how many JSON-LD blocks, whether Microdata / RDFa are present, how many total types), a type inventory listing every @type with its format and a rich-result eligibility chip, and a per-block validation card for each JSON-LD block (errors / warnings / info + pretty JSON). Everything runs in your browser, so your page HTML is never uploaded — safe for staging or unreleased pages. Your browser can’t fetch most live URLs (CORS) and there is no server proxy, so paste the source; it is a helpful client-side tester, not the official Google Rich Results Test, so confirm eligibility there.

  • Paste your page’s HTML source — every JSON-LD block is extracted and validated
  • Detects Microdata (itemscope/itemtype/itemprop) and RDFa (vocab/typeof/property) presence
  • Type inventory: every @type, its format (JSON-LD / Microdata / RDFa) and rich-result eligibility
  • Per-JSON-LD-block validation (errors / warnings / info) + pretty JSON
  • 100% client-side — page HTML never uploaded; safe for staging / unreleased pages

What is

Structured data testing (page-level)

Page-level structured-data testing is the process of inventorying every piece of machine-readable markup on a web page that a search engine can read. Search engines understand three formats: JSON-LD (Google’s preferred format, embedded in a <script type="application/ld+json"> tag), Microdata (inline HTML attributes itemscope / itemtype / itemprop) and RDFa (inline attributes vocab / typeof / property). A page-level tester extracts all of them, lists every schema.org @type found, and flags which types can produce a Google rich result. This differs from validating a single JSON-LD snippet: the goal is a complete inventory of what a crawler sees on the whole page.

SEO & Web

Related terms

JSON-LDMicrodataRDFaSchema.orgRich Results TestStructured Data Testing ToolRich snippets

Frequently Asked Questions

The Tester takes your whole page HTML and inventories every format a crawler finds — all JSON-LD blocks plus Microdata / RDFa. The Schema Validator focuses on validating a single pasted JSON-LD snippet in depth.

They are siblings for different jobs. The Structured Data Tester is page-level: you paste your full page source and it extracts every JSON-LD block, detects Microdata and RDFa presence, and builds an inventory of every schema.org type on the page with rich-result eligibility — like the old Structured Data Testing Tool. The Schema Validator is snippet-level: you paste one JSON-LD object and get a deep, per-property validation against a curated schema.org knowledge base and Google’s required / recommended rules. Use the Tester to audit a whole page and the Validator to perfect a single block. Both run 100% in your browser and share the same underlying engine.

All three. It fully parses and validates JSON-LD, and detects Microdata (itemscope/itemtype/itemprop) and RDFa (vocab/typeof/property) presence with their type URLs.

Search engines read three structured-data formats and the tester covers all of them. JSON-LD lives in <script type="application/ld+json"> tags and is Google’s preferred format — it is fully parsed and validated, block by block. Microdata is written as inline HTML attributes (itemscope, itemtype, itemprop) and RDFa as inline attributes (vocab, typeof, property); these legacy formats are detected — the tool counts the scope attributes and lists the schema.org type URLs — rather than fully parsed, because Google recommends JSON-LD. The result is a complete picture of every format and type a crawler would find on the page.

Paste the HTML source. Your browser can’t fetch most live URLs (CORS) and there’s no server proxy, so the URL box only works for CORS-enabled or same-origin pages.

Because the tool is 100% client-side with no server proxy — which is what keeps your page private — your browser can only fetch pages that explicitly allow cross-origin requests (CORS) or are on the same origin. Almost all live sites block that, so the reliable path is to open your page, use View Source (Ctrl+U), copy the HTML and paste it in. The optional “try to fetch” box is there for the rare CORS-enabled case; when it fails, it tells you to paste the source instead. Nothing you paste is ever uploaded.

No. This is a helpful client-side tester for common types — not the official Google Rich Results Test. Confirm eligibility there.

A clean report means the JSON-LD parsed and passed the tool’s curated checks and shows which types can produce a rich result — but a visible rich result also depends on content quality, policy compliance and the markup matching what users see on the page. This tool is not the official Google Rich Results Test (which decides eligibility) or the schema.org Schema Markup Validator at validator.schema.org (which knows the full vocabulary), and it detects rather than fully parses Microdata / RDFa. Always confirm in Google’s Rich Results Test before relying on a rich result.

Detailed Explanation

How It Works

What the Structured Data Tester Inventories

The Structured Data Tester is a PAGE-LEVEL tester: the user pastes a whole page’s HTML source (View Source / Ctrl+U) and the tool inventories every piece of machine-readable markup a search engine would find on that page. Search engines read three structured-data formats and the tester covers all three. JSON-LD (Google’s preferred format) lives in <script type="application/ld+json"> tags — the shared engine schemaValidateEngine.ts extracts every block (expanding @graph wrappers and top-level arrays into individual nodes) and validates each. Microdata is written as inline HTML attributes (itemscope / itemtype / itemprop) and RDFa as inline attributes (vocab / typeof / property); the tool DETECTS these legacy formats with a small in-memory regex scan — counting the scope attributes and collecting the schema.org type URLs — rather than fully parsing them, because Google recommends JSON-LD. The output is a page report: a SUMMARY (how many JSON-LD blocks, whether Microdata / RDFa are present and how many, total distinct types), a TYPE INVENTORY listing every @type with its format and a rich-result eligibility chip, a legacy-formats panel, and a per-JSON-LD-block validation card.

  • Page-level: paste your whole page HTML and see everything a crawler finds
  • Extracts and validates every JSON-LD block (@graph + arrays expanded)
  • Detects Microdata (itemscope/itemtype/itemprop) and RDFa (vocab/typeof/property) presence + types
  • Type inventory with format and Google rich-result eligibility per @type
  • All parsing and detection is pure client-side JavaScript — no server call, no CDN, no upload
Methodology

How It Detects Each Format and Maps Rich Results

JSON-LD is handled by the shared engine’s extractJsonLd / validateSchema: it locates every <script type="application/ld+json"> block in the pasted HTML, parses the JSON, flattens @graph and arrays, and checks each node’s @context and @type plus required (error) and recommended (warning) properties against a curated knowledge base of 25+ common schema.org types, with value-sanity checks for ISO 8601 dates and absolute URLs. Microdata and RDFa are detected inline: the tester scans for the bare itemscope / typeof scope attributes (a count), and reads itemtype / typeof / vocab attribute values to list the schema.org types present (shortened to their local name). It then builds a unified TYPE INVENTORY across all three formats and, using the shared RICH_RESULT_REQUIREMENTS map, tags each type with the Google rich result it can produce — Product snippet, review snippet, FAQ, Recipe, Event, Job posting, Video, Breadcrumb, Sitelinks search box, Organization signals and more — so the user sees which rich-result types are present on the page. Each JSON-LD block additionally gets a validation card (errors / warnings / info ordered, pinned to the property path) and a pretty JSON view.

  • JSON-LD via the shared schemaValidateEngine (extractJsonLd + validateSchema); engine unchanged
  • Microdata detected via itemscope/itemtype/itemprop; RDFa via vocab/typeof/property
  • Type URLs are read from itemtype / typeof / vocab and shortened to the schema.org local name
  • Unified type inventory across formats, tagged with rich-result eligibility (RICH_RESULT_REQUIREMENTS)
  • Per-JSON-LD-block validation: required (error) / recommended (warning) + ISO dates / absolute URLs
Limitations

Paste Source (CORS), Detects Legacy Formats, Not the Official Test

The tool is explicit about three honest limits. First, paste the page SOURCE: because it is 100% client-side with NO server proxy (which is what keeps your page private), your browser can only fetch CORS-enabled or same-origin pages — almost all live sites block cross-origin requests, so the reliable path is View Source (Ctrl+U) → copy → paste; the optional “try to fetch” box is only for the rare CORS-enabled case and, on failure, tells you to paste instead. Second, Microdata and RDFa are DETECTED (presence, counts and type URLs), not fully parsed — JSON-LD is the format Google recommends and the one fully parsed and validated here. Third, it is a helpful client-side tester covering common types — NOT the official Google Rich Results Test (which decides real rich-result eligibility) or the schema.org Schema Markup Validator at validator.schema.org (which knows the full vocabulary). A clean report shows which types CAN produce a rich result, but a visible rich result also depends on content quality, policy compliance and the markup matching the visible page, so the tool always advises confirming in Google’s Rich Results Test. For deep validation of a single JSON-LD snippet, the sibling Schema Validator is the better fit.

  • Paste your page source — browser can’t fetch most live URLs (CORS); no server proxy keeps it private
  • Microdata / RDFa are detected (presence + types), not fully parsed; JSON-LD is fully validated
  • Not the official Google Rich Results Test or schema.org Schema Markup Validator — confirm there
  • A clean report is not a guarantee of a visible rich result; markup must match the visible page
  • For deep single-snippet validation, use the sibling Schema Validator
Privacy & Security

Why Testing a Page In-Browser Is a Privacy Win

Online structured-data testers send your whole page — or a URL they crawl server-side — to a remote service. The Structured Data Tester instead runs entirely on the user’s device: the pasted page HTML is scanned and parsed with plain JavaScript and an in-memory regex pass, nothing is fetched, uploaded, logged or stored, and no page is crawled (there is deliberately no server proxy). That makes it safe to test STAGING, UNRELEASED or INTERNAL pages whose source you do not want to expose to a third-party service before launch — a meaningful advantage when auditing structured data for a site that is not yet public. The tool works offline once cached as a PWA, and closing the tab discards everything entered. It adds no new dependency: the JSON-LD logic lives in the small, reusable, well-typed engine schemaValidateEngine.ts shared with the sibling Schema Validator and rich-snippet tester, while the Microdata / RDFa detection is a tiny inline regex scan.

  • Page HTML is parsed locally and never uploaded — no server, no CDN, no crawl, no proxy
  • Safe for staging / unreleased / internal pages, unlike online testers
  • Works offline once cached; closing the tab discards your data
  • No new dependency — JSON-LD logic reuses schemaValidateEngine.ts; Microdata/RDFa via inline regex
  • Dark mode and mobile support with a sticky test / copy bar
Page-level structured-data testing: in-browser (AnyTool) vs online testers
CapabilityAnyToolTypical online testers
ProcessingRuns entirely in your browserSends your page / URL to a server
Your pageHTML never uploaded, works offlinePage or URL crawled server-side
Staging / unreleased pagesSafe — nothing leaves the deviceExposed to a third-party service
InputPaste your page HTML source (View Source)Often a URL the tool crawls
FormatsJSON-LD (parsed) + Microdata + RDFa (detected)Varies
Type inventoryEvery @type, format + rich-result eligibilityVaries
Per-block validationEach JSON-LD block: errors / warnings / infoVaries
HonestyClear it’s a tester — confirm in Rich Results TestOften implies it is authoritative
Cost / signupFree, no signupOften gated or ad-heavy

AnyTool tests a page’s structured data locally from pasted HTML and uploads nothing, which is safe for staging or unreleased pages. It fully parses JSON-LD and detects Microdata / RDFa presence; it is not the official Google Rich Results Test (rich-result eligibility) or the schema.org Schema Markup Validator at validator.schema.org (full vocabulary) — confirm there before relying on a rich result. Comparison as of June 2026.