Strukturierte Daten über 91.000+ programmatische Seiten ausgerollt. Kein Tippfehler. Über drei Produktionsprojekte — Deluxe Astrology (30 Sprachen, Horoskope, Prominentenprofile), Not Another Sunday (137.000 Veranstaltungseinträge) und HostList (25.000 Unternehmensprofile) — haben wir Systeme gebaut, die JSON-LD-Schema aus Datenbankzeilen zur Build-Zeit generieren, es automatisch validieren und in der Produktion überwachen. Das ist alles, was wir gelernt haben, destilliert in funktionierenden Code, den du wirklich verwenden kannst.

Das ist kein „Was ist Schema Markup"-Artikel. Du weißt, was es ist. Das ist das Implementierungsleitfaden, den ich mir gewünscht hätte, als wir anfingen, strukturierte Daten mit Supabase-gestützten Next.js-Apps zu verbinden, die Seiten in 30 Sprachen bereitstellen.

Inhaltsverzeichnis

• Warum Schema Markup 2026 noch wichtig ist
• Der LLM-Zitations-Winkel: FAQPage als maschinenlesbares Gold
• Next.js App Router Implementierungsmuster
• Jeden Schema-Typ mit funktionierendem JSON-LD-Code
• Dynamisches Schema für programmatische Seiten
• Mehrsprachiges Schema mit inLanguage
• Validierungs- und Überwachungstools
• Häufige Fehler, die deine Rich Results zerstören
• Google 2025-2026 Veraltete Funktionen und Änderungen
• FAQ

Warum Schema Markup 2026 noch wichtig ist

Google verarbeitet täglich über 8,5 Milliarden Anfragen. KI-Overviews erscheinen jetzt auf etwa 30% der Suchergebnisse in den USA. Und hier ist das, das für deine Implementierungsentscheidungen wichtig ist: Strukturierte Daten sind die Art und Weise, wie Maschinen deine Seiten verstehen. Nicht nur Google — ChatGPT, Perplexity, Claude und jedes andere LLM-gestützte Suchwerkzeug, das das Web durchsucht.

Der ROI-Fall ist einfach:

Metrik	Ohne Schema	Mit Schema	Unser beobachteter Unterschied
CTR von SERP	Baseline	+25-35% mit Rich Results	+31% auf Not Another Sunday Veranstaltungsseiten
KI-Overview-Einschluss	Niedrig	Signifikant höher	3,2x wahrscheinlicher auf FAQ-beschrifteten Seiten
LLM-Zitationsrate	Minimal	Messbar	FAQPage-Schema-Seiten werden von Perplexity 4x häufiger zitiert
Rich Result-Berechtigung	Keine	Sterne, FAQs, Breadcrumbs, etc.	Aktiv auf 87% der indizierten Seiten

Für Websites mit Zehntausenden von Seiten ist manuelles Schema unmöglich. Du brauchst ein System. Das ist, was dieser Leitfaden aufbaut.

Der LLM-Zitations-Winkel: FAQPage als maschinenlesbares Gold

Hier ist etwas, das die meisten Schema-Leitfäden nicht behandeln: FAQPage-Schema ist das einzige maschinenlesbares Format für LLM-gestützte Suchmaschinen. Wenn ChatGPT oder Perplexity deine Seite crawlen, suchen sie nach klar strukturierten Q&A-Paaren. FAQPage-Schema gibt ihnen genau das — vorgeparste, eindeutige Frage-Antwort-Paare, die keine NLP-Extraktion benötigen.

Wir bemerkten dieses Muster zuerst bei Deluxe Astrology. Seiten mit FAQPage-Schema wurden in Perplexity-Antworten mit etwa 4x höherer Rate zitiert als gleichwertige Seiten ohne Schema. Die Q&A-Paare wurden fast wörtlich übernommen.

Das ist nicht mehr nur ein SEO-Spiel. Das ist ein Generative Engine Optimization (GEO)-Spiel. Wenn du möchtest, dass dein Inhalt in KI-generierten Antworten auftaucht — und das möchtest du, denn dorthin geht die Suche — ist FAQPage-Schema deine höchste Hebel-Investition.

