Guide complet d'implémentation SEO du balisage JSON-LD
Les données structurées JSON-LD indiquent précisément aux moteurs de recherche le contenu de votre page. Le bon balisage permet d'obtenir des résultats enrichis dans Google — FAQ, carrousels d'articles, fil d'Ariane, etc. — directement dans les résultats.
Ce guide présente tous les types de schémas majeurs avec du code C# réel et le JSON exact généré. Chaque exemple provient d'une base de code Blazor en production.
Table des matières
Qu'est-ce que JSON-LD et pourquoi c'est important pour le SEO
JSON-LD (JavaScript Object Notation for Linked Data) est une méthode d'encodage des données structurées au format JSON. Les moteurs comme Google lisent ces données pour comprendre le sens de votre contenu, pas seulement ses mots-clés.
Quand Google analyse vos données structurées, votre page peut bénéficier de résultats enrichis — listes visuellement améliorées affichant notes, FAQ, images, fil d'Ariane, etc. Ces résultats génèrent plus de clics que les liens classiques.
Google recommande officiellement JSON-LD plutôt que Microdata ou RDFa car il peut être placé n'importe où dans la page — y compris dans le head — sans modifier le HTML existant. Les données sont totalement indépendantes du balisage.
Éligibilité aux résultats enrichis
Un balisage schema valide rend vos pages éligibles aux FAQ, carrousels d'articles, fil d'Ariane et autres fonctionnalités enrichies dans Google.
Plus de clics au même classement
Clarté sémantique
Les données structurées éliminent l'ambiguïté. Une page Q&R est explicitement déclarée FAQPage, ce qui indique à Google d'afficher un résultat enrichi FAQ.
Indiquez précisément votre contenu aux moteurs
Aucun changement HTML
Le JSON-LD est dans une balise script dans le head. Il ne modifie jamais le HTML visible, évitant tout risque de casse ou d'accessibilité.
Séparation claire des responsabilités
JSON-LD vs Microdata vs RDFa
Trois formats existent pour intégrer schema.org dans les pages web. Google les comprend tous, mais ils diffèrent en application et maintenance.
| Format | Emplacement syntaxique | Maintenance | Impact SEO | Recommandation Google |
|---|---|---|---|---|
| JSON-LD | Balise script séparée | Facile — aucun changement HTML | Support complet des résultats enrichis | Recommandé |
| Microdata | Attributs HTML en ligne | Élevé — lié au balisage | Support complet des résultats enrichis | Pris en charge |
| RDFa | Attributs HTML en ligne | Élevé — lié au balisage | Support complet des résultats enrichis | Pris en charge |
Pourquoi JSON-LD est plus facile à maintenir
Avec Microdata et RDFa, les attributs schema sont dispersés dans le HTML. Un changement de design peut casser les données. JSON-LD est autonome : une mise à jour suffit.
Maîtrisez le développement web moderne avec les meilleures pratiques SEO
Un conseil de ma part J’ai trouvé ce cours précieux pour comprendre comment le SEO technique, les données structurées et les standards web modernes s’articulent dans des projets concrets.
- Apprenez à implémenter les balises meta HTML, Open Graph et les données structurées JSON-LD.
- Stratégies SEO pratiques pour améliorer visibilité et classement sur les moteurs de recherche.
- Projets pratiques sur le design responsive et l’optimisation des performances.
Types de schémas principaux et usages
Schema.org définit des centaines de types, mais quelques-uns couvrent la majorité du contenu web. Ce sont ceux qui activent les résultats enrichis dans Google.
| Type de schéma | Cas d'utilisation | Type de résultat enrichi |
|---|---|---|
| Article | Articles de blog, guides, actualités | Carrousel d'articles, Actualités principales |
| FAQPage | Pages avec questions/réponses | FAQ déroulante dans les résultats |
| BreadcrumbList | Toute page avec hiérarchie de navigation | Fil d'Ariane sous l'URL |
| WebSite / WebPage | Page d'accueil, pages centrales, pages d'atterrissage | Boîte de recherche sitelinks, reconnaissance d'entité |
| SoftwareApplication | Applications, outils, logiciels | Résultat enrichi d'application avec note et prix |
Vocabulaire Schema.org
Tous les types de schémas sont définis sur schema.org. La propriété @context dans chaque bloc JSON-LD indique aux parseurs d'interpréter les noms selon ce vocabulaire. Plusieurs types peuvent coexister sur une page, Google traite chaque bloc indépendamment.
Implémentation du schéma Article
Le schéma Article est essentiel pour les sites de contenu. Il informe Google du titre, description, date de publication, auteur et éditeur — le minimum requis pour les résultats enrichis.
La classe C# ci-dessous est le modèle de sérialisation. Chaque propriété correspond directement au champ JSON-LD via les attributs JsonPropertyName.
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; }
}Les propriétés requises sont : headline, image, datePublished, dateModified, author et publisher. Le tableau articleSection est optionnel mais recommandé — il indique le sujet de l'article à Google.
<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>L'auteur et l'éditeur sont typés Organization. Pour un blog personnel, l'auteur peut être une Person avec nom et url.
Schéma FAQ pour extraits enrichis
Le schéma FAQPage génère des résultats enrichis FAQ — paires question/réponse dépliables affichées directement sous votre résultat dans Google. Cela augmente la visibilité et le taux de clics.
La classe FaqPage contient une liste de questions. Chaque entité doit avoir un nom (la question) et une acceptedAnswer avec une propriété text (la réponse).
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; }
}La sortie est un bloc FAQPage unique avec un tableau mainEntity. Chaque élément est de type Question avec une acceptedAnswer. Google supporte jusqu'à dix questions par page.
<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>L'@id du bloc FAQPage ancre le schéma à un fragment d'URL spécifique. C'est une bonne pratique pour les pages avec plusieurs blocs, facilitant l'identification claire par les parseurs.
Schéma WebSite et WebPage
Les schémas WebSite et WebPage définissent la structure de base d'un site. WebSite identifie le site (nom, URL, langue, éditeur). WebPage décrit la page et la relie au WebSite via isPartOf.
Les deux classes suivent le même modèle JSON-LD. L'@id de WebSite est la racine du domaine ; celui de WebPage est l'URL complète de la page.
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; }
}La propriété inLanguage utilise les codes BCP 47 (ex. en, de, fr). Le lien isPartOf relie la WebPage à WebSite via l'@id du domaine. Cela aide Google à modéliser votre site.
<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>Bonnes pratiques d'implémentation
La méthode WrapInScriptTag est le point unique où les chaînes JSON deviennent des blocs JSON-LD valides. Elle enveloppe le schéma sérialisé dans une balise script avec le type MIME application/ld+json.
C'est la méthode appelée par tous les constructeurs de schémas du service — Article, FAQPage, BreadcrumbList, WebSite et WebPage passent leur JSON sérialisé à cet utilitaire.
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());
}L'objet SchemaContext est le point d'entrée de la méthode BuildSchema. Il contient toutes les données nécessaires pour construire l'ensemble des blocs schema d'une page — type, métadonnées, FAQ, fil d'Ariane, article.
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);
}Le switch de dispatch rend le constructeur de schéma modulaire. FAQ et fil d'Ariane sont toujours ajoutés si présents, quel que soit le type de page. Ainsi, tout type peut inclure FAQ ou fil d'Ariane sans modifier la logique centrale.
Tester et valider votre schéma
Une syntaxe JSON-LD valide ne garantit pas l'éligibilité aux résultats enrichis. Les outils Google vérifient la validité et la conformité aux règles pour chaque type de résultat.
Test des résultats enrichis
Utilisez search.google.com/test/rich-results pour tester une URL ou coller du HTML brut. Google indique les types de résultats détectés et les propriétés requises manquantes.
Outil officiel d'éligibilité Google
Validateur de balisage Schema
validator.schema.org vérifie votre balisage selon la spécification schema.org, indépendamment des règles Google. Utile pour détecter fautes de noms ou erreurs de type.
Validation syntaxique schema.org
Google Search Console
La section Améliorations de Search Console signale erreurs et avertissements schema sur vos pages indexées. Utilisez-la pour un suivi continu après validation initiale.
Surveillance à grande échelle après lancement