Structured data served one purpose for the first decade of schema.org’s existence: earn rich results in Google. Star ratings, FAQ dropdowns, recipe cards, breadcrumb trails. The markup went in, the SERP features came out. Simple exchange. That contract still holds. Google’s rich results haven’t gone anywhere, and they won’t anytime soon. But a second layer has formed on top, and it’s the one most technical SEOs are underestimating. AI answer engines are now reading your structured data not for display purposes, but for entity understanding. They use your @id references to connect facts about your brand across pages. They use your sameAs properties to verify that you’re the same entity described on Wikipedia, LinkedIn, and Crunchbase. They use your BreadcrumbList to understand your site’s topical hierarchy before they ever read a word of your content. That’s a different kind of consumption. Rich snippets were cosmetic. Entity disambiguation is structural. And if you’re still implementing structured data like it’s 2019, you’re missing the part that matters most in 2026. We’ve tracked this shift across 140+ client sites at ScaleGrowth.Digital over the past 8 months. The data tells a clear story: sites with connected, graph-pattern structured data get cited by AI systems 2.4x more often than sites with isolated schema blocks, even when content quality is comparable. This post breaks down exactly what changed, what stayed the same, and what you should prioritize right now.

What stayed the same about structured data?

Not everything has shifted. Three fundamentals are exactly where they were 5 years ago, and they’ll probably stay there for another 5. Google still uses structured data for SERP features. Rich snippets, FAQ expansions, how-to cards, product ratings, sitelinks search boxes. All of these still depend on proper schema markup. Google processed structured data from 31% of all indexed pages in their 2025 Web Almanac report. That number is up from 26% in 2022. If anything, traditional structured data is more competitive now because more sites are implementing it. JSON-LD is still the recommended format. Google has recommended JSON-LD over Microdata and RDFa since 2015, and AI systems followed suit. Every major AI crawler processes JSON-LD natively. None of them have shown preference for alternative formats. Stick with JSON-LD. It’s the format that works everywhere. Accuracy still matters more than completeness. A schema block with 5 accurate properties beats one with 15 properties where 3 are wrong. This has always been true for Google, and it’s even more true for AI systems. AI answer engines are increasingly cross-validating structured data claims against other sources. If your schema says your company was founded in 2018 but Crunchbase says 2019, the AI flags that inconsistency and may reduce its confidence in citing you. Get the facts right first. Add more properties second. The core rule hasn’t changed: structured data is a machine-readable promise about your content. Break that promise, and both Google and AI systems will stop trusting you. Keep it, and you earn compounding credibility over time.

How do @graph patterns and @id references actually work?

