TYPO3 Schema Markup: How to Add Structured Data (3 Methods)

TYPO3 Schema Markup: How to Add Structured Data (3 Methods)

Schema Structured Data implementation in TYPO3 supports three different methods which include manual JSON-LD insertion and extension-based automation and TypoScript/Fluid custom implementation. 

Among these options JSON-LD serves as the preferred format because it offers easy management and flexible usage and search engines prefer it. The guide explains the implementation methodologies of schema in TYPO3 projects and shows the correct methods of implementation for each technique. 

The guide serves TYPO3 editors developers and site owners who want to increase search visibility and enable rich results while structuring their content without making assumptions. 

You should execute manual schema for fast configuration while using extensions to automate processes and you should create custom code to gain complete control of your system while using JSON-LD to achieve optimal outcomes.

Short Answer: How Do You Add Schema Markup in TYPO3?

Short answer: Add schema markup to TYPO3 as JSON-LD that is generated from your page data. Use the brotkrueml/schema extension for most sites, custom TypoScript or Fluid output for special cases, and a hand-written JSON-LD HTML element only for single pages. Then check the rendered page with the Rich Results Test and the Schema Markup Validator.

Key takeaways

  • JSON-LD is the format this guide recommends, because it does not depend on your HTML structure.
  • brotkrueml/schema 4.1.0 added TYPO3 v14 compatibility, and its documentation lists TYPO3 v13 LTS and v14 LTS as supported (extension documentation).
  • In August 2023 Google limited FAQ rich results to well-known government and health websites, and HowTo rich results were deprecated in September 2023 (Google Search Central blog). FAQPage and HowTo remain valid schema.org types and should only describe visible content. Check the Google Search Gallery and Search Console for what Google currently shows.
  • Validate the rendered page, not only your template, and keep exactly one source for each schema type.
  • Keep values such as dates, prices and authors identical to the visible text on the page.

Tested with / valid for: TYPO3 v13.4 LTS and v14 (brotkrueml/schema 4.x).
Updated: November 2026

Which Method Should You Choose?

If you just want a fast decision, use this

MethodBest ForSkill LevelProsCons
Manual HTML (JSON-LD)Small sites, quick fixesBeginnerEasy to add, no setup neededStatic, manual updates required
brotkrueml/schemaMost TYPO3 projectsIntermediateDynamic, auto-updates, TYPO3-integratedNeeds extension setup
Custom TypoScript / FluidComplex / enterprise sitesAdvancedFull control, flexible, scalableRequires development effort

Quick Decision Guide

  • Choose Manual if you need a quick one-page schema fix
  • Choose Extension if you want automation + scalability
  • Choose Custom if you need full control or custom logic

What Is Schema Structured Data?

What Is Schema Structured Data?

Schema Structured Data enables TYPO3 pages to show machine-readable information which helps search engines identify the content type of your material (article, product, event). The system operates according to the Schema.org standard which all major search engines recognize. 

Recommended format:

Use JSON-LD (JavaScript Object Notation for Linked Data). It is a script block in the page that does not depend on the HTML structure.

Structured Data Formats in TYPO3: JSON-LD vs Microdata vs RDFa

JSON-LD vs Microdata vs RDFa in TYPO3

When adding schema in TYPO3, choosing the right format matters for maintenance, scalability, and SEO compatibility.

Format Comparison

FormatHow It WorksBest ForProsCons
JSON-LD (Recommended)Added inside <script> tagAll TYPO3 projectsClean, easy to manage, preferred by GoogleNot directly tied to HTML elements
MicrodataEmbedded within HTML tagsSmall/static pagesDirectly linked to contentMessy, harder to maintain
RDFaUses HTML attributes like MicrodataLegacy/semantic-heavy projectsFlexible vocabulary supportComplex, rarely used in TYPO3

Recommended Schema Format: JSON-LD

  • Does not rely on the HTML code structure
  • Can be easily handled using:
    • TypoScript (page.headerData)
    • Fluid template (<f:asset.script>)
    • Brotkrueml/schema extension
  • Is safer when making updates to TYPO3

This is the reason JSON-LD is the preferred format for most TYPO3 developers.

