A single page can contain multiple types of content that each deserve their own schema markup. But how do you combine them correctly? This guide covers best practices for implementing multiple schema types on one page.

When to Use Multiple Schema Types

Common Combinations

Product Page:

  • Product schema (main)
  • FAQ schema (product questions)
  • BreadcrumbList (navigation)
  • Review/AggregateRating (nested in Product)

Blog Post:

  • Article schema (main content)
  • FAQ schema (Q&A section)
  • BreadcrumbList (navigation)
  • Person schema (author)
  • VideoObject (embedded video)

Local Business Page:

  • LocalBusiness schema (business info)
  • FAQ schema (common questions)
  • Event schema (upcoming events)
  • Review schema (testimonials)

Recipe Page:

  • Recipe schema (main content)
  • FAQ schema (cooking questions)
  • VideoObject (recipe video)
  • BreadcrumbList (navigation)

Methods for Multiple Schema Types

Method 1: Separate Script Tags

The simplest approach—each schema in its own script:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Article Title",
  "author": {"@type": "Person", "name": "Author"}
}
</script>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Question text?",
      "acceptedAnswer": {"@type": "Answer", "text": "Answer text"}
    }
  ]
}
</script>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [...]
}
</script>

Pros:

  • Easy to manage
  • Easy to add/remove individual types
  • Clear separation

Cons:

  • Multiple script tags
  • @context repeated

Method 2: Array in Single Script

Combine schemas in an array:

<script type="application/ld+json">
[
  {
    "@context": "https://schema.org",
    "@type": "Article",
    "headline": "Article Title",
    "author": {"@type": "Person", "name": "Author"}
  },
  {
    "@context": "https://schema.org",
    "@type": "FAQPage",
    "mainEntity": [
      {
        "@type": "Question",
        "name": "Question?",
        "acceptedAnswer": {"@type": "Answer", "text": "Answer"}
      }
    ]
  },
  {
    "@context": "https://schema.org",
    "@type": "BreadcrumbList",
    "itemListElement": [...]
  }
]
</script>

Pros:

  • Single script tag
  • All schema in one place

Cons:

  • Larger single block to manage
  • All or nothing if syntax error

Method 3: Using @graph

The most elegant approach for related entities:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "WebPage",
      "@id": "https://example.com/page/#webpage",
      "url": "https://example.com/page/",
      "name": "Page Title"
    },
    {
      "@type": "Article",
      "@id": "https://example.com/page/#article",
      "isPartOf": {"@id": "https://example.com/page/#webpage"},
      "headline": "Article Title",
      "author": {"@id": "https://example.com/#author"}
    },
    {
      "@type": "Person",
      "@id": "https://example.com/#author",
      "name": "John Doe",
      "url": "https://example.com/about/john"
    },
    {
      "@type": "BreadcrumbList",
      "itemListElement": [...]
    }
  ]
}
</script>

Pros:

  • Clean structure
  • Entities can reference each other via @id
  • Single @context declaration
  • Shows relationships between entities

Cons:

  • More complex syntax
  • Requires understanding of @id references

Best Practices

1. One Primary Type Per Page

Every page should have one main schema type that represents the primary content:

  • Blog post → Article
  • Product page → Product
  • Recipe → Recipe
  • Business page → LocalBusiness

2. Nest When Appropriate

Some properties should be nested, not separate:

Correct (Nested):

{
  "@type": "Product",
  "name": "Product Name",
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": 4.5
  },
  "review": [
    {"@type": "Review", "reviewBody": "Great product!"}
  ]
}

Incorrect (Separate):

// Don't do this
{"@type": "Product", "name": "Product Name"}
{"@type": "AggregateRating", "ratingValue": 4.5}

3. Use @id for References

When entities relate to each other, use @id:

{
  "@graph": [
    {
      "@type": "Article",
      "author": {"@id": "https://example.com/#author"}
    },
    {
      "@type": "Person",
      "@id": "https://example.com/#author",
      "name": "Author Name"
    }
  ]
}

4. Don’t Duplicate Information

If the same entity appears multiple places, define once and reference:

Good:

{
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.com/#org",
      "name": "Company Name"
    },
    {
      "@type": "Article",
      "publisher": {"@id": "https://example.com/#org"}
    },
    {
      "@type": "Product",
      "manufacturer": {"@id": "https://example.com/#org"}
    }
  ]
}

5. Validate Combined Schema

Always test the combined schema:

  1. Use Rich Results Test
  2. Check each type is detected
  3. Ensure no conflicts

Common Combinations Examples

E-commerce Product Page

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "BreadcrumbList",
      "itemListElement": [
        {"@type": "ListItem", "position": 1, "name": "Home", "item": "https://example.com"},
        {"@type": "ListItem", "position": 2, "name": "Products", "item": "https://example.com/products"},
        {"@type": "ListItem", "position": 3, "name": "Widget Pro"}
      ]
    },
    {
      "@type": "Product",
      "name": "Widget Pro",
      "description": "The best widget ever",
      "image": "https://example.com/widget.jpg",
      "offers": {
        "@type": "Offer",
        "price": 99.99,
        "priceCurrency": "USD"
      },
      "aggregateRating": {
        "@type": "AggregateRating",
        "ratingValue": 4.8,
        "reviewCount": 124
      }
    },
    {
      "@type": "FAQPage",
      "mainEntity": [
        {
          "@type": "Question",
          "name": "Does this come with a warranty?",
          "acceptedAnswer": {
            "@type": "Answer",
            "text": "Yes, all products include a 2-year warranty."
          }
        }
      ]
    }
  ]
}

Blog Post with Video

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Article",
      "headline": "How to Use Our Product",
      "author": {"@id": "#author"},
      "datePublished": "2025-01-15",
      "video": {"@id": "#video"}
    },
    {
      "@type": "Person",
      "@id": "#author",
      "name": "Jane Expert"
    },
    {
      "@type": "VideoObject",
      "@id": "#video",
      "name": "Product Tutorial",
      "thumbnailUrl": "https://example.com/thumb.jpg",
      "uploadDate": "2025-01-15"
    },
    {
      "@type": "BreadcrumbList",
      "itemListElement": [...]
    }
  ]
}

Things to Avoid

Don’t Conflict

Don’t have competing primary types:

// Bad - which is the main content?
{"@type": "Article", "headline": "Product Review"}
{"@type": "Product", "name": "The Product"}

Don’t Duplicate Data

Don’t repeat the same information in multiple places unnecessarily.

Don’t Over-Schema

Not everything needs schema. Focus on content that benefits from rich results.

Testing Multiple Schema

  1. Rich Results Test - Shows each detected type
  2. Schema Markup Validator - Validates JSON structure
  3. Search Console - Monitor for errors across types

Generate Schema for Your Pages

Use our JSON-LD Schema Generator to create individual schema types, then combine them using the methods above:

Conclusion

Multiple schema types on one page is common and beneficial when done correctly. Use the @graph method for complex relationships, keep one primary type, nest where appropriate, and always validate your combined schema.

The goal is to accurately represent all the structured content on your page without conflicts or redundancy.

Need help combining schema types on your pages? I can help you implement comprehensive structured data strategies. Get in touch for a consultation.