Structured data errors are problems with syntax, properties, page access, or Google's content guidelines. The fix usually takes four steps: identify the error, correct the markup or template, test the live URL, and validate the change in Search Console. A date such as 2026-09-20T10:30:00-04:00 must also use the format expected by its property.

Google recommends JSON-LD when possible because it is easier to implement and maintain than Microdata or RDFa.

Structured Data Errors at a Glance

Error type What it means Typical fix
Unparsable structured data Google cannot read the markup Fix invalid JSON, HTML, or JavaScript
Missing required field A required property is absent Add the property or remove unsupported markup
Invalid value A property uses the wrong format or data type Correct the date, URL, number, text, or object
Invalid object type A property uses an incompatible Schema.org type Use the correct nested type
Content mismatch Markup describes information users cannot see Make the page content and markup consistent
Page inaccessible Google cannot crawl or render the markup Check robots.txt, noindex, login restrictions, and JavaScript
Warning Recommended data is missing Add the property when it genuinely applies
Manual action Google considers the markup misleading or spammy Remove the violation and request reconsideration

1. How Do You Find the Exact Structured Data Error?

Use the tool that matches the problem:

  • Rich Results Test: Checks whether Google can generate a specific rich result.
  • Schema Markup Validator: Checks general Schema.org markup, including JSON-LD, Microdata, and RDFa.
  • Google Search Console: Shows errors affecting indexed pages and site templates.
  • URL Inspection: Shows how Google crawls and renders a specific URL.

The Rich Results Test checks eligibility for Google Search features. The Schema Markup Validator is more suitable for Schema.org markup that is not tied to a particular Google feature.

Test a Live URL, Not Just Copied Code

When JavaScript generates the markup, test the live URL whenever possible. A code-only test may miss problems caused by:

  • JavaScript failing to execute
  • A CMS template removing the markup
  • Incorrect template variables
  • Blocked resources
  • Different markup being served to Googlebot
  • Data that appears only after user interaction

Google recommends using the URL input in the Rich Results Test for JavaScript-generated structured data. It gives a better view of what Google can process on the page.

2. How Do You Fix Unparsable Structured Data?

An "unparsable structured data" error means Google could not interpret the markup well enough to identify the intended structured data type. Common causes include invalid JSON syntax, malformed HTML, and broken JavaScript output. Search Console groups these parsing problems separately because Google cannot reliably assign them to a specific rich result type.

Check JSON-LD Syntax

Common JSON-LD mistakes include:

  • Missing commas between properties
  • Extra commas before a closing brace or bracket
  • Curly quotes instead of straight quotes
  • Unclosed {} or []
  • Unescaped quotation marks inside text
  • Incorrect nesting
  • Comments inside JSON
  • A missing @context
  • A missing @type

Incorrect:

{
  "@context": ""@type": "Article",
  "headline": "How to fix structured data errors"
  "author": {
    "@type": "Person",
    "name": "Example Author"
  }
}

The comma after the headline value is missing.

Correct:

{
  "@context": ""@type": "Article",
  "headline": "How to fix structured data errors",
  "author": {
    "@type": "Person",
    "name": "Example Author"
  }
}

Do not add comments such as // fix this later inside JSON. JSON does not support comments.

Check the Rendered Source

If JavaScript adds the markup, inspect the rendered HTML rather than only the original page source. The JSON-LD must be present in the HTML Google can render and process.

If JavaScript produces empty values such as "name": "" or invalid output such as "price": "$19.99 USD" where a number is expected, fix the data-generation logic instead of editing each page manually.

3. How Do You Fix Missing Required Fields?

A missing required field prevents the structured data item from qualifying for the related Google rich result. The required properties depend on the structured data type.

Examples include:

  • Product markup missing name
  • Recipe markup missing image
  • Event markup missing startDate
  • VideoObject markup missing thumbnailUrl
  • Article markup missing a property required by the applicable feature documentation

Check Google's documentation for the exact structured data type. Add the required property using accurate information from the page. Required properties are feature-specific, so no single list applies to every Schema.org type.

Do Not Invent Missing Information

If the page does not contain a required property, choose one of these options:

  1. Add the information visibly to the page and include it in the markup.
  2. Change the structured data to a more accurate type.
  3. Remove the structured data if the page does not qualify.

Do not create a fake review, ratingValue, price, salary, or eventStatus just to remove an error. Structured data must represent the visible page accurately.

4. How Do You Fix Invalid Values and Data Types?

Each structured data property must use the format expected by its definition.

Typical problems include:

  • An invalid date format
  • A price containing currency symbols when a number is required
  • A URL containing spaces
  • A number entered as descriptive text
  • Plain text used where an object is required
  • A single value used where an array is expected
  • An invalid enumeration value

For example, use an ISO 8601 date for uploadDate:

"uploadDate": "2026-09-20T10:30:00-04:00"

Use a price with a separate currency value:

"price": "49.99",
"priceCurrency": "USD"

Use a nested object when the property requires one:

"author": {
  "@type": "Person",
  "name": "Example Author"
}

Google's structured data documentation defines the expected property types for each feature. Follow that documentation rather than relying only on the wider Schema.org vocabulary. Google Search may use only some Schema.org properties for a particular search feature.

5. How Do You Fix Invalid Object Type Errors?

An invalid object type usually means that a nested property uses the wrong Schema.org type.

For example, an author property may need a Person or Organization object. An image property may need an ImageObject, URL, or image array, depending on the feature.

Check three parts of the markup:

  1. Parent property: Identify the property generating the error.
  2. Expected type: Confirm whether it requires text, a URL, a number, a date, or another Schema.org object.
  3. Nested object: Check that the nested object uses a compatible @type.

