Google and Bing extract JSON-LD with dedicated structured-data parsers that feed a knowledge layer. Perplexity, ChatGPT and Gemini in retrieval mode flatten the page to text, where JSON-LD competes for context budget and frequently gets cut. Volpini et al. (arXiv:2603.10700) measured a negligible effect size of d=0.18 for JSON-LD alone in flat-text RAG, versus d=0.60 (+29.6% accuracy) for pages that render structured knowledge as readable body text. The GEO Lab’s E002 experiment converges on the same conclusion from live Perplexity measurement. The fix is link materialisation — state entity relationships as prose early in the document — not more schema.
The measured effect of JSON-LD alone is negligible in flat-text RAG
You added Schema.org JSON-LD to every page. Your Google rich results improved. Your Perplexity citation rate did not move. Both outcomes are correct, and the reason is architectural. JSON-LD for AI search behaves like two different signals depending on which system reads it, and most GEO advice collapses the two into one instruction that only half works.
The short version: Google and Bing run dedicated structured-data parsers that pull JSON-LD out of the page before indexing. Perplexity, ChatGPT and Gemini in retrieval mode read the page as flat text, where your JSON-LD competes for context budget against everything else and frequently gets cut. The markup is identical. The pipelines are not.
Volpini et al. (arXiv:2603.10700, March 2026) measured an effect size of d=0.18 for JSON-LD on its own inside flat-text retrieval-augmented generation pipelines. That is negligible by any standard reading of Cohen — well below the 22-point noise floor the GEO Lab measured for citation changes in Cohen’s d. The same paper measured d=0.60 for enhanced entity pages that render the same structured knowledge as readable body text, a +29.6% improvement in RAG answer accuracy. The structured data was not the problem. The delivery format was.
The mechanism is concrete. In the corpus Volpini et al. studied, the JSON-LD script block started at a median character position of 18,510. Flat-text pipelines commonly truncate input around the 20,000-character boundary, so the structured data often sits right at or past the point where the page gets cut before embedding. The parser-based systems never see this problem because they extract the JSON-LD as a separate object and index it in a knowledge layer, away from the body-text budget.
Going deeper? The GEO for WordPress guide covers technical schema setup, structured data placement, and how to configure your site for both parser-based and flat-text AI search — free to download.
Two architectures, two outcomes, one piece of markup
Google and Bing belong to the first world. They maintain dedicated structured-data parsers that read JSON-LD as machine-readable entity data, feed it into knowledge-graph understanding, and use it to drive rich results and knowledge panels. Here the standard advice holds: mark up your entities, your articles and your FAQs, and the parser rewards you.
Perplexity, ChatGPT and Gemini in retrieval mode belong to the second world. These systems fetch a page, flatten it to a single text chunk, embed that chunk, and retrieve against it. A JSON-LD block in that chunk is just more text. It carries no special status, it occupies context budget, and when the page is long it is among the first content to be truncated. This is the world the Structural Authority layer of the GEO Stack has to account for, because the schema work that satisfies Google does not transfer.
| Dimension | Google / Bing (parser-based) | Perplexity / ChatGPT / Gemini (flat-text RAG) |
|---|---|---|
| JSON-LD handling | Extracted by dedicated parser, indexed separately | Read as body text, competes for context budget |
| Truncation risk | None — parsed before page-length limits apply | High — median position 18,510 chars, near 20k cutoff |
| Effect size (Volpini et al.) | Drives rich results and knowledge panels | d=0.18 (negligible) |
| What earns citations | Structured markup + entity clarity | Link materialisation in visible prose (d=0.60) |
Our own FAQ-schema result points the same way
The GEO Lab’s E002 experiment tested FAQPage schema against Perplexity citation rate and found no measurable citation lift from the schema itself. That result was reached through a different method than the Volpini work, which makes the convergence useful: an arXiv RAG study and a controlled live-platform measurement land on the same conclusion from opposite directions. Adding FAQPage markup did not change whether Perplexity cited the page, because the markup never reached the retrieval layer as anything other than ordinary text. The detail of how Perplexity handles a brand name without a link is covered separately in the mention versus citation gap analysis.
One caveat applies to that comparison. The E002 finding is qualitative on the citation-lift question, not a single hard percentage, because the detection method for grounding-redirect URLs has known measurement edges. The directional result is solid: schema presence did not move citation. The exact magnitude is not the claim being made here.
The fix is link materialisation, not more schema
If your goal is citation in flat-text AI search, the lever is making structured knowledge visible in the page body as natural language. Volpini et al. call this link materialisation: take the entity relationships you would otherwise express only in JSON-LD and render them as readable sentences in the visible content. The +29.6% RAG accuracy gain (d=0.60) came from pages that did this, not from pages with richer markup.
In GEO Stack terms this is an Extractability and entity-reinforcement task, not a markup task. State the entity, its category and its relationships in prose. Put that prose early in the document, well before any truncation boundary. Keep the JSON-LD as well, because Google still reads it, but stop treating it as the thing that earns AI citations on Perplexity, ChatGPT or Gemini. It does not, and the data on that point is now coming from two independent sources.
What to do this week
Audit where your JSON-LD sits in the raw HTML. If the script block starts past roughly 15,000 characters on a long page, assume flat-text pipelines may never see it. Move your most important entity statements into the visible opening sections as plain sentences. Keep the schema for the parser-based world, add materialised entity prose for the RAG world, and measure citation rate per platform rather than assuming one signal serves both.
- JSON-LD works on Google, not on Perplexity. Google runs a dedicated parser. Perplexity reads it as flat text and often truncates it past the 20k-character boundary.
- The measured effect is negligible in flat-text RAG. Volpini et al. found d=0.18 for JSON-LD alone versus d=0.60 for link materialisation — rendering structured knowledge as readable prose.
- Two independent sources converge. An arXiv controlled RAG study and the GEO Lab’s E002 live Perplexity measurement both find no citation lift from schema markup in flat-text retrieval.
- The fix is prose, not more markup. State entity relationships as natural-language sentences early in the document. Keep JSON-LD for Google, earn AI citations with visible content.
Ready to audit your JSON-LD placement? The GEO Stack framework maps where schema helps and where prose takes over — layer by layer.
Questions? Contact The GEO Lab.
Frequently asked questions
Does JSON-LD help with AI search citations?
It depends on the system. JSON-LD helps with Google and Bing, which run dedicated structured-data parsers. It has a negligible measured effect (d=0.18, Volpini et al. 2026) inside flat-text RAG pipelines like Perplexity, ChatGPT and Gemini in retrieval mode, where it is read as ordinary body text and often truncated before indexing.
Why does schema work on Google but not Perplexity?
Google extracts JSON-LD with a dedicated parser and indexes it separately from page text. Perplexity flattens the whole page into a single text chunk for retrieval, so the JSON-LD competes for context budget with everything else. Same markup, two different architectures, two different outcomes.
What should I do instead of relying on JSON-LD for AI search?
Use link materialisation. Render your entity relationships as readable sentences in the visible body text, placed early in the document before any truncation boundary. Volpini et al. measured a +29.6% RAG accuracy gain (d=0.60) from this approach. Keep the JSON-LD for Google, but earn AI citations with prose.
Is the JSON-LD finding reliable?
Two independent sources agree. Volpini et al. (arXiv:2603.10700) measured it in a controlled RAG study, and the GEO Lab’s E002 experiment found no measurable citation lift from FAQPage schema on Perplexity using live measurement. One limitation to note in the arXiv work is that its ground truth is partly knowledge-graph-derived, which introduces some circularity, so the effect-size magnitudes are best read as directional.
Should I remove JSON-LD from my pages entirely?
No. Keep it for Google and Bing, which extract and use it through their dedicated parsers. JSON-LD still drives rich results, knowledge panels and entity disambiguation on parser-based search engines. The point is to stop relying on it as the mechanism for earning citations on Perplexity, ChatGPT and Gemini, where the flat-text pipeline ignores or truncates it. Run both: schema for parsers, materialised prose for RAG.