Schema Markup Audit: How to Find Structured Data Errors and Opportunities

Structured data can help search engines understand what a page is about, which entities it describes, and whether the page may be eligible for certain enhanced search appearances.

But schema markup is only useful when it is accurate.

A schema markup audit should do more than check whether JSON-LD exists on a page. It should identify:

• syntax errors
• missing required properties
• invalid property values
• markup that does not match visible content
• duplicate or conflicting entities
• outdated schema
• unsupported rich-result assumptions
• missing structured-data opportunities
• sitewide template problems

Google supports structured data in JSON-LD, Microdata, and RDFa, and recommends JSON-LD where possible. Correct markup can make a page eligible for supported search features, but Google does not guarantee that a rich result will appear even when the markup is valid.

Official reference: Google General Structured Data Guidelines

This guide explains how to audit structured data, how to use Google's Rich Results Test and Schema.org Validator correctly, and how to find both errors and legitimate schema opportunities.

What Is a Schema Markup Audit?

A schema markup audit is a review of the structured data implemented across a website.

The goal is to determine whether the markup:

1. Uses valid Schema.org vocabulary
2. Matches the visible content
3. Meets search-engine requirements where applicable
4. Uses appropriate types and properties
5. Avoids conflicting or misleading entities
6. Supports the site's actual content and business goals

A strong audit also checks for pages where structured data is missing even though a relevant schema type could improve machine understanding.

score = (business_value * ranking_gap) / implementation_effort

Schema.org vs Google Rich Results

This distinction is essential.

Schema.org provides a broad shared vocabulary for structured data.

Google Search supports only certain structured-data types for specific search features.

A schema type can therefore be valid according to Schema.org without necessarily creating a Google rich result.

Use different tools for these questions.

Rich Results Test vs Schema.org Validator

Google Rich Results Test

Google's Rich Results Test checks whether a page contains structured data that can be eligible for Google-supported rich results.

Use it to identify:

• Google-supported structured-data items
• critical errors
• non-critical warnings
• missing properties
• rendered structured data

Schema.org Validator

The Schema.org Validator focuses on Schema.org vocabulary and syntax.

It can extract and validate:

• JSON-LD
• Microdata
• RDFa

It can also identify syntax mistakes and unusual type/property combinations.

Official reference: Schema.org Markup Validator documentation

Why Schema Markup Audits Matter

Structured data is often implemented through:

• CMS plugins
• themes
• ecommerce platforms
• tag managers
• custom templates
• JavaScript
• SEO plugins
• manually written JSON-LD

That creates plenty of opportunities for errors.

Common examples include:

• every page marked as Article
• every page using the same canonical entity URL
• outdated prices in Product markup
• reviews marked up that are not visible
• incorrect LocalBusiness addresses
• duplicate Organization entities
• BreadcrumbList items pointing to redirects
• Article authors missing or inconsistent
• schema injected twice by separate plugins

Step 1: Inventory the Structured Data Across the Site

Start by determining which schema types are currently present.

A crawl can help extract:

• @type
• @id
• @context
• JSON-LD blocks
• Microdata
• RDFa

Build a simple inventory by template.

Step 2: Check for Invalid JSON-LD Syntax

JSON-LD is Google's recommended structured-data format where practical.

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Example Company",
  "url": "https://example.com/"
}

Common syntax errors include:

• missing commas
• unclosed braces
• invalid quotation marks
• malformed arrays
• broken URLs

Step 3: Check the @context

Schema.org markup commonly uses:

"@context": "https://schema.org"

Schema.org states that both HTTP and HTTPS forms remain understood, but HTTPS is preferred in current examples.

Official reference: Schema.org FAQ

Step 4: Check Whether the Schema Matches Visible Content

Google's structured-data guidelines say markup should represent the page's visible content and should not describe hidden or misleading information.

Do not mark up:

• a review that users cannot see
• a product price that is not shown
• an event that does not exist on the page
• a person who is not actually the author
• services the page does not describe

Official reference: Google General Structured Data Guidelines

Step 5: Check Required and Recommended Properties

Google-supported structured-data features have their own requirements.

The correct audit process is:

1. Identify the schema type
2. Check Schema.org validity
3. Check Google's documentation for that feature
4. Verify required properties
5. Review relevant recommended properties
6. Confirm the values match visible content

Step 6: Check for Duplicate Structured Data

Duplicate markup often appears when multiple systems inject schema.

Common duplicate problems include:

• different business names
• different logos
• inconsistent URLs
• different social profiles
• conflicting addresses
• duplicate Product entities
• duplicate Article entities

The problem is not simply more schema. The problem is inconsistency.

Step 7: Check Entity IDs and Relationships

JSON-LD becomes more useful when related entities are connected consistently.

For example:

"@id": "https://example.com/#organization"

An Article can reference that same entity as the publisher rather than creating an unrelated duplicate Organization.

Audit whether:

