JSON-LD Schema Markup: Komplett guide för SEO-implementering

Senast uppdaterad 2026-03-28
Strukturerad data Rika resultat

JSON-LD strukturerad data berättar för sökmotorer exakt vad ditt innehåll handlar om. Rätt schema markup ger rika resultat i Google Sök — FAQ-menyer, artikelkaruseller, brödsmulor med mera — direkt i sökresultatet.

Denna guide täcker alla viktiga schema-typer med verklig C#-kod och exakt JSON-utdata. Alla exempel kommer direkt från en produktionsklar Blazor-kodbas.

Se artikelschema Implementeringsmönster
Illustration som visar JSON-LD strukturerad data som ger rika resultat i Google Sök, inklusive FAQ-menyer, artikelkaruseller och brödsmulenavigering
JSON-LD strukturerad data är det mest underhållsvänliga sättet att lägga till schema markup — den finns i en script-tagg, helt separat från din HTML.
Innehållsförteckning

Vad är JSON-LD och varför det är viktigt för SEO

JSON-LD (JavaScript Object Notation for Linked Data) är en metod för att koda strukturerad data med JSON-formatet. Sökmotorer som Google läser denna data för att förstå innehållets mening, inte bara nyckelorden.

När Google kan tolka din strukturerade data blir sidan berättigad till rika resultat — visuellt förbättrade söklistor som visar betyg, FAQ-menyer, artikelbilder, brödsmulor och andra funktioner direkt i sökresultatet. Rika resultat ger konsekvent högre klickfrekvens än vanliga länkar.

Google rekommenderar officiellt JSON-LD framför Microdata och RDFa eftersom det kan placeras var som helst på sidan — inklusive i head — och kräver inga ändringar i befintliga HTML-element. Den strukturerade datan är helt frikopplad från din markup.

Behörighet för rika resultat

Giltig schema markup gör dina sidor berättigade till FAQ-menyer, artikelkaruseller, brödsmulor och andra rika funktioner i Google Sök.

Fler klick från samma ranking

Semantisk tydlighet

Strukturerad data eliminerar tvetydighet. En sida med frågor och svar deklareras tydligt som en FAQPage, så Google vet att visa den som ett rikt FAQ-resultat.

Berätta exakt vad du har för sökmotorerna

Inga HTML-ändringar

JSON-LD finns i en script-tagg i head. Den påverkar aldrig din visuella HTML, så att lägga till eller uppdatera schema riskerar aldrig att bryta layout eller tillgänglighet.

Tydlig ansvarsfördelning

JSON-LD vs. Microdata vs. RDFa

Det finns tre format för att bädda in schema.org strukturerad data i webbsidor. Alla tre förstås av Google, men skiljer sig avsevärt i hur de används och underhålls.

Format Syntaxplacering Underhåll SEO-effekt Googles rekommendation
JSON-LD Separat script-tagg Enkelt — inga HTML-ändringar Fullt stöd för rika resultat Rekommenderat
Microdata Inline HTML-attribut Högt — tätt kopplat till markup Fullt stöd för rika resultat Stöds
RDFa Inline HTML-attribut Högt — tätt kopplat till markup Fullt stöd för rika resultat Stöds

Varför JSON-LD är bäst för underhåll

Med Microdata och RDFa är schemaattribut utspridda i din HTML. En designändring som omstrukturerar en mall kan tyst bryta strukturerad data. JSON-LD är en självständig block — uppdatera scriptet en gång utan att påverka HTML.

Utvald webbutvecklingskurs

Bemästra modern webbutveckling med SEO-bästa praxis

Tips från mig Jag tyckte kursen var värdefull för att förstå hur teknisk SEO, strukturerad data och moderna webbstandarder samverkar i verkliga projekt.

  • Lär dig HTML-meta-taggar, Open Graph och implementering av JSON-LD strukturerad data.
  • Praktiska SEO-strategier för bättre synlighet och placering i sökmotorer.
  • Praktiska projekt som täcker responsiv design och prestandaoptimering.
Utforska webbutvecklingskursen

Viktiga schema-typer och när de används

Schema.org definierar hundratals typer men ett fåtal täcker majoriteten av webbinnehåll. Dessa typer ger rika resultat i Google Sök.

Schema-typ Användningsfall Typ av rikt resultat
Article Blogginlägg, guider, nyhetsartiklar Artikelkarusell, toppnyheter
FAQPage Sidor med frågor och svar FAQ-meny i sökresultat
BreadcrumbList Sida med navigationshierarki Brödsmulor under URL
WebSite / WebPage Startsida, navsidor, landningssidor Sökfält för sitelänkar, entitetsigenkänning
SoftwareApplication Appar, verktyg, mjukvaruprodukter Rikt appresultat med betyg och pris

Schema.org vokabulär