Where Each Format Is Located in TYPO3

  • JSON-LD

  • In TYPO3 extensions that provide dynamic schema
  • TypoScript or Fluid templates
  • SEO software and integrations
  • Microdata

  • As inline HTML in Fluid templates
  • In old TYPO3 templates/themes
  • RDFa

  • Not used much in current TYPO3 systems
  • Sometimes found in legacy projects

Quick Summary

  • Use JSON-LD for 95% of TYPO3 instances
  • Use Microdata if coupling the schema with HTML
  • Do not use RDFa unless you need it for semantic purposes.

Why Add Schema to TYPO3 Projects

Structured Schema Data allows the search engine to understand the content of your TYPO3 site in the proper context, making your page eligible for rich snippets such as FAQ, rating, product, or event pages. 

Rich snippets usually lead to better presentation in search results, resulting in higher click-through rates than non-enriched pages.

The search engine uses structured data guidelines by Schema.org and Google Search Central to create rich snippets based on the structured data provided on your website.

Measuring the effect

Once you have introduced schema data into your page, measure its performance in Google Search Console:

  • Watch rich snippet impressions
  • Compare click-through rate before and after implementation
  • View enhancement reports (FAQ, Product, etc.)

Common Schema Types for TYPO3 Websites

Not all schema types lead to rich results. Below is a priority-based structure to help you focus on what actually matters for TYPO3 SEO and implementation.

High Priority (Most Impact + Common Use)

1. Organization Schema

  • Best use case: Homepage, About, Contact pages
  • Rich result potential: No direct rich result, but supports brand/entity understanding
  • TYPO3 note: Add globally via TypoScript (page.headerData) or extension
{
"@context": "https://schema.org",
"@type": "Organization",
"name": "T3Planet",
"url": "https://t3planet.de",
"logo": "https://t3planet.de/logo.svg"
}

 

2. Breadcrumb Schema

  • Best use case: All pages with hierarchy (blogs, categories)
  • Rich result potential: Breadcrumb display in search results
  • TYPO3 note: Often generated dynamically via extensions or menu structure
{
"@context": "https://schema.org",
"@type": "BreadcrumbList",
"itemListElement": [{
"@type": "ListItem",
"position": 1,
"name": "Home",
"item": "https://example.com/"
}]
}

 

3. Article Schema

  • Best use case: Blog posts, news (EXT:news)
  • Rich result potential: Eligible for enhanced listings (not guaranteed)
  • TYPO3 note: Map fields like title, author, date dynamically
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "TYPO3 Schema Guide",
"author": { "@type": "Person", "name": "Author Name" }
}

Medium Priority (Use Case Driven)

4. Product Schema

  • Best use case: eCommerce pages
  • Rich result potential: Price, rating, availability
  • TYPO3 note: Requires dynamic data (price, stock, reviews)
{
"@context": "https://schema.org",
"@type": "Product",
"name": "TYPO3 Extension",
"offers": {
"@type": "Offer",
"price": "49.00",
"priceCurrency": "EUR"
}
}

 

5. Event Schema

  • Best use case: Webinars, meetups, conferences
  • Rich result potential: Event listings in search
  • TYPO3 note: Useful with event extensions or custom content types
{
"@context": "https://schema.org",
"@type": "Event",
"name": "TYPO3 Meetup",
"startDate": "2026-12-10T18:00:00"
}

 

Optional / Rarely a Google Rich Result

6. FAQ Schema

  • Best use case: Help pages, documentation
  • Rich result potential: Limited. Since August 2023 Google shows FAQ rich results only for well-known government and health websites; check the Google Search Gallery for the current state. The markup stays valid schema.org
  • TYPO3 note: Optional; only for questions that are visible on the page
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [{
"@type": "Question",
"name": "What is TYPO3 Schema?",
"acceptedAnswer": {
"@type": "Answer",
"text": "It helps search engines understand your content."
}
}]
}

 

Quick Priority Summary

  • Start with: Organization + Breadcrumb + Article
  • Then add: Product or Event (based on site type)
  • Optional: FAQ (rich results limited to well-known government and health sites since August 2023)