Search Console may show the property path or parent object. An error such as Missing field "name" (in "author") identifies where the problem occurs.

6. How Do You Fix Content Mismatches?

Structured data must describe content that is visible and relevant on the page. Google may ignore correctly formatted markup if it describes information users cannot see or if the markup is misleading.

Check for mismatches such as:

  • A product price in the markup that is not displayed on the page
  • A rating that is not based on visible reviews
  • An event that has been cancelled or removed
  • A page marked up as a recipe even though it does not contain a recipe
  • FAQ markup for questions that are not visible on the page
  • An organization name, address, or logo that does not represent the page
  • Hidden or off-screen text added only for search engines

Structured data should be the machine-readable version of the page, not a separate set of claims created to influence search results.

7. How Do You Check Whether Google Can Access the Page?

Valid markup cannot produce a rich result if Google cannot crawl or render the page.

Check that:

  • robots.txt does not block the page.
  • The page does not contain a noindex directive.
  • The page does not require a login.
  • The canonical URL points to the intended page.
  • The JSON-LD is returned in the page or rendered successfully.
  • Images used in the markup are crawlable and indexable.
  • Important JavaScript and CSS resources are accessible.
  • The server returns a successful HTTP response.

Google advises checking access, robots.txt, noindex, and login requirements before requesting a recrawl.

Use the URL Inspection tool in Search Console to compare the live URL with the version Google has indexed. A page may be fixed but still show an old error until Google crawls the updated version.

8. How Do You Fix Structured Data Generated by a CMS or Plugin?

WordPress, Shopify, Wix, and other content management systems can generate structured data automatically. Problems often appear when a theme and one or more plugins output overlapping markup.

Look for:

  • Two different Product objects on the same product page
  • A theme and SEO plugin both generating Organization markup
  • Old markup left behind after a plugin change
  • Product price or availability values that are no longer current
  • A plugin using an outdated Schema.org type
  • Site-wide templates adding article markup to non-article pages
  • Empty properties generated for fields that are not populated

CMS Cleanup Process

  1. Disable or isolate one structured data source at a time.
  2. Inspect the rendered HTML after each change.
  3. Keep the most complete and accurate implementation.
  4. Remove duplicate or conflicting markup.
  5. Test a representative page from each template.
  6. Test variations such as products without reviews, articles without authors, and events without ticket information.

Do not remove valid markup simply because several structured data items appear on one page. Remove markup only when it is duplicated, inaccurate, irrelevant, or conflicting.

9. How Do You Fix JavaScript-Generated Structured Data?

JavaScript-generated markup can work, but it creates more points of failure. Test the rendered URL and check for JavaScript errors when the markup is added dynamically.

Check whether:

  • The script runs before the page is rendered.
  • The API request succeeds.
  • The API response contains complete data.
  • The JSON-LD script is inserted into the document.
  • The data is available without a click, scroll, or other user action.
  • Googlebot can access the API endpoint.
  • The server can handle Google's crawl requests.

For fast-changing product information such as price and availability, server-side rendering or including the data in the initial HTML may be more reliable than relying entirely on client-side JavaScript.

10. What Is the Difference Between a Warning and an Error?

A critical error usually means the item is not eligible for the related rich result until the problem is fixed.

A warning usually means a recommended property is missing. It may not prevent eligibility, but adding the property can make the markup more complete.

Google recommends using fewer complete and accurate properties instead of adding every possible property with incomplete or inaccurate information.

Prioritise fixes in this order:

  1. Parsing and syntax errors
  2. Missing required properties
  3. Invalid values and object types
  4. Crawlability and rendering problems
  5. Content mismatches
  6. Recommended-property warnings

11. How Do You Validate a Structured Data Fix?

After correcting the markup:

  1. Test the live URL in the Rich Results Test.
  2. Confirm that the required structured data type is detected.
  3. Inspect the URL in Google Search Console.
  4. Review the enhancements detected for that URL.
  5. Return to the relevant Search Console report.
  6. Select Validate Fix if the option is available.
  7. Monitor the report while Google processes the affected pages.

Search Console can reprocess affected pages after a validation request, but crawling and indexing take time. Successful validation does not guarantee that a rich result will appear for every search.

Why Structured Data Can Be Valid but Still Not Appear in Google

Passing the Rich Results Test means the markup is technically eligible for a Google search feature. It does not guarantee that Google will display the feature.

Google may choose not to show a rich result when:

  • The page does not meet the quality guidelines.
  • The markup does not accurately represent the page.
  • The content is hidden or misleading.
  • The page is not indexed.
  • The search query does not warrant the feature.
  • Google selects a different search presentation.
  • The markup is valid but incomplete in context.

Structured data can help Google understand page content, but it does not guarantee rankings or an enhanced search appearance.

Practical Troubleshooting Checklist

Before closing the issue, confirm that:

  • The markup uses valid JSON-LD, Microdata, or RDFa.
  • The correct @context and @type are present.
  • All required properties are included.
  • Property values use the correct format.
  • Nested objects use compatible types.
  • The markup describes visible page content.
  • The page is crawlable and indexable.
  • Images and URLs are accessible.
  • JavaScript-generated markup appears in the rendered page.
  • Duplicate plugin or theme markup has been removed.
  • The live URL passes the Rich Results Test.
  • Search Console has been asked to validate the fix.
  • The page has had time to be recrawled and reprocessed.

Fix structured data at the source. Use the Rich Results Test for Google eligibility, the Schema Markup Validator for general Schema.org validation, and Search Console to monitor indexed pages. The implementation should be complete, accurate, crawlable, and consistent with what users can see.