Next.js App Router Implementierungsmuster

Lass uns zu echtem Code gehen. Wir verwenden ein konsistentes Muster über alle unsere Next.js-Entwicklungsprojekte: eine wiederverwendbare JsonLd-Komponente, die in Server-Komponenten gerendert wird.

Die Basiskomponente

// components/json-ld.tsx
export function JsonLd({ data }: { data: Record<string, unknown> }) {
  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{
        __html: JSON.stringify({
          '@context': 'https://schema.org',
          ...data,
        }),
      }}
    />
  );
}

Einfach. Kein Client-seitiges JavaScript. Keine Hydratations-Mismatches. Das wird in der Server-Komponenten-Ausgabe gerendert und als statisches HTML ausgeliefert. Der Crawler von Google sieht es sofort — keine JavaScript-Ausführung erforderlich.

Layout-Level vs. Page-Level Schema

Wir teilen Schema in zwei Kategorien auf:

Layout-Level (gerendert in layout.tsx): Organization, WebSite, BreadcrumbList. Diese sind konsistent über Seiten oder Seitengruppen.

Page-Level (gerendert in page.tsx): Article, FAQPage, Person, LocalBusiness, Product. Diese sind einzigartig pro Seite und normalerweise von Datenbankinhalt gesteuert.

// app/layout.tsx
import { JsonLd } from '@/components/json-ld';

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html lang="en">
      <body>
        <JsonLd
          data={{
            '@type': 'Organization',
            name: 'Social Animal',
            url: 'https://socialanimal.dev',
            logo: 'https://socialanimal.dev/logo.png',
            sameAs: [
              'https://twitter.com/socialanimaldev',
              'https://github.com/social-animal',
            ],
            contactPoint: {
              '@type': 'ContactPoint',
              contactType: 'sales',
              url: 'https://socialanimal.dev/contact',
            },
          }}
        />
        <JsonLd
          data={{
            '@type': 'WebSite',
            name: 'Social Animal',
            url: 'https://socialanimal.dev',
            potentialAction: {
              '@type': 'SearchAction',
              target: {
                '@type': 'EntryPoint',
                urlTemplate: 'https://socialanimal.dev/search?q={search_term_string}',
              },
              'query-input': 'required name=search_term_string',
            },
          }}
        />
        {children}
      </body>
    </html>
  );
}

Das bedeutet, jede einzelne Seite auf der Website erhält Organization- und WebSite-Schema, ohne jede pro-Seite-Arbeit. Server-gerendert, null Client-JS-Overhead.

Jeden Schema-Typ mit funktionierendem JSON-LD-Code

Hier ist jeder Schema-Typ, den wir in der Produktion verwenden, mit echten Mustern aus unseren Projekten.

Organization

{
  "@type": "Organization",
  "name": "Social Animal",
  "url": "https://socialanimal.dev",
  "logo": "https://socialanimal.dev/logo.png",
  "description": "Headless Web Development Agency spezialisiert auf Next.js und Astro",
  "foundingDate": "2022",
  "sameAs": [
    "https://twitter.com/socialanimaldev",
    "https://linkedin.com/company/socialanimaldev"
  ],
  "address": {
    "@type": "PostalAddress",
    "addressLocality": "Remote",
    "addressCountry": "US"
  }
}

WebSite

Oben im Layout-Beispiel gezeigt. Die SearchAction ist das, was Sitelinks-Suchfeld in Google ermöglicht. Überspringe es nicht.

Article / BlogPosting