Which Schema Types Should You Use for Which Page?

Use Organization and Breadcrumb on every site, then add the type that matches the page: BlogPosting or Article for posts, Product for shop items, Event for dated events. Google decides which types it shows as rich results, so check the Google Search Gallery before you plan around a result.

Page typeSchema typesHow to add it in TYPO3Watch out for
HomepageWebSite, OrganizationTypoScript SCHEMA object or extensionOne Organization for the whole site, not one per page
Blog post or news articleBlogPosting or Article, BreadcrumbListExtension or Fluid templateAuthor and dates must match the visible text
Product pageProduct with OfferExtension or Fluid, filled from the product recordPrice and availability must match the page
Event pageEventExtension or Fluid, filled from event recordsRemove or update expired events
Help or FAQ pageFAQPage (optional)Fluid, only for visible questionsFAQ rich results limited to government and health sites since August 2023

What changed for FAQ and HowTo rich results?

In August 2023 Google limited FAQ rich results to well-known government and health websites, and HowTo rich results were deprecated in September 2023 (Google Search Central blog). Google keeps changing which types it shows, so check the Google Search Gallery and the rich result reports in Search Console for the current state. Both types stay valid schema.org vocabulary and should only describe content that is visible on the page, so existing markup does not break.

Which Schema Types Should Most TYPO3 Sites Implement First?

Here's a fast guide for prioritizing schema according to the types of sites you run:

Informational / Blog Sites

Priority: Article + Breadcrumb + Organization

Reasons:

  • Article: describes article structure (title, author, date)
  • Breadcrumb: better navigability within the search results
  • Organization: provides brand/entity signals

TYPO3 Tip: Map Article fields automatically using Fluid or schemas extension

Service / Business Websites

Priority: Organization + Breadcrumb + Service / Local Markup

Reasons:

  • Organization: essential component for a business identity
  • Breadcrumb: defines site hierarchy
  • Service / Local: increases the relevance of service-oriented queries

TYPO3 Tip: Add Organization globally, if necessary apply additional Service / Local schema

eCommerce Websites

Priority: Product + Breadcrumb + Organization

Reasons:

  • Product: allows showing product price, availability, and ratings
  • Breadcrumb: makes category browsing easier
  • Organization: provides consistent branding across all web pages

TYPO3 Tip: Make sure product information (price, stock) is updated automatically

Event-Led Websites

Priority: Event + Organization + Breadcrumb

Reasons:

  • Event: enables listing events on the SERP (time, place)
  • Organization: identifies the event organizer
  • Breadcrumb: improves navigation within website content

TYPO3 Tip: Check that all events' dates are up-to-date, otherwise, schema will become invalid

Fast Summary

Almost all TYPO3 websites have to have Organization + Breadcrumb first

Then add:

  • Article if the site is content heavy
  • Product if it's eCommerce
  • Event if it's event-based

Overview of the 3 Best Integration Methods

Start with a quick comparison, then choose the method that fits your project’s complexity and workflow.

Comparison First

MethodSkill LevelMaintenance EffortBest Use CasesCommon Pitfalls
Manual HTML (JSON-LD)BeginnerHigh, manual updatesOne-off pages, prototypes, quick fixesContent drift, duplication, forgotten updates
Extension (brotkrueml/schema)IntermediateLow–Medium, automatedMost TYPO3 sites, scalable setupsMisconfiguration, overlapping schema from multiple extensions
Custom TypoScript / FluidAdvancedMedium–HighComplex logic, multilingual, multi-domainHigher dev effort, testing overhead

Free TYPO3 guides
Planning an upgrade, a multilingual setup or accessibility work around your structured data? Download our practical TYPO3 guides at no cost.
Browse the free TYPO3 guides

Method 1: Manual Static Integration (HTML Element Method)

This method is suitable for limited and static use cases (single page or quick experiments). 

Use Cases:

  • When you only want to add schema to one or two pages and 
  • you don't need to have the schema updated dynamically.
  • You don't have TYPO3 extensions installed that would allow you to integrate the schema dynamically. 

