A JSON-LD schema markup audit helps you find broken syntax, incomplete properties, mismatched page details, and implementation problems before they become recurring technical SEO issues. This checklist explains how to test JSON-LD structured data, review common schema types, separate syntax errors from eligibility warnings, and build a repeatable validation workflow for individual pages or entire sites.
Overview
JSON-LD is a structured format used to describe the meaning of page content to machines. It is commonly placed in a <script type="application/ld+json"> element, usually in the document head or body. The markup can describe an article, product, organization, breadcrumb trail, local business, or another entity defined by Schema.org.
A schema markup audit should answer four separate questions:
- Is the JSON valid? Brackets, quotation marks, commas, and values must form valid JSON.
- Is the vocabulary valid? Types and properties should use the correct Schema.org names and structure.
- Is the markup eligible for the intended search feature? A valid Schema.org property is not automatically a requirement for every search enhancement.
- Does the markup accurately describe the visible page? Structured data should not claim information that visitors cannot reasonably verify.
Keep these questions distinct when reviewing errors. A JSON parser error prevents the block from being read. A missing recommended property may produce a warning without invalidating the entire item. A page-to-schema conflict is a content and implementation problem even when the code passes a syntax test.
For larger sites, treat structured data as a technical SEO asset that belongs in templates, deployment checks, and recurring crawls. A useful audit records the URL, detected schema types, validation messages, affected properties, page template, and the status of each fix.
Checklist by scenario
1. Auditing one page manually
- Open the rendered page and confirm which content the markup is intended to describe.
- View the source or rendered HTML and locate every JSON-LD script block.
- Copy each block into a JSON-aware editor or formatter to check indentation and syntax.
- Run the code through a structured data testing tool appropriate to the search feature you are evaluating.
- Compare the reported entity with the page title, headings, visible facts, images, prices, dates, author information, and canonical URL.
- Record errors separately from warnings and decide which issues are caused by the template, CMS data, or one-off content.
2. Checking a new Article template
Start with the fields your publishing system can populate reliably. Review the headline, description, author, publisher, image, publication date, modification date, and main entity relationship. Dates should use a consistent machine-readable format, while the displayed page should support the information represented in the markup.
Check several real articles rather than only the template preview. Include a page with a single author, multiple authors if supported, no featured image, an updated date, and an unusual headline. Template logic often fails at the edges even when the standard example looks correct.
3. Reviewing Product markup
Confirm that the product name, description, image, brand, identifiers, offers, availability, and review information describe the same item shown on the page. Check that an offer is not accidentally inherited from a different product variation or category page. If the page represents several variants, review whether the structured data models the parent product, a selected variant, or a collection of products.
Do not add review or rating properties simply to complete a template. The markup should reflect genuine, visible page content and the way the site actually presents that content.
4. Auditing LocalBusiness or Organization markup
Verify the entity name, URL, logo, contact details, location, and identifiers against the page and the site’s authoritative business information. Use the most specific applicable type only when the page supports that description. A location page, corporate about page, and individual service page may need different entity relationships.
5. Checking BreadcrumbList and connected entities
Make sure each breadcrumb position is unique and ordered correctly. The final breadcrumb should represent the current page, and its URL should align with the page’s canonical URL where a URL is supplied. For sites using multiple entity blocks, inspect relationships such as mainEntity, about, author, publisher, and isPartOf so they point to the intended entities rather than duplicated anonymous objects.
6. Auditing many pages
Use a crawler or a controlled extraction script to collect JSON-LD blocks across representative URL groups. Store the raw block, parsed type, page status, canonical URL, and validation result. Group findings by template and error message instead of treating every affected URL as a separate defect.
This approach fits alongside a broader technical SEO crawling workflow. If you are building an automated checker, add fixtures for valid pages, missing fields, malformed JSON, duplicate entities, and pages with no structured data. The testing practices in this guide to web scraper tests can also help organize repeatable HTML and JSON-LD checks.
What to double-check
| Schema type or area | Audit focus | Typical failure to investigate |
|---|---|---|
| Article | Headline, author, publisher, image, and dates | Markup describes an old date or an author not shown on the page |
| Product | Product identity, offer details, availability, and reviews | Price, stock status, or review data belongs to another variant |
| LocalBusiness | Name, location, contact details, and page purpose | Corporate details are copied onto an unrelated location page |
| FAQPage | Questions and answers visible on the page | Hidden, incomplete, or promotional text is represented as an answer |
| BreadcrumbList | Order, positions, labels, and URLs | Breadcrumb URLs do not match the site hierarchy or canonical page |
| Organization | Name, logo, URL, and entity consistency | Multiple conflicting organization objects appear sitewide |
Validate the rendered result. A page source check may miss data injected by JavaScript, while a raw-source check may reveal markup that is later removed or changed. When the implementation depends on client-side rendering, compare source HTML, rendered DOM, and what the validation tool can actually access.
Review canonical alignment. The URL in an entity, breadcrumb, or page relationship should not quietly point to an alternate protocol, host, parameterized URL, or redirected page unless that behavior is intentional and documented.
Look for duplicates. Multiple JSON-LD blocks are not automatically wrong, but duplicate Organization, Article, or Product objects can make maintenance difficult and create contradictory values. Prefer a clear graph with stable identifiers where the implementation calls for connected entities.
Check values, not only property names. A property can be spelled correctly while containing the wrong data type, an empty string, an invalid URL, a stale date, or a value that does not match the visible page. Use a JSON formatter or similar developer utility to inspect nested objects before diagnosing higher-level schema warnings.
Separate Schema.org validity from search-feature support. A property may be accepted by the vocabulary but not used for a particular search enhancement. Evaluate the relevant structured-data documentation and testing output for the feature being targeted, then avoid adding fields solely because they appear in an unrelated example.
Common mistakes
- Copying a sample without adapting it. Replace example names, URLs, dates, images, and identifiers with values supported by the actual page.
- Putting JSON comments in the block. Standard JSON does not support comments. Use an external note or version-controlled template documentation instead.
- Leaving empty properties everywhere. Empty strings, placeholder URLs, and null-heavy objects make audits harder and may create misleading output. Omit a property when the site cannot provide a meaningful value.
- Confusing warnings with failures. Prioritize parser errors, invalid required values, and page conflicts first. Then assess optional fields based on their usefulness and maintenance cost.
- Marking up hidden or unrelated content. Structured data should represent the page, not an imaginary version of it created for crawlers.
- Auditing only the homepage. The highest-risk defects often appear in product variants, paginated pages, older posts, location pages, or templates with missing CMS fields.
- Fixing the output but not the source. If a CMS plugin, component, or data feed creates the error, a manual page edit will not prevent it from returning.
- Ignoring other technical signals. Structured data cannot compensate for a wrong canonical, blocked page, failed render, or incorrect status code. Combine this audit with metadata and crawl checks, such as the workflow described in the Open Graph and social metadata audit guide.
When to revisit
Revisit a JSON-LD audit before a major seasonal publishing cycle, after a CMS or theme migration, when a new schema type is introduced, and whenever templates or structured data plugins change. Also review it after changing canonical rules, product feeds, author profiles, location data, or the way dates and images are stored.
For an ongoing process, maintain a small regression checklist:
- Select representative URLs for every important page template.
- Capture the expected schema types and critical properties for each template.
- Run validation after deployments and record new errors separately from accepted warnings.
- Compare canonical URLs, rendered content, and entity identifiers with the previous crawl.
- Recheck previously fixed issues after releases rather than assuming the fix survived.
- Review guidance and supported search features periodically because validation requirements and search presentation can change.
Keep a dated audit log with the affected template, example URL, error message, owner, fix, and verification result. When a warning returns, that history helps you determine whether the cause is a deployment regression, a changed data feed, or a legitimate content variation. A structured data audit is most useful when it becomes part of the site’s normal technical SEO and quality-assurance workflow—not a one-time cleanup performed only after a visible search issue.