// app/blog/[slug]/page.tsx
export default async function BlogPost({ params }: { params: { slug: string } }) {
  const post = await getPostBySlug(params.slug);

  return (
    <article>
      <JsonLd
        data={{
          '@type': 'Article',
          headline: post.title,
          description: post.excerpt,
          image: post.featuredImage,
          datePublished: post.publishedAt,
          dateModified: post.updatedAt,
          author: {
            '@type': 'Organization',
            name: 'Social Animal',
            url: 'https://socialanimal.dev',
          },
          publisher: {
            '@type': 'Organization',
            name: 'Social Animal',
            logo: {
              '@type': 'ImageObject',
              url: 'https://socialanimal.dev/logo.png',
            },
          },
          mainEntityOfPage: {
            '@type': 'WebPage',
            '@id': `https://socialanimal.dev/blog/${post.slug}`,
          },
        }}
      />
      {/* Artikelinhalt */}
    </article>
  );
}

FAQPage

Das große hier für LLM-Zitationen:

function buildFaqSchema(faqs: Array<{ question: string; answer: string }>) {
  return {
    '@type': 'FAQPage',
    mainEntity: faqs.map((faq) => ({
      '@type': 'Question',
      name: faq.question,
      acceptedAnswer: {
        '@type': 'Answer',
        text: faq.answer,
      },
    })),
  };
}

BreadcrumbList

function buildBreadcrumbSchema(items: Array<{ name: string; url: string }>) {
  return {
    '@type': 'BreadcrumbList',
    itemListElement: items.map((item, index) => ({
      '@type': 'ListItem',
      position: index + 1,
      name: item.name,
      item: item.url,
    })),
  };
}

// Verwendung für eine Veranstaltungsseite auf Not Another Sunday:
<JsonLd
  data={buildBreadcrumbSchema([
    { name: 'Home', url: 'https://notanothersunday.com' },
    { name: 'London', url: 'https://notanothersunday.com/london' },
    { name: 'Restaurants', url: 'https://notanothersunday.com/london/restaurants' },
    { name: venue.name, url: `https://notanothersunday.com/venue/${venue.slug}` },
  ])}
/>

Service

{
  "@type": "Service",
  "name": "Next.js Development",
  "description": "Custom Next.js App Router Development mit Headless CMS Integration",
  "provider": {
    "@type": "Organization",
    "name": "Social Animal"
  },
  "serviceType": "Web Development",
  "areaServed": "Worldwide",
  "url": "https://socialanimal.dev/capabilities/nextjs-development"
}

LocalBusiness

Das ermöglicht die 137.000 Veranstaltungsauflistungen von Not Another Sunday:

function buildLocalBusinessSchema(venue: Venue) {
  return {
    '@type': venue.type === 'restaurant' ? 'Restaurant' : 'LocalBusiness',
    name: venue.name,
    description: venue.description,
    image: venue.images[0],
    address: {
      '@type': 'PostalAddress',
      streetAddress: venue.address,
      addressLocality: venue.city,
      postalCode: venue.postcode,
      addressCountry: venue.country,
    },
    geo: {
      '@type': 'GeoCoordinates',
      latitude: venue.lat,
      longitude: venue.lng,
    },
    url: venue.website,
    telephone: venue.phone,
    priceRange: venue.priceRange,
    aggregateRating: venue.reviewCount > 0 ? {
      '@type': 'AggregateRating',
      ratingValue: venue.rating,
      reviewCount: venue.reviewCount,
    } : undefined,
  };
}

Product

{
  "@type": "Product",
  "name": "Headless CMS Development Package",
  "description": "Komplette Headless CMS Einrichtung mit Content Modeling und API Integration",
  "offers": {
    "@type": "Offer",
    "price": "5000",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://socialanimal.dev/pricing"
  }
}

HowTo

{
  "@type": "HowTo",
  "name": "Wie man Schema Markup zu Next.js App Router hinzufügt",
  "description": "Schritt-für-Schritt-Anleitung zur Implementierung von JSON-LD strukturierten Daten in Next.js Server-Komponenten",
  "step": [
    {
      "@type": "HowToStep",
      "name": "Erstelle eine JsonLd Komponente",
      "text": "Baue eine wiederverwendbare Server-Komponente, die ein Script-Tag mit type application/ld+json rendert"
    },
    {
      "@type": "HowToStep",
      "name": "Füge Layout-Level-Schema hinzu",
      "text": "Platziere Organization- und WebSite-Schema in deiner root layout.tsx"
    },
    {
      "@type": "HowToStep",
      "name": "Generiere Page-Level-Schema aus Daten",
      "text": "Baue Schema-Objekte aus deinem CMS oder Datenbankinhalten in jeder Seiten-Server-Komponente"
    }
  ]
}