How it Works:

  • You will add a JSON-LD code snippet into a standard HTML content element of your TYPO3 site. 
  • You will then validate the JSON-LD code snippet using the Rich Results Test provided by Google. 

Limitations:

Although implementing this option works for a limited number of pages, it does not provide the ability to scale. 

Risk of Content Drift:

  • If the content of your page changes (price, author, date, etc.), your schema will not automatically update to reflect that change, which will create mismatches between your page's content and its associated schema. 
  • As such, the website may not display a rich result or performance listing due to this difference. 

Method 2: Dynamic Integration Using TYPO3 Schema Extension

This method is recommended for the majority of TYPO3 projects, since they are already using this method, and it is the recommended option to integrate schema dynamically.

How it Works:

The TYPO3 Schema Extension (brotkrueml/schema) dynamically creates the schema on your website. The TYPO3 Schema Extension directly accesses the database fields in TYPO3, allowing the schema to always remain in sync with the accompanying content. 

This extension also supports numerous schema types and extensions.

Configuration Options:

Can be configured via:

  • TypoScript (global setup)
  • Fluid ViewHelpers (control over template display)
  • Data mappings from:
    • SEO fields
    • content elements
    • custom fields

Example (TypoScript)

 

page = PAGE
page.10 = SCHEMA
page.10 {
type = WebSite
properties {
name.field = seo_title
description.field = description
}
}

 

Example (Fluid)

 

<schema:type.organization
name="T3Planet"
url="https://t3planet.de"
logo="https://t3planet.de/logo.svg" />

 

Editors vs Integrators (important distinction)

  • Editors: manage content fields (title, description, etc.)
  • Integrators/Developers: configure schema mapping and logic

Breadcrumb automation

  • Breadcrumb schema can be:
    • auto-generated from TYPO3 page tree
    • configured via extension settings or TypoScript

Vocabulary extensions

  • Add-ons like:
    • schema_auto
    • schema_bib
    • schema_health
  • Useful for domain-specific structured data

Common pitfalls

  • Duplicate schema from multiple extensions
  • Missing required properties

Incorrect field mappingUseful for domain-specific structured data

Method 3 – Custom Integration Using TYPO3 Core

Best for: Advanced, custom, or enterprise TYPO3 projects

When to use

  • Multilingual setups
  • Multi-domain configurations
  • Custom entities not supported by extensions
  • Headless or API-driven TYPO3

Option 1: TypoScript (Global Injection)

 

page.headerData {
100 = TEXT
100.value (
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Organization",
"name": "T3Planet",
"url": "https://t3planet.de"
}
</script>
)
}

 

Option 2: Fluid (Template-Level Control)

 

<f:asset.script identifier="schema-article" type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "{newsItem.title}",
"datePublished": "{newsItem.date -> f:format.date(format: 'Y-m-d')}"
}
</f:asset.script>

 

Why use custom integration

  • Full control over:
    • schema structure
    • conditional logic
    • data sources
  • Ideal for:
    • multilingual schema output
    • domain-specific schema variations
    • custom APIs or headless setups

Common pitfalls (Method 3)

  • Manual validation required
  • Higher maintenance effort
  • Risk of syntax errors or incomplete schema

Structured Data via Yoast SEO for TYPO3

If you already use Yoast SEO for TYPO3, it provides built-in structured data features.

When to consider it

  • You already rely on Yoast for SEO
  • You need basic schema (Organization, Article, Breadcrumb)

Limitations

  • Less flexible than dedicated schema extensions
  • Limited customization for complex schema types

Google-Supported Rich Results vs Schema.org Vocabulary

  • Schema.org = what you can describe (Article, Product, Event, etc.)
  • Google Search Central = what may appear in search (rich results)

There are three things to keep in mind when using schema. 

These are:

  • Schema may not produce a rich snippet
  • The schema used may not be a supported type
  • The query intent/page quality used in the schema may not be sufficient.

Also, keep in mind that not every rich snippet will be displayed by Google. There are exceptions: since August 2023 Google shows FAQ rich results only for well-known government and health websites.

The bottom line is to use schema correctly and follow Google's guidelines as to whether your structured content can be displayed. Also, do not count on seeing a rich snippet based on your structured content.