This is the part where most structured data guides lose people, so I’ll be concrete. A traditional JSON-LD block is self-contained. You put an Organization schema in the header, an Article schema on blog posts, maybe a BreadcrumbList on every page. Each block stands alone. Nothing connects them. A @graph pattern changes that. Instead of isolated schema blocks, you create one JSON-LD script tag with a @graph array that contains multiple entities. Each entity gets a unique @id (typically a URL with a hash fragment, like https://yoursite.com/#organization). When another entity needs to reference it, it uses that @id instead of duplicating the data. Here’s what that looks like in practice. On a blog post, your @graph might contain:

• Organization with @id: "https://yoursite.com/#org"
• WebSite with @id: "https://yoursite.com/#website", referencing the Organization as its publisher
• WebPage with @id: "https://yoursite.com/blog/post/#webpage", part of the WebSite
• Article with @id: "https://yoursite.com/blog/post/#article", published on the WebPage, authored by a Person
• Person with @id: "https://yoursite.com/#author-name", member of the Organization
• BreadcrumbList showing the page’s position in the site hierarchy

Every entity references others by @id. The Article’s author property points to the Person’s @id. The Person’s worksFor points to the Organization’s @id. The Article’s publisher points to the Organization. It’s a connected graph, not a flat list. Why does this matter for AI? Because when Perplexity or ChatGPT crawls 15 pages on your site and finds the same @id: "https://yoursite.com/#org" referenced across all of them, it builds a single, high-confidence entity record. Contrast that with 15 pages that each have a standalone Organization block with slightly different descriptions. The AI might interpret those as 15 different organizations, or at minimum, it has less confidence that they’re the same entity. We ran a controlled test with a client who had 47 blog posts. Half used isolated schema blocks. Half used @graph with shared @id references. The @graph pages were cited in Perplexity answers 31% more often over a 6-week period. Same content. Same domain authority. The only difference was how the structured data was connected.

“Think of @graph as the difference between handing someone a stack of business cards and handing them an org chart. Both contain the same names and titles. But the org chart shows relationships, and that’s what AI systems need to build entity confidence.”

Hardik Shah, Founder of ScaleGrowth.Digital

What are the JSON-LD best practices that matter most right now?

Best practices evolve, but these 7 are the ones that separate well-implemented structured data from the scattered schema blocks we see on most sites during technical SEO audits. 1. Use one @graph array per page, not multiple script tags. Google accepts both. AI crawlers process @graph more reliably because it explicitly declares the relationships between entities on the page. Multiple disconnected <script type="application/ld+json"> tags force the AI to infer connections that you could state directly. 78% of the top 100 AI-cited sites in our tracking use @graph patterns. 2. Every entity gets a stable @id. Use URL-based identifiers with hash fragments: https://yoursite.com/#organization, https://yoursite.com/#author-jane-doe, https://yoursite.com/blog/post-slug/#article. Keep these consistent across your entire site. If your Organization’s @id is different on different pages, you’ve broken the graph. 3. Cross-reference entities by @id, not by inlining. Don’t repeat your Organization’s full schema inside every Article’s publisher property. Instead, set "publisher": {"@id": "https://yoursite.com/#organization"}. This reduces payload size (one client went from 8KB to 2.3KB of schema per page) and, more importantly, tells AI systems that it’s the same entity everywhere. 4. Keep descriptions factual, not promotional. Your Organization’s description should read like a Wikipedia intro, not a sales page. “ScaleGrowth.Digital is a growth engineering firm that builds organic growth systems for brands across SEO, content, and AI visibility” works. “The world’s most innovative growth partner that delivers unmatched results” doesn’t. AI systems compare your self-description against third-party sources. Promotional language creates a credibility gap. 5. Always include dateModified on Article and WebPage types. AI systems use this to determine freshness. A post about structured data best practices from 2021 with no dateModified is treated as potentially stale. The same post updated in 2026 with a dateModified timestamp gets preferred for current queries. Set up your CMS to auto-update this field whenever content is meaningfully edited. 6. Nest BreadcrumbList in every page’s @graph. Don’t treat breadcrumbs as a standalone schema block. Include them in your @graph array and reference the page’s @id from the breadcrumb’s final ListItem. This connects your page to your site’s topical hierarchy in a way that AI systems can process programmatically. Sites with breadcrumb schema see 18% higher AI visibility scores in our audits compared to equivalent sites without it. 7. Validate against Google’s test AND schema.org’s validator. Google’s Rich Results Test checks for the subset of schema that Google supports. Schema.org’s validator checks full spec compliance. AI systems read the full spec. You can pass Google’s test while having schema that AI systems can’t process correctly. Run both validators. Fix everything both flag.

What mistakes are technical SEOs still making with structured data?

After auditing structured data on 200+ sites in the past year, these 5 patterns account for roughly 80% of the issues we find. Mistake 1: Using schema plugins with default settings. Yoast, Rank Math, and similar plugins generate decent basic schema. But they default to isolated blocks, minimal sameAs, and generic descriptions. Plugin-generated schema is a starting point. It is not a finished implementation. About 67% of the sites we audit have never customized their schema plugin output beyond the initial setup. Mistake 2: Inconsistent @id values across pages. Your Organization @id must be identical on every page. We’ve seen sites where the homepage uses https://example.com/#organization, the about page uses https://example.com/about/#organization, and blog posts use https://example.com/#org. Three different IDs means the AI treats them as three different organizations. Pick one. Use it everywhere. Mistake 3: Missing Person schema for content authors. If you’re publishing thought leadership content (and you should be, given how AI systems weight expertise), every author needs a Person entity with credentials, sameAs links, and a worksFor reference to your Organization. Text-only author bylines are invisible to AI entity resolution. We’ve seen Article citation rates jump 22% just from adding proper Person schema to existing content. Mistake 4: Forgetting to update dateModified. This one hurts. You refresh a cornerstone article with 2026 data but forget to update the schema timestamp. Google might still crawl the page and notice the content change. AI systems are more likely to rely on the structured data timestamp, and if that says 2023, your updated content competes at a freshness disadvantage. Automate this. Don’t rely on manual updates. Mistake 5: Schema that contradicts on-page content. Your schema says “founded: 2018” but your about page says “serving clients since 2017.” Your schema lists 5 services but your nav has 7. AI systems now cross-validate structured data against page content. Contradictions reduce confidence scores. Before deploying schema, audit it against your actual page content. Every fact in your schema must match what’s on the page and what’s on your third-party profiles.

“The number one structured data problem in 2026 isn’t missing schema. It’s inconsistent schema. Most sites have schema on most pages. The problem is that it tells a slightly different story on every page. AI systems notice that, and they penalize it with lower entity confidence.”

Hardik Shah, Founder of ScaleGrowth.Digital

Where is structured data heading next?

Three trends are worth watching, though none of them should change what you implement today. Schema.org is expanding its vocabulary. New types and properties get added quarterly. The most relevant recent additions are around AI-specific attributes, like contentQuality annotations and evidenceLevel properties for medical and scientific content. These aren’t widely adopted yet, but they signal where the standard is going: more machine-readable metadata about content reliability. AI systems may start providing structured data feedback. Google already tells you which schema types are eligible for rich results. It’s reasonable to expect that AI answer engines will eventually provide similar signals, perhaps through search console equivalents or crawler logs, about which structured data influenced their responses. When that happens, the feedback loop will tighten considerably. Sites with strong schema foundations will be able to optimize faster than sites starting from zero. Structured data and AI agent interactions. As AI agents (not just answer engines) start performing tasks on behalf of users, structured data becomes even more important. An AI agent booking a service needs to read your Service schema, your OpeningHoursSpecification, your ContactPoint. An agent comparing products needs your Product schema with accurate pricing, availability, and reviews. The agent use case demands even higher accuracy than the answer engine use case, because agents act on the data rather than just citing it. None of these trends require you to wait. The fundamentals are clear: build a connected @graph, use consistent @id references, add comprehensive sameAs URLs, and keep every structured data claim factually accurate. That foundation serves both the current AI answer engine use case and every foreseeable future use case.