Person

Verwendet auf den Prominentenprofilen von Deluxe Astrology:

function buildPersonSchema(celebrity: Celebrity) {
  return {
    '@type': 'Person',
    name: celebrity.name,
    description: celebrity.bio,
    image: celebrity.photo,
    birthDate: celebrity.birthDate,
    birthPlace: celebrity.birthPlace ? {
      '@type': 'Place',
      name: celebrity.birthPlace,
    } : undefined,
    nationality: celebrity.nationality,
    url: `https://deluxeastrology.com/celebrities/${celebrity.slug}`,
    sameAs: celebrity.externalLinks || [],
  };
}

Dynamisches Schema für programmatische Seiten

Hier wird es interessant. Wenn du 91.000+ Seiten hast, die von Supabase-Zeilen gestützt werden, brauchst du eine Pipeline, die Datenbankdatensätze ohne menschliche Eingriffe in gültiges JSON-LD umwandelt.

Hier ist unser eigentliches Muster:

// app/[lang]/horoscope/[sign]/[period]/page.tsx
import { createClient } from '@/lib/supabase/server';
import { JsonLd } from '@/components/json-ld';

export async function generateStaticParams() {
  const supabase = createClient();
  const { data: pages } = await supabase
    .from('horoscope_pages')
    .select('lang, sign, period');

  return (pages || []).map((p) => ({
    lang: p.lang,
    sign: p.sign,
    period: p.period,
  }));
}

export default async function HoroscopePage({
  params,
}: {
  params: { lang: string; sign: string; period: string };
}) {
  const supabase = createClient();
  const { data: page } = await supabase
    .from('horoscope_pages')
    .select('*')
    .eq('lang', params.lang)
    .eq('sign', params.sign)
    .eq('period', params.period)
    .single();

  if (!page) return notFound();

  const articleSchema = {
    '@type': 'Article',
    headline: page.title,
    description: page.meta_description,
    datePublished: page.published_at,
    dateModified: page.updated_at,
    inLanguage: page.lang,
    author: {
      '@type': 'Organization',
      name: 'Deluxe Astrology',
    },
    mainEntityOfPage: {
      '@type': 'WebPage',
      '@id': `https://deluxeastrology.com/${page.lang}/horoscope/${page.sign}/${page.period}`,
    },
  };

  const faqSchema = page.faqs?.length
    ? {
        '@type': 'FAQPage',
        mainEntity: page.faqs.map((faq: any) => ({
          '@type': 'Question',
          name: faq.q,
          acceptedAnswer: {
            '@type': 'Answer',
            text: faq.a,
          },
        })),
      }
    : null;

  return (
    <main>
      <JsonLd data={articleSchema} />
      {faqSchema && <JsonLd data={faqSchema} />}
      {/* Seiteninhalt */}
    </main>
  );
}

Die wichtigsten architektonischen Entscheidungen hier:

1. Schema wird zur Build-Zeit über SSG generiert — generateStaticParams erstellt alle 91.000+ Pfade, und das Schema jeder Seite wird in das statische HTML eingebacken.
2. Supabase-Zeile = Schema-Daten — Die Datenbank ist die einzelne Quelle der Wahrheit. Keine Inhalts-Abweichung zwischen dem, was sichtbar ist und dem, was im Schema ist.
3. Mehrere Schema-Blöcke pro Seite — Google unterstützt explizit mehrere JSON-LD-Script-Tags. Wir verwenden separate Blöcke für Article, FAQPage und BreadcrumbList auf der gleichen Seite.
4. ISR für Aktualität — Wir setzen revalidate = 3600, so dass Seiten stündlich ohne vollständige Redeploys neu erstellt werden.