• the same organization uses the same @id
• author entities are reused consistently
• WebPage entities connect to the correct site
• Article markup references the right publisher
• Service entities belong to the correct provider

Step 8: Audit Organization Schema

Review fields such as:

• name
• url
• logo
• sameAs
• contactPoint

Official reference: Google Organization structured data

Step 9: Audit LocalBusiness Schema

Audit:

• business name
• address
• telephone
• URL
• opening hours
• geographic information
• business subtype
• parent organization relationships

Official reference: Google LocalBusiness structured data

For local SEO strategy beyond schema, see our Local SEO Services.

Step 10: Audit Article and BlogPosting Schema

Review:

• headline
• author
• publisher
• datePublished
• dateModified
• image
• canonical URL relationships

Official reference: Google Article structured data

Step 11: Audit BreadcrumbList Schema

Check:

• positions are sequential
• names are accurate
• URLs resolve correctly
• breadcrumb items do not point to broken pages
• visible navigation and structured data do not conflict

Official reference: Google Breadcrumb structured data

Step 12: Audit Product and Offer Schema

Review:

• product name
• image
• offers
• price
• currency
• availability
• SKU
• brand
• reviews and ratings

Official reference: Google Product structured data

Step 13: Audit Review and AggregateRating Markup

Check that:

• reviews are genuine
• review content is visible
• rating values are accurate
• the reviewed item is eligible
• markup follows Google's review guidelines

Official reference: Google Review Snippet structured data

Step 14: Check Structured Data Images

Google says structured-data image URLs should be crawlable and indexable.

Review whether image URLs:

• return 200 OK
• are not blocked
• use stable URLs
• are relevant to the page
• meet feature-specific requirements

Step 15: Check Crawlability and Indexability

Structured data cannot solve a page that search engines cannot properly access.

Review:

• robots.txt
• meta robots
• HTTP status
• canonical tags
• firewall rules
• rendering

For more detail, see:

• Robots.txt SEO Guide
• Crawlability vs Indexability

Step 16: Check JavaScript-Generated Structured Data

Structured data can be generated with JavaScript.

Test the rendered page using:

• Rich Results Test
• URL Inspection
• rendered HTML
• crawler rendering

Step 17: Review Search Console Enhancement Reports

Use Search Console structured-data reports to identify:

• valid items
• invalid items
• warnings
• affected URLs
• trends over time

Also review the Unparsable structured data report for syntax issues that prevent Google from understanding the markup.

Step 18: Check for Structured Data Manual Actions

Google can issue manual actions for structured-data abuse.

Review:

Google Search Console → Security & Manual Actions → Manual Actions

Potential problems include:

• misleading markup
• fake reviews
• content not visible to users
• irrelevant structured data
• spammy implementation

Step 19: Do Not Assume Valid Schema Guarantees Rich Results

Google explicitly says that valid structured data does not guarantee a rich result.

Eligibility can depend on:

• page quality
• search context
• user location
• device
• feature availability
• compliance with guidelines
• Google's algorithms

Step 20: Find Missing Structured Data Opportunities

Homepage

Possible entities may include:

• Organization
• WebSite
• WebPage

Service Pages

Depending on the page:

• Service
• WebPage
• BreadcrumbList
• provider references

Blog Posts

Common choices include:

• BlogPosting or Article
• BreadcrumbList
• Person or Organization references

Local Location Pages

Possible types include:

• LocalBusiness
• PostalAddress
• BreadcrumbList
• WebPage

Product Pages

Possible types include:

• Product
• Offer
• AggregateRating where legitimately applicable
• BreadcrumbList

Service Schema: Useful, but Understand Its Purpose

Service is a valid Schema.org type.

It can describe a service and connect that service to a provider.

However, you should not assume that Service schema automatically produces a special Google rich result.

This is a good example of the difference between semantic Schema.org markup and Google-supported rich-result markup.

FAQ Schema: Do Not Add It Just for Rich Results

Schema.org supports FAQPage, but Google has significantly limited FAQ rich-result visibility compared with earlier years.

Do not add FAQ schema simply because you expect extra SERP real estate.

If a page genuinely contains useful FAQs, the visible FAQ content can still be structured appropriately where it makes sense.

Common Schema Markup Errors

Missing Required Property

Follow the specific rich-result documentation.

Invalid Property Value

Use the expected value type.

Property Used on the Wrong Type

Check the type's Schema.org documentation.

Markup Does Not Match the Page

The structured data must describe visible content.

Duplicate Entities

Consolidate or connect conflicting entities appropriately.

Broken URLs

Audit logo, image, canonical, and profile URLs.

Incorrect Dates

Check date-sensitive markup carefully.

Fake Review Markup

Never create ratings that users did not provide.

Warnings vs Errors

Do not treat every warning as a critical emergency.

In Google's Rich Results Test:

• Errors can make an item ineligible for the specific rich result.
• Warnings often indicate recommended properties that are not mandatory.

Prioritize issues based on:

• page importance
• number of affected URLs
• rich-result eligibility
• user value
• implementation effort

Structured Data Audit Checklist

Technical Validation

• Does the JSON-LD parse?
• Is @context correct?
• Are types valid?
• Are properties valid?
• Are required Google properties present?
• Are important recommended properties missing?

Content Accuracy

• Does markup match visible content?
• Are prices accurate?
• Are availability values accurate?
• Are reviews real and visible?
• Are addresses current?
• Are authors correct?
• Are dates accurate?

Entity Consistency

• Are Organization IDs consistent?
• Are Person IDs consistent?
• Are duplicate entities present?
• Are page entities connected correctly?
• Are publisher/provider relationships correct?

URLs

• Do schema URLs return 200 OK?
• Are image URLs crawlable?
• Are canonical URLs correct?
• Are logo URLs current?
• Are sameAs profiles accurate?

Search Eligibility

• Is the page crawlable?
• Is the page indexable?
• Does it meet feature-specific guidelines?
• Does Rich Results Test detect the expected item?
• Does Search Console report errors?

Opportunities

• Is Organization schema missing?
• Are Breadcrumbs missing?
• Are Article pages missing Article/BlogPosting?
• Are legitimate LocalBusiness pages missing local markup?
• Are Product pages missing Product data?
• Could important service pages use accurate Service markup?

How to Prioritize Schema Fixes

High Priority

Fix first when:

• markup is completely unparsable
• important pages have critical rich-result errors
• schema contains materially false information
• a manual action exists
• large templates generate conflicting data
• product price or availability is wrong

Medium Priority

Address next when:

• recommended properties are missing
• entity relationships are inconsistent
• page templates use overly generic schema
• breadcrumbs contain outdated URLs

Opportunity

Consider when:

• important page types have no structured data
• entity relationships could be clearer
• Organization or author identities are inconsistent
• content supports a legitimate additional schema type

Schema Markup and AI Search

Structured data can provide machine-readable information about:

• organizations
• people
• products
• services
• articles
• locations
• relationships between entities

That can support clearer machine understanding.

However, adding schema does not guarantee:

• ChatGPT mentions
• AI Overview inclusion
• Google AI Mode citations
• Perplexity citations
• better rankings

If you are measuring whether your brand appears across AI search, see our AI Visibility Checker guide.

For crawler access, see our AI Crawler Access guide.

Schema Markup Audit Workflow

A practical workflow looks like this:

1. Crawl the site
2. Extract structured data
3. Group pages by template
4. Identify schema types
5. Test representative URLs
6. Validate Schema.org syntax
7. Test Google rich-result eligibility
8. Compare markup with visible content
9. Review required properties
10. Check entity IDs and relationships
11. Review Search Console enhancement reports
12. Check manual actions
13. Identify missing opportunities
14. Fix templates rather than isolated URLs where possible
15. Re-test after deployment

How RankForge Approaches Structured Data Audits

RankForge treats structured data as part of a broader technical and semantic SEO system.

We connect:

Crawlability → Indexability → Page Meaning → Entity Relationships → Structured Data → Search Eligibility

That prevents schema work from becoming an isolated checklist exercise.

Our Technical SEO Services include structured-data diagnostics alongside crawlability, indexation, rendering, canonicalization, internal linking, and other technical search issues.

FAQ

What is a schema markup audit?

A schema markup audit reviews structured data across a website to find syntax errors, missing properties, inaccurate values, duplicate entities, Google rich-result issues, and legitimate opportunities for additional structured data.

What tool should I use to test schema markup?

Use Google's Rich Results Test for Google-supported rich-result eligibility and the Schema.org Validator for broader Schema.org syntax, types, and properties.

Does valid schema markup guarantee rich results?

No. Google explicitly states that valid structured data can make a page eligible for a rich result but does not guarantee that the feature will appear.

Is JSON-LD better for SEO?

Google supports JSON-LD, Microdata, and RDFa and recommends JSON-LD where possible. Accuracy and compliance matter more than the format alone.

Should every page have schema markup?

No. Add structured data when it accurately describes meaningful content or entities on the page.

Can schema markup improve AI visibility?

Structured data can provide machine-readable entity and content information, but it does not guarantee citations, mentions, rankings, or visibility in AI search systems.

Final Thoughts

A good schema markup audit should answer more than:

"Does the page pass a validator?"

The real questions are:

• Is the markup accurate?
• Does it describe the visible content?
• Are the types and properties appropriate?
• Does it meet Google's requirements where rich results are expected?
• Are entity relationships consistent?
• Are duplicate plugins creating conflicts?
• Are there important pages missing useful structured data?
• Is the underlying page crawlable and indexable?

Structured data works best when it reflects a strong website rather than trying to compensate for a weak one.

If your website has structured-data errors, inconsistent entity markup, missing schema opportunities, or Search Console enhancement issues, explore RankForge's Technical SEO Services or contact RankForge Agency to discuss a structured SEO audit.