JSON-LD Schema Markup: Umfassender SEO-Implementierungsleitfaden

Letzte Aktualisierung 28.03.2026
Strukturierte Daten Erweiterte Suchergebnisse

JSON-LD strukturierte Daten geben Suchmaschinen klare Informationen zu Ihrem Inhalt. Das passende Schema-Markup ermöglicht erweiterte Suchergebnisse bei Google — FAQ-Dropdowns, Artikelkarussells, Breadcrumbs und mehr direkt in den Suchergebnissen.

Dieser Leitfaden behandelt alle wichtigen Schema-Typen mit echtem C#-Code und dem genauen JSON-Ausgabeformat. Alle Beispiele stammen direkt aus einer produktiven Blazor-Codebasis.

Artikel-Schema ansehen Implementierungsmuster
Abbildung zeigt JSON-LD strukturierte Daten, die erweiterte Suchergebnisse bei Google ermöglichen, inklusive FAQ-Dropdowns, Artikelkarussells und Breadcrumb-Navigation
JSON-LD strukturierte Daten sind die wartungsfreundlichste Methode für Schema-Markup — sie liegen in einem Script-Tag, völlig getrennt vom HTML.
Inhaltsverzeichnis

Was ist JSON-LD und warum es für SEO wichtig ist

JSON-LD (JavaScript Object Notation for Linked Data) ist eine Methode, strukturierte Daten im JSON-Format zu kodieren. Suchmaschinen wie Google lesen diese Daten, um den Inhalt und nicht nur die Schlüsselwörter zu verstehen.

Wenn Google Ihre strukturierten Daten auswerten kann, qualifizieren Sie sich für erweiterte Suchergebnisse — optisch verbesserte Einträge mit Bewertungen, FAQ-Dropdowns, Artikelbildern, Breadcrumbs und weiteren Funktionen direkt in den Suchergebnissen. Diese erzielen deutlich höhere Klickraten als einfache Links.

Google empfiehlt offiziell JSON-LD statt Microdata oder RDFa, da es überall auf der Seite, auch im Head, platziert werden kann und keine Änderungen am HTML erfordert. Die strukturierten Daten sind vollständig vom Markup getrennt.

Berechtigung für erweiterte Suchergebnisse

Gültiges Schema-Markup macht Ihre Seiten für FAQ-Dropdowns, Artikelkarussells, Breadcrumbs und weitere erweiterte Funktionen in der Google-Suche berechtigt.

Mehr Klicks bei gleichem Ranking

Semantische Klarheit

Strukturierte Daten beseitigen Mehrdeutigkeiten. Eine Seite mit Frage-Antwort-Themen wird als FAQPage deklariert, sodass Google sie als FAQ-Ergebnis anzeigt.

Sagen Sie Suchmaschinen genau, was Sie bieten

Keine HTML-Änderungen

JSON-LD befindet sich in einem Script-Tag im Head. Es beeinflusst nie das sichtbare HTML, sodass Schema-Ergänzungen keine Layout- oder Zugänglichkeitsprobleme verursachen.

Klare Trennung der Verantwortlichkeiten

JSON-LD vs. Microdata vs. RDFa

Es gibt drei Formate, um schema.org strukturierte Daten in Webseiten einzubetten. Google versteht alle, aber sie unterscheiden sich stark in Anwendung und Wartung.

Format Syntax-Position Wartung SEO-Auswirkung Google-Empfehlung
JSON-LD Separates Script-Tag Einfach — keine HTML-Änderungen Volle Unterstützung erweiterter Ergebnisse Empfohlen
Microdata Inline-HTML-Attribute Hoch — eng an Markup gebunden Volle Unterstützung erweiterter Ergebnisse Unterstützt
RDFa Inline-HTML-Attribute Hoch — eng an Markup gebunden Volle Unterstützung erweiterter Ergebnisse Unterstützt

Warum JSON-LD in Wartbarkeit gewinnt

Bei Microdata und RDFa sind Schema-Attribute im HTML verstreut. Designänderungen können strukturierte Daten unbemerkt zerstören. JSON-LD ist ein eigenständiger Block — ein Update im Script genügt, ohne HTML zu beeinflussen.

Empfohlener Webentwicklungs-Kurs

Moderne Webentwicklung mit SEO Best Practices meistern

Mein Tipp Dieser Kurs hilft Ihnen, technische SEO, strukturierte Daten und moderne Webstandards praxisnah zu verstehen.

  • Lernen Sie die Umsetzung von HTML-Meta-Tags, Open Graph und JSON-LD strukturierten Daten.
  • Praktische SEO-Strategien für bessere Sichtbarkeit und Rankings in Suchmaschinen.
  • Praxisprojekte zu Responsive Design und Performance-Optimierung.