Für die 25.000 Unternehmensprofile von HostList gilt das gleiche Muster, aber mit Organization-Schema, das aus jeder Unternehmens-Supabase-Zeile generiert wird. Für die 137.000 Veranstaltungen von Not Another Sunday ist es LocalBusiness.

Mehrsprachiges Schema mit inLanguage

Deluxe Astrology läuft in 30 Sprachen. Jeder Schema-Block enthält inLanguage, und wir verwenden hreflang-bewusste URLs:

function buildMultilingualArticleSchema(
  page: HoroscopePage,
  allLanguages: string[]
) {
  return {
    '@type': 'Article',
    headline: page.title,
    description: page.meta_description,
    inLanguage: page.lang,
    datePublished: page.published_at,
    dateModified: page.updated_at,
    author: {
      '@type': 'Organization',
      name: 'Deluxe Astrology',
    },
    // Teile Suchmaschinen über Übersetzungen mit
    workTranslation: allLanguages
      .filter((lang) => lang !== page.lang)
      .map((lang) => ({
        '@type': 'Article',
        inLanguage: lang,
        url: `https://deluxeastrology.com/${lang}/horoscope/${page.sign}/${page.period}`,
      })),
  };
}

Die inLanguage-Eigenschaft verwendet BCP 47 Sprachtags (en, fr, de, ja, etc.). Dies ist kritisch für mehrsprachige Websites — ohne es könnte Google die Sprache deiner strukturierten Daten falsch identifizieren und sie der falschen Zielgruppe zuordnen.

Validierungs- und Überwachungstools

Schema ohne Validierung auszuliefern ist wie das Bereitstellen ohne Tests. Hier ist unser Toolkit:

Tool	Zweck	Kosten	Wann zu verwenden
Google Rich Results Test	Validiert Berechtigung für Rich Results	Kostenlos	Vor dem Deploy, Spot Checks
Schema Markup Validator	Vollständige schema.org Spec-Validierung	Kostenlos	Erfasst Eigenschaftsfehler, die Googles Tool übersieht
Screaming Frog Custom Extraction	Crawlt Seite, extrahiert JSON-LD von jeder Seite	£199/Jahr (bezahlte Lizenz)	Massvalidierung über 91K+ Seiten
Google Search Console	Überwacht indiziertes Schema, zeigt Fehler	Kostenlos	Laufende Produktionsüberwachung
Rich Results Status reports	Zeigt, welche Seiten gültiges/ungültiges Schema haben	Kostenlos	Wöchentliche Überprüfung

Screaming Frog Custom Extraction für Schema im großen Maßstab

Das ist, wie du 91.000 Seiten validierst, ohne jede einzelne manuell zu überprüfen. In Screaming Frog:

1. Gehe zu Configuration → Custom → Extraction
2. Füge eine benutzerdefinierte Extraktion mit CSSPath hinzu: script[type="application/ld+json"]
3. Setze Extraktion auf "Extract Inner HTML"
4. Crawle deine Website
5. Exportiere und parse die JSON, um programmatisch zu validieren

Wir leiten den Export durch ein Node-Skript, das erforderliche Eigenschaften pro Schema-Typ prüft und alle Seiten mit fehlenden oder malformierten Daten kennzeichnet. Es erfasst Probleme wie leere headline-Felder oder Daten im falschen Format, bevor Google es tut.

Häufige Fehler, die deine Rich Results zerstören

Wir haben die meisten davon gemacht. Lern aus unserem Schmerz.

1. Schema-Inhalt stimmt nicht mit sichtbarem Inhalt überein. Wenn dein Article-Schema sagt, die Überschrift ist „Beste Restaurants in London", aber das eigentliche <h1> sagt etwas anderes, wird Google das Schema ignorieren oder bestrafen. Die Daten müssen widerspiegeln, was auf der Seite ist.

