Advanced Schema Patterns: @graph, Nesting, Stacking, and Specialized Types

Basic schema markup -- a single Product or Article type on a page -- is no longer sufficient for AI visibility. The highest-performing pages in AI search use advanced schema patterns that combine multiple types, cross-reference entities, and leverage specialized types that most sites ignore. Sites implementing comprehensive structured data saw a 44% increase in AI search citations. Pages using 3-4 schema types together achieve the highest citation rates across ChatGPT, Perplexity, and Google AI Overviews.

This guide covers the advanced schema patterns that separate pages AI engines love to cite from pages they skip: the @graph structure for managing multiple types, nested schemas for entity relationships, schema stacking for maximum coverage, ItemList for collections, sameAs for cross-referencing, Speakable for voice and AI extraction, and the critical difference between QAPage and FAQPage.

The @graph Pattern: Managing Multiple Schema Types

When a page needs multiple schema types -- and most ecommerce pages do -- the @graph pattern is the correct way to implement them. The @graph structure creates a flat array of entities within a single JSON-LD block, with each entity referenced by an @id property.

Why @graph Exists

Without @graph, you would need separate JSON-LD script blocks for each schema type on a page. While multiple script blocks technically work, they create problems: entities cannot reference each other, search engines may process them independently without understanding relationships, and maintenance becomes complex.

The @graph pattern solves this by placing all entities in a single JSON-LD block:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "Example Store",
      "url": "https://example.com"
    },
    {
      "@type": "WebSite",
      "@id": "https://example.com/#website",
      "publisher": { "@id": "https://example.com/#organization" }
    },
    {
      "@type": "Product",
      "@id": "https://example.com/product-page/#product",
      "name": "Example Product"
    }
  ]
}

Each entity has a unique @id (typically the page URL with a hash fragment). Other entities reference each other using these @id values rather than duplicating data. This creates a connected entity graph that AI engines can traverse.

Best Practices for @graph

Keep the structure flat. Never nest @graph arrays inside other @graph arrays. Each entity sits at the top level of the @graph array. Relationships are expressed through @id references, not through physical nesting.

Use consistent @id patterns. Establish a convention: https://yourdomain.com/#organization for the organization, https://yourdomain.com/page-url/#product for products, https://yourdomain.com/page-url/#breadcrumb for breadcrumbs. Consistent patterns make debugging and maintenance manageable at scale.

Validate everything. Run every @graph implementation through Google's Rich Results Test and the Schema Markup Validator. Complex @graph structures are easy to break with a misplaced comma or incorrect @id reference.

Nested Schemas: Entity Relationships

While @graph entities reference each other through @id, some schema relationships are better expressed through direct nesting -- embedding one entity inside another.

When to Nest vs. When to Reference

Nest when the child entity only exists in the context of the parent. A product's Offer (price and availability) only makes sense as part of the Product -- it has no independent existence. Nest it directly:

{
  "@type": "Product",
  "name": "Running Shoe Model X",
  "offers": {
    "@type": "Offer",
    "price": "129.99",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}

Reference with @id when the entity exists independently and may be referenced by multiple parents. An Organization publishes many products and articles -- it should be defined once in the @graph and referenced by @id:

{
  "@type": "Product",
  "manufacturer": { "@id": "https://example.com/#organization" }
}

Common Nesting Patterns for Ecommerce

Product with nested Offer and AggregateRating:

The most common ecommerce nesting pattern. The Product entity contains nested Offer (price, availability, seller) and AggregateRating (review summary) entities. This nesting is correct because both the offer and rating data are intrinsically tied to the product.

Article with nested Author:

For blog posts and buying guides, the Article schema can nest a Person entity for the author when the author is not a site-wide entity. If the same author writes multiple articles, reference a shared Person entity through @id instead.

FAQ nested within Article using hasPart:

The Article schema can reference FAQ content using the hasPart property: "hasPart": { "@type": "FAQPage" }. This tells AI engines that the FAQ section is structurally part of the article content rather than a standalone element. This relationship signal increases the probability that AI engines treat the FAQ answers as authoritative because they are backed by the article's broader context.

Schema Stacking: Combining Multiple Types

Schema stacking is the practice of implementing multiple complementary schema types on a single page. The most AI-optimized pages use 3-4 schema types together, each serving a different purpose in the AI extraction pipeline.

The Product Page Stack

The optimal schema stack for an ecommerce product page:

  1. Product: Core product data -- name, description, image, brand, SKU, GTIN
  2. Offer: Price, availability, seller, valid through date
  3. AggregateRating: Average rating, review count, rating distribution
  4. Review: Individual customer reviews with author, date, and rating
  5. FAQPage: Product-specific questions and answers
  6. BreadcrumbList: Site navigation hierarchy showing category placement

This six-type stack covers every dimension that AI engines evaluate when deciding whether to cite a product: what the product is (Product), what it costs and whether it is available (Offer), whether customers approve (AggregateRating and Review), what common questions it addresses (FAQ), and where it fits in the site hierarchy (Breadcrumb).

Pages with the triple stack of Product plus FAQ plus BreadcrumbList achieve citation rates roughly 2.7x higher than pages with Product schema alone. Adding AggregateRating and Review schema further improves the trust signals that influence citation selection.

The Blog Post Stack

For content marketing pages -- buying guides, comparisons, industry analysis:

  1. Article or BlogPosting: Publication data -- headline, author, date published, date modified, publisher
  2. FAQPage: Key questions answered by the article
  3. BreadcrumbList: Content hierarchy
  4. Speakable: Sections optimized for voice and AI extraction
  5. Organization: Publisher entity (referenced, not nested)

The dateModified property within Article schema is especially important. Pages with dateModified schema receive 1.8x more AI citations than pages without it. AI engines use this signal to assess freshness without relying on page content analysis.

The Category Page Stack

For ecommerce category and collection pages:

  1. ItemList: Ordered or unordered list of products in the category
  2. BreadcrumbList: Category hierarchy within site navigation
  3. FAQPage: Category-level questions (e.g., "How to choose the right running shoe")
  4. Organization: Store entity

The ItemList schema is particularly valuable for category pages because it tells AI engines the scope of your product catalog for a given category. When an AI answers "What running shoes does [brand] sell?", the ItemList provides a machine-readable inventory.

ItemList for Collections

ItemList schema represents an ordered or unordered list of items -- products, articles, events, or any other entity type. For ecommerce, ItemList is the correct way to mark up category pages, search results pages, and curated collections.

Implementation Pattern

{
  "@type": "ItemList",
  "name": "Best Selling Running Shoes",
  "numberOfItems": 12,
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "item": {
        "@type": "Product",
        "@id": "https://example.com/shoes/model-x/",
        "name": "Model X Running Shoe",
        "image": "https://example.com/images/model-x.jpg"
      }
    },
    {
      "@type": "ListItem",
      "position": 2,
      "item": {
        "@type": "Product",
        "@id": "https://example.com/shoes/model-y/",
        "name": "Model Y Running Shoe"
      }
    }
  ]
}

When to Use ItemList

Use ItemList on any page that displays multiple items in a list format:

  • Category pages: All products in a category
  • Best-seller pages: Top products by sales volume
  • Comparison pages: Products being compared
  • Search results: Products matching a search query
  • Gift guides: Curated product recommendations

ItemList is especially valuable for AI citation because it answers enumeration queries. "What are the top 10 [products] from [brand]?" is a common AI query pattern, and ItemList schema provides the exact data the AI needs to answer.

Ranking Within ItemList

The position property within each ListItem communicates ranking order to AI engines. Use meaningful ordering -- by popularity, by rating, by relevance -- rather than arbitrary sequencing. AI engines may cite your top-ranked items preferentially when answering "best" or "top" queries.

sameAs Cross-Referencing

The sameAs property connects your entities to their representations on other platforms. This cross-referencing builds the entity graph that AI engines use to verify identity and establish authority.

Implementation for Organization

{
  "@type": "Organization",
  "name": "Your Brand",
  "sameAs": [
    "https://www.linkedin.com/company/yourbrand",
    "https://twitter.com/yourbrand",
    "https://www.instagram.com/yourbrand",
    "https://www.facebook.com/yourbrand",
    "https://www.youtube.com/@yourbrand",
    "https://en.wikipedia.org/wiki/Your_Brand",
    "https://www.wikidata.org/wiki/Q12345678"
  ]
}

