Anleitung März 2026

Schema.org Anleitung: Strukturierte Daten richtig implementieren

Strukturierte Daten sind der direkteste Weg um KI-Crawlern zu sagen was deine Website ist, was sie anbietet und warum sie vertrauenswürdig ist. Diese Anleitung zeigt Schritt für Schritt wie du Schema.org mit JSON-LD implementierst — vom ersten Markup bis zu den wichtigsten Typen für jede Art von Website.

Was ist Schema.org?

Schema.org ist ein gemeinsames Vokabular für strukturierte Daten im Web, das 2011 von Google, Microsoft, Yahoo und Yandex ins Leben gerufen wurde. Es definiert eine Sammlung von Typen und Eigenschaften — von "Person" über "Product" bis zu "FAQPage" — mit denen Website-Betreiber maschinenlesbare Beschreibungen ihrer Inhalte in den HTML-Code einbetten können.

Das Ziel ist einfach: Suchmaschinen und KI-Systeme sollen den Kontext einer Seite verstehen, nicht nur den Text. Ohne strukturierte Daten muss ein Crawler aus dem Fließtext erraten, ob "Apple" der Technologiekonzern oder die Frucht gemeint ist, wer der Autor eines Artikels ist und ob eine Bewertung das Produkt oder den Shop beschreibt. Mit Schema.org ist das eindeutig definiert.

Für KI-Sichtbarkeit besonders relevant: ChatGPT, Claude und Perplexity nutzen strukturierte Daten um Inhalte schneller und zuverlässiger zu klassifizieren. Eine Seite mit korrektem Schema.org-Markup wird mit höherer Wahrscheinlichkeit als vertrauenswürdige Quelle eingestuft und zitiert.

Warum JSON-LD das beste Format ist

Schema.org-Markup kann in drei Formaten eingebettet werden: JSON-LD, Microdata und RDFa. Google empfiehlt JSON-LD — und das aus gutem Grund:

Separation of concerns: JSON-LD wird im <head> oder <body> als separater Script-Block eingebettet und vermischt sich nicht mit dem HTML-Inhalt. Das macht es leichter zu pflegen.
Einfach zu aktualisieren: Änderungen am Markup erfordern keine Anpassung am sichtbaren HTML.
Klar lesbar: JSON-LD ist für Menschen gut lesbar und für Maschinen einfach parsebar.
Vollständige Google-Unterstützung: Alle Schema.org-Features die Google unterstützt, funktionieren mit JSON-LD.

Microdata und RDFa sind direkt in den HTML-Tags eingebettet — das macht sie schwerer zu warten und fehleranfälliger. Für neue Implementierungen sollte ausschließlich JSON-LD verwendet werden.

Die Grundstruktur von JSON-LD

Ein JSON-LD-Block wird als <script>-Tag mit dem Typ "application/ld+json" in den <head> oder <body> der Seite eingebettet. Hier ist die minimale Grundstruktur:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "WebPage",
  "name": "Seitenname",
  "url": "https://example.com/seite/"
}
</script>

Jedes JSON-LD-Objekt hat mindestens zwei Pflichtfelder: @context (immer "https://schema.org") und @type (der Schema.org-Typ). Alle weiteren Felder sind typspezifisch.

Eine Seite kann mehrere JSON-LD-Blöcke enthalten — entweder als separate <script>-Tags oder als Array innerhalb eines Tags. Mehrere Typen pro Seite sind nicht nur erlaubt, sondern empfohlen.

Die wichtigsten Schema.org-Typen

Schema.org kennt über 800 Typen — von "MedicalCondition" bis "VideoGame". Für die meisten Websites sind jedoch nur eine Handvoll Typen wirklich relevant:

Organization

Grundlegende Informationen über das Unternehmen oder den Betreiber. Pflicht für jede Website.

WebPage / WebApplication

Beschreibt eine einzelne Seite oder Web-App. Ideal für Unterseiten und Tools.

Article

Für Blogposts, Guides und redaktionelle Inhalte. Verbessert die Zitierbarkeit.

FAQPage

Für Frage-Antwort-Inhalte. Besonders wirksam für KI-Sichtbarkeit.

BreadcrumbList

Zeigt die Seitenstruktur. Hilft Crawlern die Hierarchie zu verstehen.

Product

Für E-Commerce-Produkte mit Preis, Bewertungen und Verfügbarkeit.

LocalBusiness

Für lokale Unternehmen mit Adresse, Öffnungszeiten und Telefonnummer.

Person

Für Autorenprofile und persönliche Websites. Stärkt E-E-A-T-Signale.

Organization — für jede Website Pflicht