Kurs Webentwicklung entdecken

Wichtige Schema-Typen und ihre Anwendung

Schema.org definiert Hunderte Typen, doch wenige decken den Großteil der Webinhalte ab. Diese ermöglichen erweiterte Suchergebnisse bei Google.

Schema-Typ Anwendungsfall Typ des erweiterten Ergebnisses
Article Blogbeiträge, Anleitungen, Nachrichtenartikel Artikelkarussell, Top-Meldungen
FAQPage Seiten mit Frage-Antwort-Paaren FAQ-Dropdown in Suchergebnissen
BreadcrumbList Seiten mit Navigationshierarchie Breadcrumb-Pfad unter der URL
WebSite / WebPage Startseite, Hub-Seiten, Landingpages Sitelinks-Suchfeld, Entitätserkennung
SoftwareApplication Apps, Tools, Softwareprodukte App-Ergebnis mit Bewertung und Preis

Schema.org Vokabular

Alle Schema-Typen sind bei schema.org definiert. Die @context-Eigenschaft in jedem JSON-LD-Block weist Parser an, Eigenschaftsnamen anhand des schema.org Vokabulars zu interpretieren. Mehrere Schema-Typen auf einer Seite sind möglich — Google verarbeitet jeden Block separat.

Implementierung des Artikel-Schemas

Das Artikel-Schema ist der wichtigste Typ für inhaltsorientierte Seiten. Es übermittelt Google Überschrift, Beschreibung, Veröffentlichungsdatum, Autor und Herausgeber — die Mindestangaben für erweiterte Suchergebnisse.

Die folgende C#-Klasse ist das Serialisierungsmodell. Jede Eigenschaft entspricht direkt dem JSON-LD-Feld mit JsonPropertyName-Attributen.

C#ArticleSchema C#-Klasse (JsonLdService.cs)
private class ArticleSchema
{
    [JsonPropertyName("@context")]
    public string Context { get; } = "https://schema.org";

    [JsonPropertyName("@type")]
    public string Type { get; } = "Article";

    [JsonPropertyName("headline")]
    public string? Headline { get; set; }

    [JsonPropertyName("description")]
    public string? Description { get; set; }

    [JsonPropertyName("image")]
    public string? Image { get; set; }

    [JsonPropertyName("url")]
    public string? Url { get; set; }

    [JsonPropertyName("author")]
    public Organization? Author { get; set; }

    [JsonPropertyName("publisher")]
    public ArticlePublisher? Publisher { get; set; }

    [JsonPropertyName("datePublished")]
    public string? DatePublished { get; set; }

    [JsonPropertyName("dateModified")]
    public string? DateModified { get; set; }

    [JsonPropertyName("articleSection")]
    public List<string>? ArticleSection { get; set; }
}

Erforderliche Eigenschaften sind: headline, image, datePublished, dateModified, author und publisher. Das Array articleSection ist optional, aber empfohlen — es signalisiert Googles thematischen Umfang des Artikels.

HTMLJSON-LD-Ausgabe des Artikel-Schemas
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "JSON-LD Schema Markup: Complete SEO Implementation Guide",
  "description": "Learn how to implement JSON-LD structured data for Article, FAQPage, BreadcrumbList, WebSite, and WebPage schema types.",
  "image": "https://ghostlyinc.com/images/web/jsonldguide/opengraph/hero-1200.png",
  "url": "https://ghostlyinc.com/en/json-ld-schema-markup-seo-guide/",
  "author": {
    "@type": "Organization",
    "name": "GhostlyInc",
    "url": "https://ghostlyinc.com"
  },
  "publisher": {
    "@type": "Organization",
    "name": "GhostlyInc",
    "logo": {
      "@type": "ImageObject",
      "url": "https://ghostlyinc.com/images/logo.png"
    }
  },
  "datePublished": "2026-03-28T10:00:00Z",
  "dateModified": "2026-03-28T10:00:00Z",
  "articleSection": [
    "What is JSON-LD and why it matters for SEO",
    "JSON-LD vs. Microdata vs. RDFa",
    "Core schema types and when to use them",
    "Article schema implementation"
  ]
}
</script>

Autor und Herausgeber sind als Organization typisiert. Bei persönlichen Blogs kann der Autor auch eine Person mit Name und URL sein.

FAQ-Schema für Rich Snippets

Das FAQPage-Schema erzeugt FAQ-Ergebnisse — erweiterbare Frage-Antwort-Paare, die direkt unter Ihrem Eintrag in den Google-Suchergebnissen angezeigt werden. Dies erhöht die Sichtbarkeit und Klickrate deutlich.