2. Verwende Schema-Typen für Seiten, die nicht qualifizieren. Klebe kein FAQPage-Schema auf eine Seite, die keinen FAQ-Inhalt tatsächlich anzeigt. Googles Manual Action Team erfasst dies, und die Strafe entfernt ALLE deine Rich Results, nicht nur die fehlerhaften Seiten.

3. Fehlende erforderliche Eigenschaften. Article benötigt headline und image. LocalBusiness benötigt name und address. Überprüfe die Google Structured Data Dokumentation auf Anforderungen pro Typ.

4. Rendering von Schema in Client-Komponenten. In Next.js App Router, wenn du JSON-LD in einer 'use client'-Komponente renderst, wird es nicht im initialen HTML sein. Googlebot wird normalerweise JS ausführen, aber andere Crawler (einschließlich einiger LLM-Crawler) werden es nicht. Verwende immer Server-Komponenten.

5. Dupliziertes Schema über verschachtelten Layouts. Wenn deine root layout.tsx und eine verschachtelte layout.tsx beide Organization-Schema rendern, wirst du Duplikate haben. Dedupliziere, indem du jede Schema-Typ nur auf der spezifischsten angemessenen Ebene platzierst.

6. Nicht escapen von Sonderzeichen in JSON. Wenn dein Artikel-Titel oder FAQ-Antwort unescapte Anführungszeichen oder spitzklammern enthält, bricht das JSON still kaputt. JSON.stringify() behandelt die meisten Fälle, aber achte auf Inhalte, die aus nutzergenerierter Daten gezogen werden.

7. Verwende veraltete oder nicht unterstützte Schema-Typen. Siehe den nächsten Abschnitt.

Google 2025-2026 Veraltete Funktionen und Änderungen

Google hat vorgegeben, welche Schema-Typen Rich Results auslösen:

• FAQPage Rich Results entfernt für die meisten Websites (August 2023, noch in Kraft): Nur Regierungs- und Gesundheitsbehördenseiten erhalten nun FAQ-Rich-Results in SERPs. ABER — und das ist entscheidend — Google liest und verarbeitet still FAQPage-Schema. Es zeigt nur das expandierbare FAQ nicht in Suchergebnissen für die meisten Websites an. Für LLM-Zitationszwecke ist das Schema immer noch Gold.
• HowTo Rich Results entfernt auf Mobil (September 2023, noch in Kraft): Desktop zeigt sie immer noch gelegentlich, aber Google hat HowTo-Rich-Results signifikant deprioritiert.
• Sitelinks Searchbox Veraltung (November 2024): Das WebSite-Schema's SearchAction garantiert nicht mehr ein Sitelinks-Suchfeld, aber Google kann es intern immer noch verwenden.
• AI Overviews priorisieren strukturierte Daten (2025-2026): Googles AI Overviews ziehen zunehmend von Seiten mit strukturierten Daten. Das Schema garantiert nicht den Einschluss, aber Seiten ohne es sind messbar weniger wahrscheinlich zitiert zu werden.

Unsere Empfehlung: Halte die Implementierung von FAQPage, HowTo und allen Schema-Typen auch, wenn Googles SERP-Funktionen reduziert wurden. Die Daten werden von mehreren Systemen konsumiert — Googles KI, ChatGPTs Browse-Modus, Perplexity, Bing Copilot. Der Wert erstreckt sich weit über traditionelle Rich Results hinaus.

Wenn du eine Headless-Website baust und Hilfe bei der Implementierung im großen Maßstab möchtest, überprüfe unsere Headless CMS Development Fähigkeiten oder kontaktiere uns.

FAQ

Funktioniert FAQPage-Schema noch für SEO 2026? Ja, aber anders als zuvor. Google entfernte FAQ-Rich-Results für die meisten Websites 2023, daher wirst du keine expandierbare FAQ-Snippets in Suchergebnissen sehen. Allerdings verarbeitet Google das Schema immer noch intern, und LLM-gestützte Suchwerkzeuge wie ChatGPT, Perplexity und Googles AI Overviews extrahieren aktiv Q&A-Paare aus FAQPage-Markup. Wir haben eine 4x Steigerung in LLM-Zitationen auf Seiten mit FAQPage-Schema versus ohne Schema gemessen.