How Do You Add JSON-LD With TypoScript and Fluid?

Use the SCHEMA content object of brotkrueml/schema in TypoScript, or the schema ViewHelpers in Fluid. Both build the JSON-LD from TYPO3 data and add it to the page output. The examples below follow the official extension documentation.

TypoScript: SCHEMA content object

The object adds the type to the global schema output and takes values from page fields. The fallback seo_title // title uses the title when no SEO title is set.

 

page.10 = SCHEMA
page.10 {
   type = WebSite
   properties {
      name.field = seo_title // title
      description.field = description
   }
}

 

Fluid: schema ViewHelpers

Type ViewHelpers use the lower camel case type name, for example schema:type.itemPage. The attribute -as places a nested type under a property of its parent.

 

<schema:type.itemPage>
   <schema:type.product
      -as="mainEntity"
      name="Some fancy product"
      color="blue"
   >
      <schema:type.aggregateRating
         -as="aggregateRating"
         ratingValue="4"
         reviewCount="126"
      />
   </schema:type.product>
</schema:type.itemPage>

 

Fluid without an extension: f:asset.script

Core Fluid can print a JSON-LD block with f:asset.script. The argument identifier is required (ViewHelper reference). Use a unique identifier per block, so the AssetCollector outputs it only once.

 

<f:asset.script identifier="ld-example" type="application/ld+json">
{
   "@context": "https://schema.org",
   "@type": "Organization",
   "name": "Example GmbH",
   "url": "https://example.com"
}
</f:asset.script>

How Do You Validate Structured Data in TYPO3?

Validate the public URL in three tools: the Rich Results Test for Google eligibility, the Schema Markup Validator for schema.org syntax, and Google Search Console for the live page. Repeat after every TYPO3 or extension update.

  1. Check the generated markup in TYPO3. With brotkrueml/schema, the Admin Panel shows the structured data for the current page. Non-admin users need the user TSconfig admPanel { enable { ext-schema = 1 } }.
  2. Run the Rich Results Test. Enter the public URL. It shows which Google features your markup is eligible for and lists errors and warnings.
  3. Run the Schema Markup Validator. It checks the schema.org syntax of any type, including types without a Google rich result.
  4. Inspect the live URL in Google Search Console. Use URL Inspection to confirm that Google sees the markup in the rendered HTML, and review the enhancement reports for the types you use.
  5. Compare with the visible page. Every value in the markup must appear on the page. View the page source and confirm that each type exists only once.

Writing titles, descriptions and Schema.org markup for many pages by hand is slow. The T3AI AI Assistant for TYPO3 helps editors with SEO metadata and structured data inside the TYPO3 backend. For breadcrumb markup, see our guide to SEO-friendly breadcrumbs with MenuProcessor and Fluid, and compare options in the best TYPO3 SEO extensions.

Sovereign TYPO3 AI

AI Assistant icon

AI Assistant for TYPO3T3AI

Write, optimise and translate content right in the backend.

Try Assistant free

TYPO3 Schema Launch Checklist for Structured Data Implementation

 

Checklist Before Launch

To confirm that your Schema in TYPO3 is functional, correct, and ready for search engines, complete the following pre-launch workflow:  

Validate Structured Data

  • Test JSON-LD with the following:
    • Schema.org Validator
    • Google Search Central Rich Results Test
    • Fix all errors (you can review warnings later).

Validation of Live URL (not just Code)

  • Use URL Inspection tool in Google Search Console
  • Confirm that the schema is present and not blocked by JS, caching or other elements when rendered in the final HTML.

Schema Duplication Check

  • Review the page source for multiple schema blocks of the same type on the page.
  • Confirm:
    • No overlap between extensions
    • No manual and dynamic duplication

Coinciding Schema and Visible Content

  • Ensure all structured data on the page corresponds to the actual content on the page.
  • Avoid:
    • Hidden Data
    • Obsolete Values (for example, price, date, author)

Language Consistency Across Versions

  • For multilingual TYPO3 websites:
    • Ensure language of schema matches language of page
    • Ensure correct URL for each language version
    • Avoid mixed-language properties