Die FaqPage-Klasse enthält eine Liste von Fragen. Jede Frage muss einen Namen (Frage) und eine acceptedAnswer mit Text (Antwort) haben.

C#FaqPage C#-Klasse (JsonLdService.cs)
private class FaqPage
{
    [JsonPropertyName("@context")]
    public string Context { get; } = "https://schema.org";

    [JsonPropertyName("@type")]
    public string Type { get; } = "FAQPage";

    [JsonPropertyName("@id")]
    public string? Id { get; set; }

    [JsonPropertyName("name")]
    public string? Name { get; set; }

    [JsonPropertyName("mainEntity")]
    public List<FaqEntity>? MainEntity { get; set; }
}

private class FaqEntity
{
    [JsonPropertyName("@type")]
    public string Type { get; } = "Question";

    [JsonPropertyName("name")]
    public string? Name { get; set; }

    [JsonPropertyName("acceptedAnswer")]
    public FaqAnswer? AcceptedAnswer { get; set; }
}

private class FaqAnswer
{
    [JsonPropertyName("@type")]
    public string Type { get; } = "Answer";

    [JsonPropertyName("text")]
    public string? Text { get; set; }
}

Die Ausgabe ist ein einzelner FAQPage-Block mit einem mainEntity-Array. Jedes Element ist ein Question-Typ mit acceptedAnswer. Google unterstützt bis zu zehn Fragen pro Seite für erweiterte Ergebnisse.

HTMLJSON-LD-Ausgabe des FAQ-Schemas
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "@id": "https://ghostlyinc.com/en/json-ld-schema-markup-seo-guide/#faq",
  "name": "Frequently asked questions",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is the difference between JSON-LD and Microdata?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "JSON-LD is a separate script block that lives in the head and does not touch HTML. Microdata adds attributes directly to HTML elements. Google recommends JSON-LD for its maintainability."
      }
    },
    {
      "@type": "Question",
      "name": "How many FAQ questions can I mark up?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Google supports up to ten questions per page for the FAQ rich result. Additional questions are still valid schema but will not appear in the search result enhancement."
      }
    }
  ]
}
</script>

Die @id im FAQPage-Block verankert das Schema an einem bestimmten URL-Fragment. Dies ist Best Practice bei mehreren Schema-Blöcken, um eindeutige Identifikation zu gewährleisten.

WebSite- und WebPage-Schema

WebSite- und WebPage-Schema bilden das grundlegende Entitätsmodell einer Website. WebSite definiert die Seite mit Name, URL, Sprache und Herausgeber. WebPage beschreibt die einzelne Seite und verknüpft sie mit der übergeordneten WebSite via isPartOf.

Beide Klassen folgen dem gleichen JSON-LD-Muster. Die @id bei WebSite ist die Domain-Root, bei WebPage die vollständige Seiten-URL.

C#WebSiteSchema und WebPageSchema C#-Klassen (JsonLdService.cs)
private class WebSiteSchema
{
    [JsonPropertyName("@context")]
    public string Context { get; } = "https://schema.org";

    [JsonPropertyName("@type")]
    public string Type { get; } = "WebSite";

    [JsonPropertyName("name")]
    public string? Name { get; set; }

    [JsonPropertyName("url")]
    public string? Url { get; set; }

    [JsonPropertyName("inLanguage")]
    public string? InLanguage { get; set; }

    [JsonPropertyName("publisher")]
    public Organization? Publisher { get; set; }
}

private class WebPageSchema
{
    [JsonPropertyName("@context")]
    public string Context { get; } = "https://schema.org";

    [JsonPropertyName("@type")]
    public string Type { get; } = "WebPage";

    [JsonPropertyName("@id")]
    public string? Id { get; set; }

    [JsonPropertyName("name")]
    public string? Name { get; set; }

    [JsonPropertyName("description")]
    public string? Description { get; set; }

    [JsonPropertyName("url")]
    public string? Url { get; set; }

    [JsonPropertyName("inLanguage")]
    public string? InLanguage { get; set; }

    [JsonPropertyName("isPartOf")]
    public WebSiteReference? IsPartOf { get; set; }
}

Die Eigenschaft inLanguage verwendet BCP 47 Sprachcodes (z.B. en, de, fr). Der isPartOf-Link verbindet die WebPage mit der WebSite über die Domain-@id. Das hilft Google, ein vollständiges Entitätsmodell Ihrer Seite zu erstellen.

