Reliable structured-data extraction starts with understanding how JSON-LD, Open Graph, Microdata, and RDFa represent the same page in different ways. This guide compares those formats, shows what to track during recurring audits, and provides a practical workflow for extracting, normalizing, validating, and monitoring records without treating one markup format as universally complete.
Overview
A modern page may describe a product, article, organization, event, or breadcrumb trail in more than one place. JSON-LD commonly appears inside <script type="application/ld+json"> elements. Open Graph values are usually stored in <meta> tags, while Microdata and RDFa attach attributes directly to visible or semantically related HTML elements.
These formats overlap, but they are not interchangeable. JSON-LD is often the easiest format to parse as a structured object. Open Graph is useful for page-level sharing metadata such as a title, image, URL, and description. Microdata and RDFa can connect individual values to the elements that display them, but their structures may be more difficult to traverse consistently.
The safest approach is to collect all available representations, map them into a common internal model, and preserve the original values and source format. Do not silently choose whichever value appears first. Record where each field came from so that conflicting metadata can be reviewed later.
For larger audits, combine structured-data extraction with related technical SEO checks. A crawler that captures canonical URLs, status codes, and meta tags can provide useful context when a schema value is missing or attached to the wrong page. See the guide to technical SEO data extraction for a broader page-audit workflow.
What to track
Compare the main formats
| Format | Where to find it | Useful fields | Common extraction concern |
|---|---|---|---|
| JSON-LD | script[type="application/ld+json"] | Schema type, name, URL, image, author, offers, dates, relationships | Multiple blocks, arrays, nested objects, malformed JSON, or values rendered after page load |
| Open Graph | meta[property="og:..."] | Title, description, URL, image, type, site name, locale | Repeated properties, image dimensions, missing values, or conflicting URL variants |
| Microdata | itemscope, itemtype, and itemprop | Entity type and property values attached to page elements | Nested scopes, value selection rules, and visible text that differs from an attribute value |
| RDFa | vocab, typeof, property, and related attributes | Entity relationships and typed properties | Context-dependent parsing and less predictable HTML structures |
Build a field map before writing a scraper
Define the normalized record first. For an article, the model might include url, canonical_url, title, description, image_urls, author, date_published, date_modified, and schema_types. For a product, add fields such as brand, sku, price, currency, and availability.
Keep three layers in the output:
- Normalized values: the fields your downstream process uses.
- Provenance: the source format, selector, schema type, and extraction timestamp.
- Raw evidence: the original JSON-LD object or relevant HTML fragment when practical.
This separation makes it possible to improve parsing rules without losing evidence from earlier crawls. It also helps distinguish a genuine content change from a change in your extraction code.
Capture schema type and relationships
Do not store only a flat list of property names. Record the type associated with each object and retain nested relationships such as an article's author, a product's offer, or an organization's contact point. A JSON-LD block may contain an array of objects, an object with an @graph property, or references using an @id. Your parser should handle each shape rather than assuming that the first object is the page's primary entity.
Cadence and checkpoints
A recurring extraction job is most useful when it measures stable variables instead of collecting an ever-growing archive without a review process. A monthly or quarterly cadence is a reasonable starting point for many content and catalog audits, but high-change pages may require more frequent checks.
At every crawl
- Save the final URL, HTTP status, retrieval time, and response or rendered-page context.
- Count JSON-LD blocks and record whether each block parses successfully.
- Capture Open Graph properties, including repeated values such as multiple images.
- Identify Microdata and RDFa scopes and record their types and property names.
- Store normalized values together with their source format and selector or path.
- Flag missing required fields for the record type used by your project.
At a monthly or quarterly review
Compare field coverage, parse-error rates, duplicate entities, and conflicts between formats. Review a sample of changed pages in a browser, because an automated diff can identify a change but cannot always explain whether it is intentional. A redesign, template migration, CMS update, or JavaScript change may alter markup without changing the visible page—or may change the visible page while leaving stale metadata behind.
For a site-wide project, group results by template, directory, schema type, and status code. A sudden increase in missing product prices across one template points to a different cause than isolated omissions on a handful of pages. XML sitemap coverage can also help you decide whether the crawl is sampling the intended URL set; use the XML sitemap extraction and audit workflow as a companion check.
How to interpret changes
Not every difference is an error. First classify the change as a content change, markup change, extraction change, or access change.
- Content change: the visible title, price, author, or date changed and the structured value changed with it.
- Markup change: the same information moved from Microdata to JSON-LD, or a property was renamed or nested differently.
- Extraction change: your selector, parser, browser mode, or normalization rule changed.
- Access change: the crawler received a redirect, error page, consent screen, challenge page, or incomplete client-rendered response.
When formats disagree, apply an explicit precedence policy rather than a hidden one. For example, you might use a page's canonical URL as a consistency reference, treat a successfully parsed JSON-LD entity as the primary candidate, and retain Open Graph and visible HTML values for comparison. That is an operational choice, not a universal rule. The correct policy depends on whether your goal is catalog ingestion, technical SEO auditing, social-preview monitoring, or research.
Validate relationships as well as individual fields. A product price without a currency, an article date that cannot be parsed, or an image URL that resolves to a non-image response should be flagged for review. Keep warnings separate from hard failures so that one incomplete optional property does not discard an otherwise useful record.
For pages that require authentication or session state, make the access conditions part of the crawl record. Cookies, CSRF tokens, and session handling can affect which markup is returned; the related guide on scraping login-protected websites covers those concerns in more detail.
When to revisit
Revisit this extraction workflow on a monthly or quarterly schedule, and immediately after a website redesign, CMS migration, template change, schema implementation, or major change to your rendering pipeline. Also review it when parse failures rise, normalized-field coverage falls, or duplicate and conflicting values appear in a previously stable template.
A practical maintenance checklist
- Choose a representative sample of pages for each important template and Schema.org type.
- Run the extractor and save raw markup, normalized records, provenance, and validation results.
- Compare the current run with the previous baseline for field coverage, types, values, and parse errors.
- Inspect changed pages in a browser and determine whether each change is intentional.
- Update selectors, JSON-LD traversal rules, normalization logic, and tests where needed.
- Re-run the sample before applying changes to the full crawl.
- Record the review date, affected templates, decision, and next checkpoint.
Keep the extractor modular: use separate collectors for JSON-LD, Open Graph, Microdata, and RDFa, followed by a shared normalization and validation layer. This makes future maintenance less risky and lets you compare formats instead of discarding useful evidence. For broader change monitoring, pair structured-data snapshots with content diffing and website-change detection. The result is a repeatable technical SEO and web data intelligence process that can identify missing, stale, or conflicting metadata before it affects downstream analysis.