Verification of Schema Type for the Page

  • Article = Blog Posts
  • Product = Product Pages
  • Event = Events Page

Do not incorrectly identify schema as this could lower eligibility for structured data to be shown.

Secure and Indexable Delivery

  • Ensure the web page being served is secured with HTTPS protocol.
  • Check the page is indexable (not using noindex).
  • Ensure the page is not being blocked by robots.txt.

Measure Before and After Rollout

  • In Google Search Console:
    • Track CTR changes
    • Monitor impressions of rich results
    • Review enhancement report(s).

TYPO3 Structured Data Troubleshooting Guide for Schema Issues

Troubleshooting Common Issues

Even with proper setup, schema issues can occur, especially in TYPO3 environments with multiple extensions and dynamic content. Use these targeted fixes:

1. Duplicate or Missing Schemas

  • Make sure you only have one JSON-LD for each schema type in a single web page.
  • Check to see if you're getting duplicates from:
    • A combination of multiple extensions (e.g., an SEO and a schema plugin)
    • Combining a manual method with an automatic injection method
  • Disabling an overlapping provider or consolidating schema logic.

2. Supported Properties

  • Validate your field values against Schema.org.
  • You need to correct the following types of property values:
    • Misspelled property values.
    • Outdated or unsupported property values.
    • Incorrect Data Types of Property Values (e.g., a string where it should be a number).

3. Outdated TYPO3 Extension and Extension Conflicts

  • Make sure your TYPO3 extensions (e.g., the brotkrueml/schema extension) are updated.
  • Check for the following:
    • Predominantly, extension conflicts (typically with your search engine optimization extensions).
    • Broken mappings after updating TYPO3.
  • You'll need to validate all schema after each update.

4. JSON Formatting Errors

  • Use a linter tool or the Google Rich Results Test to validate your JSON.
  • Some common examples of JSON formatting errors that you'll see:
    • Missing Commas
    • Missing Brackets
    • Bad Quotes
    • Extra Commas

5. Schema Mismatch between Visible and Hidden Content

  • The schema you send should match what users see on the page.
  • Avoid sending:
    • Hidden content.
    • Outdated content.
  • Display content such as reviews, prices, or dates that aren't displayed to the user.
  • A mismatch between the schema and the visible content will remove eligibility for rich search results.

6. Outdated Dynamic Fields (i.e. Products and Events)

  • Be sure that the fields related to items such as:
    • Prices
    • Availability of Products
    • Event Dates
  • Are automatically updated depending upon the content in TYPO3.
  • An expired event or incorrect price will cause the schema to be invalidated.

7. Multilanguage Schema with Two Languages.

  • Check the following:
  • Schema Language must be the same as the web page Language
  • Localized URL
  • No Mixed Languages Exist in the Property
  • Create Separate Schema Rendering for Each Language in TYPO3

8. FAQ Rich Snippet Expectation Mismatch

  • Even valid FAQ schema may not show in search
  • Reasons:
    • restricted by Google policies
    • site not considered authoritative
  • Validate via Google Search Central and adjust expectations

Best Practices for TYPO3 Schema Integration

Follow these to keep your structured data stable, accurate, and scalable:

1. Update Extensions

  • Always use the current version of brotkrueml/schema or other related extensions.
  • Updates address any errors that previously existed and improve compatibility with schemas.

2. Use Dynamic Values from TYPO3 Fields

  • Directly map the title, description, price, date, etc. directly from the content management system (CMS) to the corresponding schema element. 
  • This helps to ensure that the schema is not old or out of date.

3. Centralise Schema Logic

  • Update the schema only in one location instead of multiple places. All schema logic should be managed through:
    • TypoScript
    • Fluid Templates
    • Extensions
  • This will help to reduce duplicated work and errors.

4. Validate After TYPO3 Upgrades

  • Use the tools from Google Search Central to complete an additional validation check of the schema after any updates are made in TYPO3 to ensure that both the rendering and detection of the items are still working properly.

5. Backup Schema Templates

  • Maintain a versioned backup of both:
    • TypoScript
    • Fluid Templates
  • This makes it easy to restore if you experience a problem.

