Technical SEO Optimized for AI Search

    Google Changed How It Reads JSON-LD: What Brands Need to Fix in Their Structured Data

    Siddhant JainAugust 22, 20269 min read
    Last updated: October 27, 2026
    Share

    Summarize with AI

    Opens your chosen AI platform in a new tab. Sign-in may be required; article access and summaries vary by platform.

    Google Changed How It Reads JSON-LD: What Brands Need to Fix in Their Structured Data

    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 Demo

    Want 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.

    Generate llms.txt

    Frequently Asked Questions

    What exactly did Google change about JSON-LD?
    Google changed its JSON-LD extraction process to apply only one pass of HTML unescaping, bringing its parser closer to JSON and other established standards. Previously its extraction could effectively unwind multiple levels of escaping, so double-escaped entities eventually resolved to the intended character. Now the decoding stops after a single pass.
    Is this a Google ranking update or a penalty?
    No. There is no indication from Google's announcement that this is a new ranking algorithm, ranking signal or penalty. It is a parsing change. Structured data affects eligibility for rich results and search experiences rather than normal web search ranking, and correct structured data never guaranteed a rich result in the first place.
    Why does double escaping happen in the first place?
    Almost nobody writes it intentionally. Values often pass through several layers before the final HTML is served: a CMS stores the value, one layer escapes it for HTML, then a template, plugin or rendering system escapes it again. Ecommerce platforms, SEO plugins, product feeds, custom JavaScript, server-side rendering and templating frameworks can all introduce a second encoding pass.
    What should developers use instead of double-escaped entities?
    Standards-compliant JSON escaping. An ampersand can exist directly inside a normal JSON string, or be written as a Unicode hexadecimal escape such as \u0026. What implementations should avoid is depending on multiple rounds of HTML entity decoding to arrive at the intended value.
    Which websites are most likely to be affected?
    Large ecommerce sites generating Product, Offer, Review and Breadcrumb schema dynamically; sites relying on CMS or SEO plugins for schema; enterprises with custom schema generators; sites where several tools all write structured data; and large dynamic sites where one template may be correct while another is not.
    How can a team check whether their site is affected?
    Inspect the final delivered JSON-LD rather than the CMS configuration, search for patterns such as & or &#...;, test representative URLs across every important template using the Rich Results Test and the Schema Markup Validator, check the rendered HTML where JSON-LD is generated by JavaScript, fix the generation layer rather than individual URLs, and validate again after deployment.
    Does this change affect AI search visibility?
    Google's announcement concerns Google's own JSON-LD extraction behaviour, and there is no basis in it to claim a direct effect on how ChatGPT, Perplexity, Gemini or Google AI Overviews interpret every website. The broader principle still matters: machine interpretability is becoming a core part of digital visibility, and clean, unambiguous machine-readable data helps every system that crawls, extracts and cites your brand.

    Check Your AI Search Visibility

    Find out how your brand appears across ChatGPT, Gemini, Perplexity, and Google AI Overviews.