When you receive an “unparsable structured data issues detected” warning in Google Search Console, don’t panic! It can actually be an easy fix if you know where to look.
The key to resolving these issues is to identify syntax errors in the JSON-LD and make necessary corrections. To tackle these errors, start with accessing the details page for the specific issue in Search Console’s Unparsable Structured Data Report .
Depending on the errors, correct the syntax by adding missing properties or using commas, quotes, parentheses, and brackets. Once you’ve fixed the errors, the next step is to use the Search Console’s “validate fix” option to ensure the corrections are recognized by Google.
In this article, let’s walk through some of the common parsing errors and how to fix structured data error.
What is unparsable structured data?
Unparsable structured data refers to structured data that search engines are unable to read or interpret due to errors in the syntax or structure of the code. This can prevent search engines from displaying rich results for your website, which can negatively impact its visibility in search rankings.
What are the common error types and how to fix them?
Understanding the types of errors that lead to unparsable structured data is the first step in fixing them. Let’s delve deeper into the most common issues:
1. Syntax errors
Syntax errors occur when the structured data code doesn’t follow the correct format. These errors are often caused by:
- Typos
- Missing or extra commas, brackets, or quotation marks
- Incorrect nesting of elements
To fix syntax errors, use tools like Google’s Rich Results Test or Schema Markup Validator to check your code. These tools catch syntax errors early and flag the specific lines of code where the issues occur.
When examining your code, here are a few things that I check:
- Missing Curly Brackets {}: Every opening curly brackets { must have a corresponding closing brace }. If the closing brace is missing, the object is considered incomplete.
- Missing Commas Between Key-Value Pairs: Each key-value pair inside an object must be separated by a comma.
- Key-Value Pair Syntax: Each key in a JSON object (also called a member name) must be enclosed in double quotes “, and it should be followed by a colon :, then the value (usually also enclosed in double quotes).
In our example, there is a missing comma (,) between datePublished and author.
2. Missing required properties
If you are using structured data for rich results on Google, you should read their structured data documentation carefully. Some structured data types require specific properties to enable rich results snippets – this may not be caught by Schema Markup Validator but only shows up in Google Rich Results Test.
For instance, a “ProfilePage” schema must include properties like mainEntity. Missing these can cause parsing errors.
{
"@context": "https://schema.org",
"@type": "ProfilePage",
"hasPart": [{
"@type": "Article",
"headline": "Things to see in NJ",
"url": "https://example.com/things-to-see-nj",
"datePublished": "2014-02-23T18:34:00Z",
"author": { "@id": "#main-author" }
}]
}If we put the above code in Schema.org validator and Rich Results Test, you will see that Schema.org doesn’t flag any error while Rich Results Test will catch the error.
To fix this error, you just need to add all the required properties in your schema markup.
3. Missing optional fields
Missing optional fields are just warnings rather than outright errors. Unlike a required property, recommended properties are nice-to-have information but not a must-have element. If your page doesn’t have that information, there is nothing to fix there.
For example, Google recommends using the review and aggregateRating properties in the Product schema. So if you don’t collect any customer reviews, then you can actually skip that field.
As seen from the Rich Results Test, the warning is displayed in yellow (instead of red like the previous example) with a green check mark. It means that the structured data is in fact valid.
4. Invalid property values
Invalid property values occur when data types don’t match the expected format. For example, inputting a string where a URL is required or using text when a number is expected.
In the following example, ratingValue should use a number – using a text will result in an error.
To correct this type of error, check what data type is expected and update your schema markup to match the data type.
5. Improper nesting of properties
Structured data follows a hierarchical structure, where certain properties must be nested within others. If you place a property in the wrong hierarchy, it may fail to be parsed.
Let’s take a look at an example:
In the above example, price and priceCurrency are meant to be nested within an Offer object, which is used to describe pricing details for products. Similarly, ratingValue and reviewCount should be nested under an AggregateRating object, which provides information about the product’s overall rating and reviews.
Without proper nesting, search engines may not properly interpret or display this data in rich results. Even though we include the price and review rating in the schema, if we don’t nest it in the relevant object, Google will not understand their relationship with the product.
To fix this, you need to identify the correct schema and information you’ll use and understand the relationships between different properties and their corresponding schema types.
Once you’ve clarified the proper relationships, structure your data hierarchically by nesting related properties within the correct parent objects. You can always test and validate your schema while building – so don’t be afraid to experiment around.
Conclusion
Structured data errors can appear over time as you add or update content on your website. By regularly validating your schema markup and staying up-to-date with schema changes, you can ensure that your structured data is always parsable and optimized for search engines.
If you need help tailoring it further or adding more technical details, feel free to ask!
