Guida completa all'implementazione SEO con JSON-LD Schema
I dati strutturati JSON-LD indicano ai motori di ricerca il contenuto esatto della tua pagina. Il markup schema corretto abilita risultati arricchiti su Google — FAQ, caroselli di articoli, breadcrumb e altro — direttamente nei risultati di ricerca.
Questa guida illustra i principali tipi di schema con codice C# reale e l'output JSON esatto prodotto. Ogni esempio proviene da un codice Blazor in produzione.
Indice
Cos'è JSON-LD e perché è importante per la SEO
JSON-LD (JavaScript Object Notation for Linked Data) è un metodo per codificare dati strutturati in formato JSON. I motori di ricerca come Google leggono questi dati per comprendere il significato del contenuto, non solo le parole chiave.
Quando Google interpreta i tuoi dati strutturati, la pagina può ottenere risultati arricchiti — elenchi di ricerca migliorati con valutazioni, FAQ, immagini, breadcrumb e altro, visibili direttamente nei risultati. Questi risultati ottengono più clic rispetto ai link standard.
Google consiglia ufficialmente JSON-LD rispetto a Microdata e RDFa perché può essere inserito ovunque nella pagina — anche nell'head — senza modificare gli elementi HTML esistenti. I dati strutturati sono completamente separati dal markup.
Idoneità ai risultati arricchiti
Un markup schema valido rende le tue pagine idonee a FAQ, caroselli di articoli, breadcrumb e altre funzionalità arricchite su Google Search.
Più clic dallo stesso posizionamento
Chiarezza semantica
I dati strutturati eliminano ambiguità. Una pagina con domande e risposte è dichiarata come FAQPage, così Google la mostra come risultato arricchito FAQ.
Comunica ai motori di ricerca esattamente cosa offri
Nessuna modifica all'HTML
JSON-LD risiede in un tag script nell'head. Non modifica l'HTML visivo, quindi aggiungere o aggiornare schema non compromette layout o accessibilità.
Separazione chiara delle responsabilità
JSON-LD vs. Microdata vs. RDFa
Esistono tre formati per incorporare dati strutturati schema.org nelle pagine web. Google li riconosce tutti, ma differiscono per applicazione e manutenzione.
| Formato | Posizione sintassi | Manutenzione | Impatto SEO | Raccomandazione Google |
|---|---|---|---|---|
| JSON-LD | Tag script separato | Facile — nessuna modifica HTML | Supporto completo ai risultati arricchiti | Consigliato |
| Microdata | Attributi HTML inline | Alto — fortemente legato al markup | Supporto completo ai risultati arricchiti | Supportato |
| RDFa | Attributi HTML inline | Alto — fortemente legato al markup | Supporto completo ai risultati arricchiti | Supportato |
Perché JSON-LD è più gestibile
Con Microdata e RDFa, gli attributi schema sono sparsi nell'HTML. Cambiamenti al template possono rompere i dati strutturati. JSON-LD è un blocco autonomo: aggiorni lo script e l'HTML resta intatto.
Padroneggia lo sviluppo web moderno con le migliori pratiche SEO
Consiglio personale Ho trovato questo corso utile per comprendere come SEO tecnico, dati strutturati e standard web moderni si integrino in progetti reali.
- Impara a implementare meta tag HTML, Open Graph e dati strutturati JSON-LD.
- Strategie SEO pratiche per migliorare visibilità e posizionamento sui motori di ricerca.
- Progetti pratici su design responsive e ottimizzazione delle prestazioni.
Tipi principali di schema e quando usarli
Schema.org definisce centinaia di tipi, ma pochi coprono la maggior parte dei contenuti web. Questi abilitano i risultati arricchiti su Google Search.
| Tipo di schema | Caso d'uso | Tipo di risultato arricchito |
|---|---|---|
| Article | Post, guide, articoli di notizie | Carosello articoli, Notizie principali |
| FAQPage | Pagine con domande e risposte | FAQ a discesa nei risultati di ricerca |
| BreadcrumbList | Qualsiasi pagina con gerarchia di navigazione | Percorso breadcrumb sotto l'URL |
| WebSite / WebPage | Homepage, pagine hub, landing page | Box ricerca sitelink, riconoscimento entità |
| SoftwareApplication | App, strumenti, prodotti software | Risultato app con valutazione e prezzo |
Vocabolario Schema.org
Tutti i tipi di schema sono definiti su schema.org. La proprietà @context in ogni blocco JSON-LD indica ai parser di interpretare i nomi proprietà secondo il vocabolario schema.org. Puoi combinare più tipi in una pagina — Google elabora ogni blocco separatamente.
Implementazione schema Articolo
Lo schema Articolo è il più importante per siti basati su contenuti. Indica a Google titolo, descrizione, data pubblicazione, autore e editore — il minimo per ottenere risultati arricchiti.
La classe C# sottostante è il modello di serializzazione. Ogni proprietà mappa direttamente al campo JSON-LD corrispondente tramite attributi 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; }
}Le proprietà obbligatorie sono: headline, image, datePublished, dateModified, author e publisher. L'array articleSection è opzionale ma consigliato — indica l'ambito tematico dell'articolo a 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>Autore e editore sono di tipo Organization. Per blog personali, l'autore può essere una Person con nome e URL.
Schema FAQ per snippet arricchiti
Lo schema FAQPage crea risultati FAQ arricchiti — domande e risposte espandibili visibili direttamente nei risultati Google sotto la tua pagina. Aumenta lo spazio verticale e migliora visibilità e clic.
La classe FaqPage contiene una lista di entità domanda. Ogni entità deve avere un nome (la domanda) e un acceptedAnswer con proprietà text (la risposta).
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; }
}L'output è un singolo blocco FAQPage con un array mainEntity. Ogni elemento è di tipo Question con acceptedAnswer. Google supporta fino a dieci domande per pagina.
<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 nel blocco FAQPage collega lo schema a un frammento URL specifico. È una best practice per pagine con più blocchi schema, per identificare univocamente ogni entità.
Schema WebSite e WebPage
Gli schemi WebSite e WebPage definiscono il grafo entità di base per un sito. WebSite identifica il sito — nome, URL, lingua e editore. WebPage descrive la pagina e la collega al WebSite tramite isPartOf.
Entrambe le classi seguono lo stesso schema JSON-LD. L'@id di WebSite è la radice del dominio; l'@id di WebPage è l'URL completo della pagina.
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 proprietà inLanguage usa codici lingua BCP 47 (es. en, de, fr). Il link isPartOf collega WebPage all'entità WebSite tramite l'@id del dominio. Aiuta Google a costruire un modello entità completo del sito.
<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 practice di implementazione
Il metodo helper WrapInScriptTag è il punto unico dove le stringhe JSON diventano blocchi JSON-LD validi. Avvolge il payload serializzato in un tag script con MIME type application/ld+json.
Questo metodo è chiamato da tutti i builder di schema nel servizio — Article, FAQPage, BreadcrumbList, WebSite e WebPage passano il loro JSON serializzato a questa utility.
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'oggetto SchemaContext è il punto di ingresso per il metodo BuildSchema. Contiene tutti i dati necessari per costruire l'insieme completo di blocchi schema per una pagina — tipo, metadati, FAQ, breadcrumb e dati articolo.
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);
}Lo switch di dispatch rende il builder schema componibile. FAQ e breadcrumb sono sempre aggiunti se presenti, indipendentemente dal tipo di pagina. Qualsiasi pagina può avere FAQ o breadcrumb senza modificare la logica centrale.
Testare e validare il tuo schema
Una sintassi JSON-LD valida non garantisce l'idoneità ai risultati arricchiti. Gli strumenti Google verificano validità sintattica e conformità alle policy per ogni tipo di risultato.
Test risultati arricchiti
Usa search.google.com/test/rich-results per testare un URL o incollare HTML. Google conferma i tipi di risultati rilevati e segnala proprietà obbligatorie mancanti.
Verificatore ufficiale di idoneità Google
Validator schema markup
validator.schema.org verifica il tuo markup rispetto alla specifica schema.org indipendentemente dalle policy Google. Utile per errori di nomi proprietà e mismatch di tipo.
Validazione sintassi Schema.org
Google Search Console
La sezione Enhancements in Search Console segnala errori e avvisi schema su larga scala nelle pagine indicizzate. Usala per monitoraggio continuo dopo la validazione iniziale.
Monitoraggio su larga scala post-lancio