HTMLJSON-LD-Ausgabe des WebSite- und WebPage-Schemas
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "WebSite",
  "name": "GhostlyInc",
  "url": "https://ghostlyinc.com",
  "inLanguage": "en",
  "publisher": {
    "@type": "Organization",
    "name": "GhostlyInc",
    "url": "https://ghostlyinc.com"
  }
}
</script>

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "WebPage",
  "@id": "https://ghostlyinc.com/en/json-ld-schema-markup-seo-guide/",
  "name": "JSON-LD Schema Markup: Complete SEO Implementation Guide",
  "description": "Learn how to implement JSON-LD structured data for Article, FAQPage, BreadcrumbList, WebSite, and WebPage schema types.",
  "url": "https://ghostlyinc.com/en/json-ld-schema-markup-seo-guide/",
  "inLanguage": "en",
  "isPartOf": {
    "@type": "WebSite",
    "@id": "https://ghostlyinc.com"
  }
}
</script>

Best Practices für die Implementierung

Die Hilfsmethode WrapInScriptTag ist der zentrale Punkt, an dem JSON-Strings zu gültigen JSON-LD-Blöcken werden. Sie umschließt das serialisierte Schema mit dem erforderlichen Script-Tag und dem MIME-Typ application/ld+json.

Diese Methode wird von allen Schema-Buildern im Service aufgerufen — Article, FAQPage, BreadcrumbList, WebSite und WebPage übergeben ihr serialisiertes JSON an diese Utility.

C#WrapInScriptTag-Methode (JsonLdService.cs)
private static MarkupString WrapInScriptTag(string json)
{
    var builder = new StringBuilder();
    builder.AppendLine("<script type=\"application/ld+json\">");
    builder.AppendLine(json);
    builder.AppendLine("</script>");

    return new MarkupString(builder.ToString());
}

Das SchemaContext-Objekt ist der Einstiegspunkt für die BuildSchema-Methode. Es enthält alle Daten, um die vollständigen Schema-Blöcke für eine Seite zu erstellen — Typ, Metadaten, FAQ-Liste, Breadcrumb-Hierarchie und Artikeldaten.

C#BuildSchema-Dispatch-Logik (JsonLdService.cs)
public SchemaBuildResult BuildSchema(SchemaContext context)
{
    if (context == null) throw new ArgumentNullException(nameof(context));

    var jsonLd = new List<MarkupString>();

    switch (context.PageType)
    {
        case PageSchemaType.Home:
            jsonLd.Add(WebSite(context));
            jsonLd.Add(WebPage(context));
            break;
        case PageSchemaType.Article:
            jsonLd.Add(Article(context.Article!));
            break;
        case PageSchemaType.Tool:
            jsonLd.Add(WebPage(context));
            jsonLd.Add(SoftwareApplication(context.SoftwareApplication!));
            break;
        case PageSchemaType.Hub:
            jsonLd.Add(WebPage(context));
            break;
    }

    if (context.Faqs != null && context.Faqs.Count > 0)
    {
        jsonLd.Add(FAQ(context.Faqs.ToList(), context.FaqTitle, context.Url));
    }

    if (context.ParentHierarchy.Count > 0)
    {
        jsonLd.Add(BreadcrumbList(BuildBreadcrumbItems(context)));
    }

    return new SchemaBuildResult(jsonLd, context.PageType == PageSchemaType.Article);
}

Der Dispatch-Switch macht den Schema-Builder modular. FAQs und Breadcrumbs werden immer angehängt, wenn vorhanden, unabhängig vom Seitentyp. So kann jeder Seitentyp FAQ- oder Breadcrumb-Blöcke erhalten, ohne die Kernlogik zu ändern.

Testen und Validieren Ihres Schemas

Gültige JSON-LD-Syntax garantiert keine Berechtigung für erweiterte Ergebnisse. Googles Tools prüfen Syntax und ob Ihr Inhalt die Richtlinien für jeden Ergebnis-Typ erfüllt.

Test für erweiterte Suchergebnisse

Nutzen Sie search.google.com/test/rich-results, um URLs oder HTML zu prüfen. Google zeigt an, welche erweiterten Ergebnisse erkannt wurden und welche erforderlichen Eigenschaften fehlen.

Googles offizieller Berechtigungsprüfer

Schema-Markup-Validator

validator.schema.org prüft Ihr Markup unabhängig von Googles Richtlinien anhand der schema.org-Spezifikation. Nützlich zum Erkennen von Tippfehlern und Typfehlern.

Syntaxprüfung für schema.org

Google Search Console

Der Bereich „Verbesserungen“ in der Search Console meldet Schema-Fehler und Warnungen für Ihre indexierten Seiten. Nutzen Sie ihn zur kontinuierlichen Überwachung nach der Erstvalidierung.

Skalierte Überwachung nach dem Launch

Häufig gestellte Fragen

Antworten auf häufige Fragen zum JSON-LD Schema-Markup