Real Implementation Examples by Site Type

These examples show how schema is actually applied in TYPO3 projects, aligned with real use cases.

Blog / News Site

Typical schema:

  • Article + Breadcrumb + Organization

Implementation approach:

  • Use extension or Fluid to map:
    • title: headline
    • author: Person
    • publish date: datePublished

Example (Fluid):

 

<f:asset.script identifier="schema-article-author" type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "{newsItem.title}",
"datePublished": "{newsItem.date}",
"author": {
"@type": "Person",
"name": "{newsItem.author}"
}
}
</f:asset.script>

 

Corporate / Business Site

Typical schema:

  • Organization + Breadcrumb

Implementation approach:

  • Add Organization globally via TypoScript
  • Keep business details consistent across pages

Example (TypoScript):

 

page.headerData {
100 = TEXT
100.value (
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Organization",
"name": "Company Name",
"url": "https://example.com"
}
</script>
)
}

Product / eCommerce Site

Typical schema:

  • Product + Breadcrumb + Organization

Implementation approach:

  • Pull dynamic data:
    • price
    • availability
    • ratings

Example:

 

{
"@context": "https://schema.org",
"@type": "Product",
"name": "{product.title}",
"offers": {
"@type": "Offer",
"price": "{product.price}",
"priceCurrency": "EUR",
"availability": "https://schema.org/InStock"
}
}

 

Key requirement:

  • Keep values synced with actual product data to avoid mismatches

Event Site

Typical schema:

  • Event + Organization + Breadcrumb

Implementation approach:

  • Map event fields:
    • name
    • start/end date
    • location

Example:

 

{
"@context": "https://schema.org",
"@type": "Event",
"name": "{event.title}",
"startDate": "{event.startDate}",
"endDate": "{event.endDate}"
}

 

Key requirement:

  • Always update or remove expired events

Real-World Examples of Schema in TYPO3

Below are simplified, implementation-focused examples showing how schema is actually used in TYPO3 using different methods.

FAQ Schema (Blog Use Case)

Use case: Blog posts or documentation pages with Q&A sections
Method: TYPO3 Extension or Fluid (dynamic content mapping)

Example (Fluid)

 

<f:asset.script identifier="schema-faqpage" type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [{
"@type": "Question",
"name": "{faq.question}",
"acceptedAnswer": {
"@type": "Answer",
"text": "{faq.answer}"
}
}]
}
</f:asset.script>

Breadcrumb Schema (Navigation Use Case)

Use case: All TYPO3 pages with page hierarchy
Method: TypoScript (global site structure)

Example (TypoScript)

 

page.headerData {
200 = TEXT
200.value (
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "BreadcrumbList",
"itemListElement": [{
"@type": "ListItem",
"position": 1,
"name": "Home",
"item": "https://example.com/"
}]
}
</script>
)
}

 

Product Schema (eCommerce Use Case)

Use case: Product detail pages in TYPO3 shops
Method: TYPO3 Schema Extension (dynamic mapping)

Example (Extension-based concept)

 

{
"@context": "https://schema.org",
"@type": "Product",
"name": "{product.title}",
"offers": {
"@type": "Offer",
"price": "{product.price}",
"priceCurrency": "EUR"
}
}

 

Why extension here:
Keeps product data (price, stock, availability) automatically in sync with TYPO3 content.

Organization Schema (Global Site Identity)

Use case: Every TYPO3 website (header/footer/global identity)
Method: TypoScript or extension

Example (TypoScript, Organization)

 

page.headerData {
100 = TEXT
100.value (
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Organization",
"name": "Company Name",
"url": "https://example.com"
}
</script>
)
}

Event Schema (Event Use Case)

Use case: Meetups, webinars, conferences
Method: Extension or Fluid (dynamic event records)

Example (Fluid, Event)

 

<f:asset.script identifier="schema-event" type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Event",
"name": "{event.title}",
"startDate": "{event.startDate}",
"endDate": "{event.endDate}",
"location": {
"@type": "Place",
"name": "{event.location}"
}
}
</f:asset.script>

 

Conclusion