Alla schema-typer definieras på schema.org. @context-egenskapen i varje JSON-LD-block talar om för tolkar att tolka egenskapsnamn enligt schema.org vokabulär. Du kan kombinera flera schema-typer på en sida — Google behandlar varje scriptblock separat.

Implementering av artikelschema

Artikelschema är den viktigaste typen för innehållsdrivna sajter. Den berättar för Google rubrik, beskrivning, publiceringsdatum, författare och utgivare — minimikravet för att bli berättigad till rika resultat.

C#-klassen nedan är serialiseringsmodellen. Varje egenskap motsvarar direkt ett JSON-LD-fält med JsonPropertyName-attribut.

C#ArticleSchema C#-klass (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; }
}

Obligatoriska egenskaper är: headline, image, datePublished, dateModified, author och publisher. articleSection-arrayen är valfri men rekommenderad — den visar artikelns ämnesområde för Google.

HTMLJSON-LD-utdata för artikelschema
<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>

Författare och utgivare är båda av typen Organization. För personliga bloggar kan författaren istället vara en Person med namn och url.

FAQ-schema för rika utdrag

FAQPage-schema skapar rika FAQ-resultat — expanderbara fråga/svar-par som visas direkt i Google Sök under din sida. Detta kan öka den vertikala ytan och förbättra synlighet och klickfrekvens.

FaqPage-klassen innehåller en lista med frågeobjekt. Varje objekt måste ha ett namn (frågan) och ett acceptedAnswer med en text-egenskap (svaret).

C#FaqPage C#-klass (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; }
}

Utdata är ett enda FAQPage-block med en mainEntity-array. Varje objekt är av typen Question med acceptedAnswer. Google stödjer upp till tio frågor per sida för rika resultat.

HTMLJSON-LD-utdata för FAQ-schema
<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>

@id på FAQPage-blocket länkar schemat till en specifik URL-fragment. Detta är bästa praxis för sidor med flera schema-block, så tolkar kan entydigt identifiera varje objekt.

WebSite- och WebPage-schema

WebSite- och WebPage-schema skapar den grundläggande entitetsgrafen för en webbplats. WebSite identifierar sajten — namn, URL, språk och utgivare. WebPage beskriver enskild sida och länkar till WebSite via isPartOf.

Båda klasser följer samma JSON-LD-mönster. @id på WebSite är domänroten; @id på WebPage är hela sidans URL.

C#WebSiteSchema och WebPageSchema C#-klasser (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; }
}

Egenskapen inLanguage använder BCP 47-språkkoder (t.ex. en, de, fr). isPartOf-länken kopplar WebPage till WebSite genom att referera till domänens @id. Detta hjälper Google att bygga en komplett entitetsmodell av din sajt.

HTMLJSON-LD-utdata för WebSite- och WebPage-schema
<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>

Bästa praxis för implementering

Hjälpmetoden WrapInScriptTag är den enda punkten där JSON-strängar blir giltiga JSON-LD-block. Den omsluter all serialiserad schema-data i en script-tagg med MIME-typen application/ld+json.

Detta är metoden som alla schema-byggare i tjänsten anropar — Article, FAQPage, BreadcrumbList, WebSite och WebPage skickar all sin serialiserade JSON till denna samma funktion.

C#WrapInScriptTag-metod (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());
}

SchemaContext-objektet är ingångspunkten för BuildSchema-metoden. Det innehåller all data som behövs för att bygga hela uppsättningen schema-block för en sida — typ, metadata, FAQ-lista, brödsmulehierarki och artikeldata.

C#Dispatch-logik för BuildSchema (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);
}

Dispatch-switch gör schema-byggaren modulär. FAQ och brödsmulor läggs alltid till om de finns, oavsett sidtyp. Det betyder att vilken sidtyp som helst kan få FAQ-block eller brödsmulor utan att ändra kärnlogiken.

Testa och validera ditt schema

Giltig JSON-LD-syntax garanterar inte behörighet för rika resultat. Googles verktyg kontrollerar både syntax och om ditt innehåll uppfyller policyn för varje rikt resultat.

Test för rika resultat

Använd search.google.com/test/rich-results för att testa valfri URL eller klistra in rå HTML. Google visar vilka rika resultat som upptäckts och markerar saknade obligatoriska egenskaper.

Googles officiella behörighetskontroll

Validator för schema markup

validator.schema.org kontrollerar din markup mot schema.org-specifikationen oberoende av Googles riktlinjer för rika resultat. Bra för att hitta stavfel och typfel i egenskapsnamn.

Syntaxvalidering för schema.org

Google Search Console

Avsnittet Förbättringar i Search Console rapporterar schemafel och varningar i stor skala över dina indexerade sidor. Använd det för löpande övervakning efter initial validering.

Övervaka i stor skala efter lansering

Vanliga frågor

Svar på vanliga frågor om JSON-LD schema markup