Blog / Technical SEO /

A guide to validating structured data on dynamically rendered pages

The validator says “valid”. The page, as a crawler sees it, may have no structured data at all, or two conflicting copies.

On a JavaScript-rendered page, structured data can be in the initial response, added later, duplicated or incomplete. So validation has to check what a search crawler can reach and what a user sees, not only whether a snippet of JSON passes a syntax test. I’ve lost count of how often “valid” and “correct” turned out to be different things.

Identify the source and render path

Work out whether structured data comes from the theme, an app, server rendering or a client-side script. Inspect the raw response and the rendered DOM. Check that required scripts and resources are available to the crawler. A browser can run code differently from a search system, so use proper inspection tools and the current official documentation.

I choose representative page types and states: default product, selected variant, out of stock, article or other relevant structured entity. Record URL, time, environment and tool. If content depends on user interaction, determine whether the data appears before or after the interaction and whether the crawler can observe it.

Compare markup with visible content

Check names, prices, availability, images, identifiers and claims against the page. Values should be accurate and visible to users where the guidelines require it. If the page changes by variant or market, test that the structured data follows the selection. Don’t add values just to silence a warning.

Look for duplicate objects emitted by multiple apps or scripts. Conflicting markup can be harder to diagnose than a missing field. Identify the source before changing templates so an app update does not recreate the problem.

Validate more than syntax

A parser can show markup is syntactically valid. It can’t guarantee rich-result display or ranking. Check eligibility, policy requirements and page accuracy separately. Read warnings in context and prioritise the ones that affect trust or eligibility. Keep the expected result realistic.

Test cache states and deployment conditions. A page may have stale JSON in a cache or missing output on some locale paths. Re-run validation on the live URL after deployment and inspect representative pages manually.

Document ownership

Keep a record of data source, template, test URL, result, owner and follow-up. Review structured output when themes, apps, product data or rendering changes.

Account for caching and failure states

Dynamic pages can behave differently in cached and uncached conditions. Check whether the structured data is included in a cached response and whether product changes invalidate that cache. If the page has consent-dependent scripts, determine whether the relevant data is available to crawlers without violating privacy or site policy. Do not assume a single browser session represents every response.

Test errors and unavailable data. If a product API fails, the page should not emit stale price or availability as though it were current. Review fallback behaviour and assign an owner for data freshness. A technically parseable JSON block can still be wrong if it lags behind the visible offer.

Keep tests repeatable

Save representative URLs for each template and locale. Record initial versus rendered findings and note whether a test needed interaction. Re-run after theme, app, consent or product feed changes. Use the same test conditions when comparing versions, and tell parser changes apart from page changes.

If validation tools disagree, compare their fetch method, rendering and policy scope. Settle the discrepancy before changing production markup.

Avoid overfitting to a test tool

A validation tool can report properties that are technically supported but not useful for the page. Evaluate whether the data reflects the visible entity and follows applicable policies. Do not add optional fields solely to make a report green. Rich-result display is not guaranteed even when markup is valid and eligible.

If the page is client-rendered, test the crawler-facing response with an appropriate inspection method. Confirm that important data is not withheld behind interactions or dependent on a blocked resource. If a crawler cannot see the relevant content, investigate rendering and access rather than adding another duplicate script.

Keep the review focused on user and crawler consistency. A clean validation output is one piece of evidence, not proof of search appearance.

Validate changes in a controlled way

If structured data needs correction, change one source at a time and keep the test URL. A theme update, app setting and custom script changed together make it difficult to identify which one fixed or created a problem. Review the rendered result, then compare the raw response and crawler inspection.

When a value comes from a product feed or inventory system, trace the data flow to its source. A manual schema override may become stale when the product changes. Prefer a maintainable source of truth and assign ownership for exceptions.

Tell stakeholders what validation does and doesn’t establish. Parseability, policy alignment and data accuracy are different checks, and you shouldn’t promise rich results.

Keep the validation date in the audit record and repeat the test after changes to rendering scripts, since an old pass says nothing about today’s output. Compare initial and rendered output when JavaScript is involved, and keep both with the URL and test date. Can your team reproduce a valid result after the next product, app or theme change?