Der Organization-Typ sollte auf jeder Website vorhanden sein — idealerweise auf der Startseite. Er definiert wer hinter der Website steckt und schafft Vertrauen bei KI-Systemen.

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Mein Unternehmen",
  "url": "https://example.com",
  "logo": "https://example.com/logo.png",
  "description": "Kurze Beschreibung des Unternehmens",
  "contactPoint": {
    "@type": "ContactPoint",
    "email": "[email protected]",
    "contactType": "customer service"
  },
  "sameAs": [
    "https://twitter.com/meinunternehmen",
    "https://linkedin.com/company/meinunternehmen"
  ]
}

Das Feld sameAs ist besonders wertvoll: Es verknüpft deine Website mit deinen Social-Media-Profilen und anderen verifizierten Quellen. Das stärkt das Vertrauen von KI-Systemen in deine Organisation erheblich.

WebPage und WebApplication

Für jede wichtige Unterseite sollte ein WebPage-Markup vorhanden sein. Es beschreibt den Zweck der Seite und verknüpft sie mit der übergeordneten Website-Struktur.

{
  "@context": "https://schema.org",
  "@type": "WebPage",
  "name": "Seitenname",
  "url": "https://example.com/seite/",
  "description": "Kurze Beschreibung der Seite",
  "inLanguage": "de-DE",
  "isPartOf": {
    "@type": "WebSite",
    "name": "Website-Name",
    "url": "https://example.com"
  }
}

Für Tools und interaktive Anwendungen ist WebApplication der passendere Typ als WebPage:

{
  "@context": "https://schema.org",
  "@type": "WebApplication",
  "name": "Tool-Name",
  "url": "https://example.com/tools/mein-tool/",
  "applicationCategory": "DeveloperApplication",
  "operatingSystem": "Web",
  "offers": {
    "@type": "Offer",
    "price": "0",
    "priceCurrency": "EUR"
  }
}

Article — für Blogs und Guides

Für Blogposts, Guides und redaktionelle Inhalte ist der Article-Typ entscheidend. Er definiert Autor, Veröffentlichungsdatum und Herausgeber — alles Informationen die KI-Systeme zur Bewertung der Vertrauenswürdigkeit nutzen.

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Titel des Artikels",
  "description": "Kurze Beschreibung des Artikels",
  "url": "https://example.com/blog/artikel/",
  "datePublished": "2026-03-01",
  "dateModified": "2026-03-15",
  "author": {
    "@type": "Person",
    "name": "Max Mustermann",
    "url": "https://example.com/autor/max/"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Mein Unternehmen",
    "url": "https://example.com"
  },
  "inLanguage": "de-DE"
}

Das Feld dateModified ist besonders wichtig: Es signalisiert KI-Systemen dass der Inhalt aktuell gehalten wird. Veraltete Inhalte ohne Aktualisierungsdatum werden seltener als aktuelle Quellen zitiert.

FAQPage — besonders KI-wirksam

FAQPage ist einer der wirksamsten Schema.org-Typen für KI-Sichtbarkeit. KI-Systeme wie ChatGPT und Perplexity sind darauf ausgelegt, Fragen zu beantworten — und FAQ-Markup liefert genau das in maschinenlesbarer Form.

Tipp: FAQPage-Markup ist nicht nur für dedizierte FAQ-Seiten geeignet. Füge am Ende jedes Guides oder Blogposts 3-5 häufige Fragen mit Antworten ein und markiere sie mit FAQPage-Markup. Das erhöht die Chance erheblich in KI-Antworten zitiert zu werden.

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Was ist Schema.org?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Schema.org ist ein Vokabular für strukturierte Daten, das von Google, Microsoft, Yahoo und Yandex entwickelt wurde. Es ermöglicht Website-Betreibern maschinenlesbare Beschreibungen ihrer Inhalte in HTML einzubetten."
      }
    },
    {
      "@type": "Question",
      "name": "Welches Format sollte ich für Schema.org verwenden?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Google empfiehlt JSON-LD. Es ist einfacher zu implementieren und zu pflegen als die Alternativen Microdata und RDFa."
      }
    }
  ]
}

BreadcrumbList hilft Crawlern die Hierarchie deiner Website zu verstehen. Es zeigt wie eine Seite in die Gesamtstruktur eingebettet ist — von der Startseite über Kategorien bis zur aktuellen Seite.

{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://example.com/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Guides",
      "item": "https://example.com/guides/"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Schema.org Anleitung",
      "item": "https://example.com/guides/schema-org/"
    }
  ]
}

Häufige Fehler vermeiden

Diese Fehler treten bei der Schema.org-Implementierung besonders häufig auf:

Falsches JSON-Format: Fehlende Kommas, nicht geschlossene Klammern oder fehlende Anführungszeichen machen das gesamte Markup ungültig. JSON ist fehlerintolerant — ein einzelner Syntaxfehler deaktiviert das komplette Markup.
@context vergessen: Ohne "@context": "https://schema.org" wird das Markup von Crawlern nicht als Schema.org erkannt.
Inhalt und Markup stimmen nicht überein: Der im Markup angegebene Inhalt muss tatsächlich auf der Seite sichtbar sein. Schema.org das Inhalte behauptet die nicht auf der Seite stehen, wird von Google als Spam gewertet.
Falsche URL-Formate: URLs müssen vollständig sein (mit https://) und auf tatsächlich existierende Seiten verweisen.
Zu viele Typen auf einmal: Starte mit Organization und WebPage, dann erweitere schrittweise. Fehlerhafte Implementierungen sind schlechter als gar kein Markup.

Wichtig: Schema.org-Markup das Inhalte beschreibt die nicht auf der Seite zu finden sind ("cloaking"), wird von Google als Spam gewertet und kann zu Abstrafungen führen. Markup und sichtbarer Inhalt müssen übereinstimmen.

Schema.org testen und validieren

Bevor du Schema.org-Markup live schaltest, solltest du es validieren. Folgende Tools helfen dabei:

Google Rich Results Test (search.google.com/test/rich-results) — Zeigt ob Google das Markup erkennt und ob Rich Snippets möglich sind.
Schema.org Validator (validator.schema.org) — Validiert das Markup gegen die offizielle Schema.org-Spezifikation.
Google Search Console — Zeigt nach dem Deployment welche strukturierten Daten Google auf deiner Website gefunden hat und ob Fehler vorliegen.

Nach dem Deployment dauert es in der Regel einige Tage bis Google das neue Markup crawlt und in der Search Console anzeigt. AI-Crawler wie GPTBot crawlen weniger häufig — es kann Wochen dauern bis Änderungen dort wirksam werden.

Schnell-Checkliste für die Implementierung

Organization-Markup auf der Startseite implementieren
WebPage oder WebApplication für alle wichtigen Unterseiten
Article-Markup für alle Blogposts und Guides
FAQPage-Markup für Seiten mit Fragen und Antworten
BreadcrumbList für tiefere Seitenebenen
JSON mit einem Online-Validator auf Syntaxfehler prüfen
Mit Google Rich Results Test validieren
Nach Deployment in Search Console auf Fehler prüfen

Wie gut ist dein Schema.org-Markup?

Der AI-Ready Check analysiert deine strukturierten Daten und zeigt dir konkret was fehlt — kostenlos, in 30 Sekunden.

Jetzt kostenlos testen →

Häufig gestellte Fragen zu Schema.org

Muss ich alle Schema.org-Typen implementieren?+

Nein — fange mit den wichtigsten Typen für deine Website an. Organization und WebPage sind für jede Website sinnvoll. Article ist wichtig wenn du Blogposts oder Guides veröffentlichst. FAQPage lohnt sich immer wenn du Fragen und Antworten auf deiner Seite hast. Starte klein und erweitere schrittweise.

Verbessert Schema.org direkt mein Google-Ranking?+

Schema.org ist kein direkter Rankingfaktor bei Google — zumindest nicht explizit. Es ermöglicht jedoch Rich Snippets in den Suchergebnissen, die die Klickrate erheblich verbessern können. Außerdem hilft es Google den Inhalt besser zu verstehen, was indirekt die Relevanz für bestimmte Suchanfragen verbessern kann.

Kann ich Schema.org auch ohne CMS oder Plugin implementieren?+

Ja — JSON-LD ist reines HTML und kann in jede Seite direkt eingebettet werden. Kein Plugin oder CMS nötig. Du fügst einfach einen <script type="application/ld+json">-Block in den <head> deiner HTML-Datei ein.

Wie viele JSON-LD-Blöcke darf eine Seite haben?+

Es gibt keine offizielle Obergrenze. Eine Seite kann mehrere separate <script type="application/ld+json">-Blöcke haben — zum Beispiel einen für Organization, einen für WebPage und einen für FAQPage. Das ist vollkommen valide und sogar empfohlen um die Lesbarkeit zu verbessern.

Wie lange dauert es bis Schema.org in Google sichtbar wird?+

Nachdem du Schema.org implementiert hast, dauert es in der Regel einige Tage bis Google die Seite neu crawlt und das Markup erkennt. In der Google Search Console unter "Verbesserungen" siehst du dann welche strukturierten Daten gefunden wurden. Rich Snippets können erst erscheinen wenn Google das Markup als valide und relevant eingestuft hat — das kann mehrere Wochen dauern.