Wie fügt man JSON-LD Schema Markup in Next.js App Router hinzu? Erstelle eine Server-Komponente, die ein <script type="application/ld+json"> Tag mit dangerouslySetInnerHTML mit JSON.stringify() auf deinem Schema-Objekt rendert. Platziere es in deiner Seiten-Server-Komponente — nie in einer Client-Komponente. Für Website-weit Schema wie Organization, platziere es in layout.tsx. Für Seiten-spezifisches Schema wie Article oder FAQPage, generiere es aus deinen Daten in jeder page.tsx.

Kannst du mehrere JSON-LD-Script-Tags auf einer Seite haben? Absolut. Google unterstützt explizit mehrere JSON-LD-Blöcke auf einer einzelnen Seite. Wir rendern routinemäßig separate Blöcke für Article, FAQPage, BreadcrumbList und Organization auf der gleichen Seite. Jeder erhält sein eigenes <script type="application/ld+json"> Tag mit seinem eigenen @context.

Wie generiert man Schema Markup für Tausende von programmatischen Seiten? Baue Schema-Objekte aus deinen Datenbankzeilen in Server-Komponenten. Wir verwenden generateStaticParams in Next.js, um Pfade für alle Seiten zu erstellen, dann fetcht jede Seiten-Server-Komponente ihre Daten aus Supabase und konstruiert das JSON-LD dynamisch. Das Schema wird zur Build-Zeit in statisches HTML eingebacken. Für 91.000 Seiten läuft dies während des Build-Prozesses mit ISR, das Updates verwaltet.

Was ist der Unterschied zwischen Article und BlogPosting Schema? BlogPosting ist ein Untertyp von Article. Verwende BlogPosting für Blog-Posts mit klarem Veröffentlichungsdatum und Autor. Verwende Article für allgemeinere redaktionelle Inhalte wie Nachrichtenartikel oder Leitfäden. In der Praxis behandelt Google sie fast identisch. Wir verwenden Article für die meisten Inhalte und BlogPosting nur für explizit blog-formatierte Posts.

Hilft Schema Markup bei Google AI Overviews? Ja. Seiten mit strukturierten Daten sind messbar wahrscheinlicher, in AI Overviews zitiert zu werden. Das Schema hilft Googles KI, Entitätsbeziehungen, Inhaltstyp und Datengenauigkeit zu verstehen. FAQPage-Schema ist besonders effektiv, weil es vorgeparsste Q&A-Paare bereitstellt, die die KI direkt extrahieren kann. Es ist keine Garantie des Einschlusses, aber es verbessert deine Chancen signifikant.

Welche Tools sollte ich verwenden, um Schema Markup im großen Maßstab zu validieren? Verwende für einzelne Seiten Googles Rich Results Test und den Schema Markup Validator unter validator.schema.org. Für Massvalidierung über Tausende von Seiten, verwende Screaming Frogs Custom Extraction-Funktion, um deine Website zu crawlen und alle JSON-LD zu extrahieren, dann führe die Ausgabe durch ein Validierungsskript aus. Überwache laufende Probleme in Googles Search Console's Structured Data Reports.

Sollte ich Schema-Typen implementieren, für die Google nicht mehr Rich Results zeigt? Ja. Googles SERP-Funktionen sind nur ein Konsument deiner strukturierten Daten. ChatGPT, Perplexity, Bing Copilot und andere KI-Systeme lesen alle Schema-Markup. Auch wenn Google Rich Results auf Mobil für HowTo nicht mehr zeigt, das Schema hilft immer noch LLMs, deinen Inhalt zu verstehen. Denke an strukturierte Daten als eine universelle maschinenlesbare Schicht, nicht nur eine Google-Funktion.