Google Changed How It Reads JSON-LD: What Brands Need to Fix in Their Structured Data
Summarize with AI
Opens your chosen AI platform in a new tab. Sign-in may be required; article access and summaries vary by platform.

Key Insights
- Google Search Central has changed its JSON-LD extraction process to apply only one pass of HTML unescaping, bringing its parser closer to JSON and other established standards. Double-escaped entities such as & or ✔ will no longer be decoded repeatedly until they reach the underlying character. This is not a core update, spam update or ranking penalty; it is a parsing change. Sites whose CMS, themes, plugins, product feeds or custom schema generators encode the same character multiple times may find that Google extracts values that differ from what was intended. The main risk is incorrect interpretation of structured data and reduced eligibility for specific rich-result experiences, not automatic ranking loss. Ecommerce sites, CMS plugin users, custom schema generators and large dynamic sites with multiple tools writing schema should audit first. The recommended fix is to generate standards-compliant JSON-LD using normal JSON strings or Unicode escapes such as \u0026 rather than relying on repeated HTML entity decoding. Teams should inspect the final rendered JSON-LD, test representative URLs across every important template with the Rich Results Test and Schema Markup Validator, fix the generation layer rather than individual URLs, and validate again after deployment. The broader lesson is that search engines are becoming less forgiving of messy machine-readable data, and machine interpretability is now a core part of digital visibility.
Google has made a small but important technical change to the way it reads JSON-LD structured data.
For most websites with correctly implemented structured data, nothing needs to change.
But websites whose CMS, plugins, themes or custom schema generators produce double-escaped characters should pay attention.
Google Search Central announced that it has changed its JSON-LD extraction process to apply only one pass of HTML unescaping, bringing its parser closer to JSON and other established standards. As a result, double-escaped entities such as `&` or `✔` will no longer be repeatedly decoded until they reach the underlying character.
This is not a Google core update, spam update or new ranking penalty.
It is a parsing change.
But if your structured data relies on Google's previous forgiving behaviour, the information Google extracts from your markup may no longer be exactly what you intended.
And that makes this worth auditing.
What exactly did Google change?
Structured data allows websites to describe their content in a machine-readable format.
A product page, for example, can tell Google explicitly:
- the product name
- brand
- price
- availability
- rating
- review information
An article can identify its:
- headline
- author
- publication date
- modification date
- publisher
And an organisation can define information such as its name, URL and logo.
Google supports JSON-LD, Microdata and RDFa for structured data and recommends JSON-LD as one of its supported formats.
A JSON-LD implementation might look like this:
```html
{
"@context": "https://schema.org",
"@type": "Organization",
"name": "Smith & Sons",
"url": "https://example.com"
}
```
The problem occurs when systems responsible for generating the markup unnecessarily encode the same character multiple times.
Instead of:
```text
Smith & Sons
```
a site's underlying JSON-LD might contain:
```text
Smith & Sons
```
Historically, Google's extraction process could effectively unwind multiple levels of escaping.
With the new behaviour, Google performs only one HTML-unescaping pass.
So:
```text
Smith & Sons
```
may become:
```text
Smith & Sons
```
and stop there — instead of ultimately becoming:
```text
Smith & Sons
```
That is the important difference.
Why does double escaping happen?
In many cases, nobody intentionally writes JSON-LD this way.
It happens because modern websites often pass information through several layers before the final HTML reaches a browser or crawler.
Imagine a product name:
```text
Health & Wellness Kit
```
The CMS stores the value.
One part of the application escapes it for HTML:
```text
Health & Wellness Kit
```
Then another template, plugin or rendering layer processes the same value and escapes it again:
```text
Health & Wellness Kit
```
The result is double escaping.
This can occur when structured data is generated dynamically through:
- ecommerce platforms
- CMS templates
- third-party SEO plugins
- schema plugins
- product feeds
- custom JavaScript
- server-side rendering systems
- templating frameworks
- custom-built schema generators
The risk therefore becomes greater on large websites where structured data is generated programmatically across thousands or millions of URLs.
What should developers use instead?
Google recommends moving away from implementations that depend on repeated HTML unescaping and using standard JSON escaping or Unicode hexadecimal escapes instead.
JSON's standard itself allows Unicode characters to be represented directly or through Unicode escape sequences such as `\uXXXX`.
For example, an ampersand can simply exist as an ampersand inside a normal JSON string:
```json
{
"name": "Health & Wellness"
}
```
Or it can be represented using a Unicode hexadecimal escape:
```json
{
"name": "Health \u0026 Wellness"
}
```
What implementations should avoid is relying on multiple rounds of HTML entity decoding to arrive at the intended value.
For example:
```text
Health & Wellness
```
should not be the mechanism through which the final JSON-LD value becomes:
```text
Health & Wellness
```
The important principle is simple:
Generate standards-compliant JSON-LD rather than depending on Google's parser to correct the output.
If you are rebuilding your schema layer, it is worth aligning it with how entities and knowledge graphs are read by machines. Our guide to schema, entities and knowledge graphs covers that foundation in detail.
Is this a Google ranking update?
No.
There is currently no indication from Google's announcement that this is a new ranking algorithm, ranking signal or penalty.
That distinction matters.
Structured data can make pages eligible for specific search experiences and rich results, but Google explicitly states that correctly implemented structured data does not guarantee that a rich result will appear.
Google also clarifies that structured-data-related manual actions affect a page's eligibility for rich results rather than its ranking in normal Google web search.
Therefore, headlines suggesting:
"Google's JSON-LD Update Could Crash Your Rankings"
would overstate what Google has announced.
A more accurate interpretation is:
> Google has become stricter about how it parses certain structured-data values. Websites relying on incorrectly or unnecessarily double-escaped JSON-LD should update their implementation.
What could actually go wrong?
The primary risk is not an automatic ranking loss.
The risk is incorrect interpretation of structured data.
Consider a Product schema containing:
```json
{
"@type": "Product",
"name": "Health & Wellness Pack"
}
```
If Google stops after a single unescaping pass, the extracted name may still contain an encoded entity rather than the intended ampersand.
Depending on where the issue occurs and the property involved, this could result in:
- structured-data values being interpreted incorrectly
- information not matching the visible page content
- validation or processing issues
- inaccurate structured-data extraction
- issues with eligibility for particular rich-result experiences
It does not mean every page containing a double-escaped entity will disappear from rich results.
The effect depends on what is incorrectly encoded, the structured-data type involved and how Google's systems process that particular property.
That is why the right response is an audit, not panic.
Which websites should pay particular attention?
1. Ecommerce websites
Large ecommerce sites are particularly worth checking because Product, Offer, Review and Breadcrumb structured data is often generated dynamically.
Product names can contain:
```text
&
'
"
™
®
+
```
along with other characters that may pass through different formatting and encoding systems.
A small template issue can therefore propagate across thousands of product pages.
2. Websites using CMS plugins
If WordPress or another CMS generates structured data through a plugin, the site's marketing or SEO team may never inspect the actual JSON-LD being produced.
An implementation that has worked for years isn't necessarily evidence that the generated output follows current standards.
3. Websites using custom schema generators
Enterprise websites frequently build structured-data systems internally.
If data moves through databases, APIs, rendering layers and templates before being injected into JSON-LD, teams should verify where escaping occurs.
4. Websites where multiple tools generate schema
Another common problem is having:
- a CMS
- an SEO plugin
- an ecommerce plugin
- a custom script
- a tag-management implementation
all interacting with structured data.
This increases both duplication and encoding risk.
5. Large dynamic websites
At scale, manually checking a handful of pages is not enough.
One category template could be correct while another template produces improperly escaped schema.
The audit therefore needs to happen at both the URL level and template level.
How to check whether your website is affected
There are several practical checks SEO and engineering teams can run.
Step 1: Inspect the final JSON-LD
Don't only inspect what exists in the CMS.
Check what is actually being delivered on the page.
Look for:
```html
```
and inspect the content inside it.
Search specifically for patterns such as:
```text
&
```
```text
&#...
```
and other unnecessarily repeated HTML encodings.
Step 2: Test representative URLs
Google recommends using its Rich Results Test to validate structured data and using the URL Inspection tool after deployment to check how Google sees the page.
Don't test only the homepage.
For an ecommerce website, for example, sample:
- homepage
- category page
- product page
- product with reviews
- product with special characters in its name
- article/blog page
- location page
Google also recommends using the Schema Markup Validator when broader schema.org validation is required beyond Google-specific rich-result eligibility.
Step 3: Check rendered HTML
This becomes particularly important where JSON-LD is generated through JavaScript.
Google specifically recommends testing the live URL and checking the rendered HTML when diagnosing JavaScript-generated structured data.
What exists in your source system and what Google eventually receives may not be identical.
Step 4: Identify the source of the problem
If double escaping is present across thousands of pages, don't manually fix individual URLs.
Find the generation layer responsible for it.
That could be:
- CMS
- theme
- plugin
- template
- API transformation
- JavaScript function
- server-side renderer
Fix the source so that future structured-data output is consistently generated correctly.
Step 5: Validate after deployment
Google itself warns that structured data can break after deployment because of templating or serving issues.
Its documentation recommends testing during development and monitoring structured-data reports after launch.
This is particularly relevant here.
A successful developer test does not guarantee every production template is generating the same output.
What brands should ask their SEO and development teams today
Brands don't necessarily need to understand the details of HTML escaping.
But they should ask one simple question:
"Does any JSON-LD generated on our website contain double-escaped entities?"
The technical team can then check:
1. Are our JSON-LD blocks valid and standards compliant?
2. Do any templates generate values such as `&` or `&#...;`?
3. Are values being HTML-escaped before they are inserted into JSON-LD and then escaped again by another system?
4. Have we tested representative URLs across every important template?
5. Are Product, Review, Organization, Article, Breadcrumb and other commercially important schema types rendering correctly?
6. Have we tested the final rendered page rather than only our CMS configuration?
If the answers are clean, there may be nothing more to do.
The bigger lesson: search engines are becoming less forgiving of messy machine-readable data
The announcement itself is narrow.
But the broader lesson is important.
For years, technical SEO implementations have sometimes benefited from search engines being forgiving.
Malformed markup, inconsistent encoding and imperfect templates might still have been interpreted correctly because Google's systems attempted to compensate.
That isn't a good technical strategy.
As websites become increasingly consumed by machines — search crawlers, parsers, recommendation systems and AI-driven interfaces — brands need to think about more than what their website looks like.
They need to think about what their website communicates to machines.
Structured data is one part of that communication layer.
Clean HTML, crawlable content, descriptive entities, consistent metadata and standards-compliant machine-readable information all reduce ambiguity.
And reducing ambiguity is becoming increasingly important. That is the same discipline behind building AI visibility and sustained generative engine optimization.
Does this affect AI Search visibility?
It is important not to overstate the announcement.
Google's announcement specifically concerns Google's JSON-LD extraction behaviour.
There is no basis from this announcement alone to claim that the change directly affects how ChatGPT, Perplexity, Gemini or other AI discovery platforms interpret every website. You can see how each of those surfaces behaves differently on our AI search platforms overview.
But there is a broader principle that brands should take seriously:
Machine interpretability is becoming an important part of digital visibility.
Your website is no longer consumed only by people looking at a browser.
Different systems may crawl, extract, classify, understand and retrieve information from it.
That makes clean technical architecture increasingly valuable.
Brands should therefore think beyond individual fixes and ask:
> How easy is it for machines to accurately understand our products, services, expertise, entities and relationships?
That is a much bigger question than schema markup alone. If you want to see which domains AI engines actually cite today, the AI Citation Index tracks that month over month.
From technical SEO to machine visibility
Google's JSON-LD parser change isn't the kind of announcement that should cause marketing teams to panic.
For correctly implemented websites, it may require no action whatsoever.
But it is exactly the kind of technical change sophisticated SEO teams should catch early.
The action is straightforward:
Audit your JSON-LD. Identify double-escaped entities. Fix them at the generation layer. Validate the final rendered implementation.
More importantly, use the change as a reminder that search visibility increasingly depends on providing machines with information they can interpret reliably.
The web has always been written for humans and machines.
The machine side of that equation is now becoming harder to ignore.
Key Takeaway
Google now performs only one pass of HTML unescaping when extracting JSON-LD.
If your website's schema already outputs clean, standards-compliant JSON-LD, there is likely nothing to change.
If your implementation produces double-escaped entities such as `&`, it is time to audit the underlying schema generator.
This isn't a ranking update. It's a technical parsing change — but one worth fixing before it becomes a structured-data problem.
About DareAISearch
DareAISearch helps brands understand, improve and execute their visibility across traditional and AI-driven search environments. By connecting analytics, intelligence and deployment, DareAISearch helps brands identify where discovery is happening, understand why competitors are being surfaced, and take action across owned, controlled and third-party digital channels. Explore our AI search optimization services to get started.
One Unified Engine for GEO and SEO.
Book A DemoWant to create your own llms.txt file?
Use the free DareAISearch llms.txt Generator to create an upload-ready file for your website in minutes.
Frequently Asked Questions
What exactly did Google change about JSON-LD?
Is this a Google ranking update or a penalty?
Why does double escaping happen in the first place?
What should developers use instead of double-escaped entities?
Which websites are most likely to be affected?
How can a team check whether their site is affected?
Does this change affect AI search visibility?
Check Your AI Search Visibility
Find out how your brand appears across ChatGPT, Gemini, Perplexity, and Google AI Overviews.