Wikipedia and Wikidata sameAs links are the most powerful for AI citation because AI engines use these as primary entity verification sources. If your brand has a Wikipedia page, the sameAs link to it dramatically strengthens your entity profile.

sameAs for Products

Products can also use sameAs to link to their representations on other platforms:

  • Link to marketplace listings (Amazon, eBay)
  • Link to review aggregator pages
  • Link to manufacturer product pages (if you are a retailer)

This cross-referencing helps AI engines build a complete picture of the product across the web, increasing citation confidence.

Speakable Schema

Speakable schema explicitly marks sections of your page that are optimized for text-to-speech and AI extraction. With voice search accounting for 27% of all queries in 2026 and 40.7% of voice answers coming from featured snippets, Speakable schema directly influences whether AI systems extract your content.

How Speakable Works

Speakable uses CSS selectors or XPath to identify specific page sections suitable for voice reading and AI extraction:

{
  "@type": "WebPage",
  "speakable": {
    "@type": "SpeakableSpecification",
    "cssSelector": [
      ".product-summary",
      ".key-features",
      ".answer-block"
    ]
  }
}

The cssSelector property points to page elements that contain extractable, voice-optimized content. These should be your best-formatted, most concise answer passages -- the sections you most want AI engines to cite.

What to Mark as Speakable

Mark your introduction, key definitions, product summaries, and answer paragraphs as Speakable. These sections should contain:

  • Complete answers in 29 words or fewer (matching the average voice search answer length)
  • Factual statements with specific data points
  • Natural, conversational language suitable for text-to-speech
  • Self-contained meaning (no reliance on surrounding context)

Do not mark entire pages as Speakable. The value comes from specificity -- telling AI engines exactly which passages are the best extraction candidates.

QAPage vs FAQPage: Choosing the Right Type

QAPage and FAQPage serve different content models, and using the wrong one sends incorrect signals to AI engines.

FAQPage: Editorial Answers

FAQPage is for questions the site owner writes and answers editorially. The site publishes both the question and the definitive answer. Each question has one acceptedAnswer.

Use FAQPage for:

  • Product FAQ sections on ecommerce pages
  • Help center articles with official answers
  • Buying guide Q&A sections
  • Any page where your brand provides the authoritative answer

QAPage: Community Answers

QAPage is for community-driven Q&A pages where a user posts a question and multiple people submit answers -- like Stack Overflow or a product community forum. QAPage supports suggestedAnswer for multiple community-submitted answers plus an optional acceptedAnswer for the chosen best answer.

Use QAPage for:

  • Community forums on your site
  • User Q&A sections where customers answer each other
  • Support forums with multiple contributor answers

Why the Distinction Matters for AI

AI engines treat FAQPage and QAPage citations differently. FAQPage content is treated as authoritative -- the site owner stands behind the answer. QAPage content is treated as community opinion -- useful but requiring corroboration.

For ecommerce product pages, FAQPage is almost always the correct choice. Your product FAQ answers are editorial -- your brand is the authority on your own products. Using QAPage for product FAQs would signal to AI engines that the answers are community-contributed rather than official, potentially reducing citation confidence.

The exception is if your product pages include a community Q&A section alongside the official FAQ. In that case, use FAQPage for your official answers and QAPage for the community section -- both can exist on the same page within the @graph structure.

Implementation Checklist

Advanced schema patterns are powerful but complex. Use this implementation sequence:

  1. Start with @graph structure on all page templates
  2. Add the appropriate schema stack for each page type (product, category, blog)
  3. Implement sameAs on your Organization entity with all verified profile URLs
  4. Add ItemList to all category and collection pages
  5. Mark Speakable sections on your highest-value content pages
  6. Verify FAQPage vs QAPage usage across all pages with Q&A content
  7. Validate everything through Google Rich Results Test and Schema Markup Validator

The brands using these advanced patterns are building schema profiles that AI engines can traverse like a knowledge graph. Each schema type contributes a different signal -- identity, authority, structure, product data, community trust -- and together they create the comprehensive machine-readable profile that makes citation easy for AI engines and profitable for your business.