Schema in TYPO3 should be reviewed and validated regularly and adjusted whenever the content changes. The AI Foundation for TYPO3 can also support controlled AI workflows that analyze structured content or assist in creating appropriate Schema data.

Next steps

  1. Choose a method (Manual, Extension, or Custom)
  2. Add JSON-LD consistently across relevant pages
  3. Validate before publishing using Google tools
  4. Monitor results in Google Search Console (CTR, rich results, errors)

This ensures your structured data stays accurate, indexable, and aligned with TYPO3 content changes over time.

More Questions About TYPO3 Schema Markup

Do I need an extension to add schema markup in TYPO3?

No. You can print JSON-LD with an HTML content element, TypoScript or Fluid. An extension such as brotkrueml/schema adds a typed PHP API, a TypoScript SCHEMA object, Fluid ViewHelpers and an Admin Panel view of the generated markup. This reduces outdated and duplicate markup on larger sites.

Does FAQ schema still help in 2026?

Rarely for the search result. Since August 2023 Google shows FAQ rich results only for well-known government and health websites, and HowTo rich results were deprecated in September 2023 (Google Search Central blog). Google keeps changing which types show, so check the Google Search Gallery and Search Console. FAQPage markup is still valid schema.org and should only describe visible questions and answers, but it should not be a reason to add FAQ blocks.

Which TYPO3 versions does brotkrueml/schema support?

The documentation states support for TYPO3 v13 LTS and v14 LTS. Version 4.0 dropped TYPO3 v11 and v12, and version 4.1.0 added v14 compatibility. Install it in Composer mode with composer req brotkrueml/schema.

Can I use two schema extensions on the same site?

You can, but it often creates duplicate or conflicting markup, for example two Organization blocks. Choose one provider per schema type, disable overlapping output from SEO extensions, and check the page source after every change.

Why is my valid markup not showing as a rich result?

Valid markup only makes a page eligible. Google decides whether to show a rich result, and some types no longer have one. Check that the type is listed in the Google Search Gallery, that the content is visible on the page, and that the page is indexable.

Get the free TYPO3 guides
Keep your TYPO3 project current and your structured data stable after upgrades with our free practical guides.
Download the free TYPO3 guides

The best method for adding schema is by using a TYPO3 schema extension like brotkrueml/schema, as this allows for dynamic (and therefore maintainable) data. Only use manual JSON-LD if you have small, fixed sets of data that you want to add to your website.

Yes! JSON-LD is the recommended format because it is very easy to manage and update over time; it also works separately from HTML; and search engines like Google prefer to use JSON-LD.

No. Out of the box TYPO3 does not provide any native/controlled schema support. You would require TypoScript or Fluid or both, or an extension that supports schema to add this functionality.

The most common way/type people are adding schema to their site is using an extension called brotkrueml/schema which creates dynamic schema and seamlessly worms into TYPO3 workflows.

Implementing schema through TypoScript is very easy to do because TypoScript allows you to inject JSON-LD into headerData. Things like “Organization” or “Breadcrumbs”, which are global schema, can be injected on every page.

The Fluid template engine can be used to dynamically generate JSON-LD via . This is particularly useful when generating schema associated with content such as Articles or Events.

While the FAQ schema can help improve the structure of content, the likelihood of displaying FAQ rich results is very low. Therefore, the primary purpose of using the FAQ schema is to clarify information rather than increase its visibility.

The best way to test schema in TYPO3 is by using the following: Google Search Central - Rich Results Testing Tool; Schema Validation Tools, and by validating the rendered live URL as opposed to validating the code in the TYPO3 templates.

Some of the common reasons for duplicate structured data in TYPO3 are: Several extensions providing schema data, schema through manual entry, schema created through the extension and schema injected to a template through themes or SEO plug-ins.

The first three schema types that you should implement on your eCommerce site are: Product (the core product information); Breadcrumb (provides navigation visibility); Organization (gives identity to the brand). These three schema types will help to provide the most consistent structural benefits for your eCommerce site.

No, schema does not directly affect rankings; however, when schema is correctly implemented, it allows search engines to better understand the content on your website, increase your likelihood of showing up in rich results, and improve the click-thru rate for your website.

You May Also Like