Maîtriser les données structurées @graph : architecture et imbrication JSON-LD avancée
Rédigé par Ulysse Berthelot — Co-Fondateur & Président de iaba. Mis à jour le . Temps de lecture : ≈10 minutes.
@graph unifié en JSON-LD.Les données structurées @graph unifient toutes les entités Schema.org d’une page dans un seul script JSON-LD interconnecté. C’est le standard technique attendu en 2026 par les moteurs de recherche et les LLM.
- Le nœud
@graphregroupe des entités Schema.org (WebSite, WebPage, Organization, Article) dans un tableau unique. - Les identifiants
@idet la propriétésameAscréent des liens explicites entre objets — 65 % des sites indexés utilisent JSON-LD selon HTTP Archive 2024. - Cette architecture survit à une refonte, se déploie en headless via SSR ou edge functions, et se valide avec des outils propriétaires en production.
L’architecture @graph en JSON-LD est une méthode de structuration avancée qui permet de regrouper plusieurs entités Schema.org au sein d’un tableau unique partageant un contexte sémantique commun. Au lieu de déclarer des scripts isolés, le nœud @graph utilise des identifiants (via la propriété @id) pour interconnecter logiquement des objets distincts tels que WebSite, WebPage et Organization. Cette imbrication plate facilite l’analyse, la réconciliation des entités et la désambiguïsation par les algorithmes des moteurs de recherche et les grands modèles de langage (LLM).
Ce guide s’adresse aux équipes techniques — CTO, responsables SEO seniors, chefs de projet web — qui pilotent des écosystèmes complexes : sites headless, plateformes multilingues, stacks composables. Nous abordons ici la modélisation en graphe, la mécanique de sameAs, la survie du balisage lors d’une migration SEO, la validation à l’échelle et le déploiement sur edge SEO en 2026.
Définition — @graph : propriété JSON-LD normalisée par le W3C qui accepte un tableau d’objets nommés (nœuds) partageant tous le même @context. Elle permet une modélisation à plat plutôt qu’une imbrication profonde, tout en préservant les relations sémantiques via les @id.
Pourquoi utiliser l’architecture @graph pour le JSON-LD avancé ?
L’architecture @graph remplace la multiplication de scripts ld+json isolés par un unique document qui déclare toutes les entités d’une page comme des nœuds reliés. Elle réduit la duplication, prévient les conflits d’entités et rend le graphe interprétable par les crawlers en une seule passe.
La logique traditionnelle consistait à empiler plusieurs blocs <script type="application/ld+json"> — un pour l’Article, un pour le BreadcrumbList, un pour l’Organization. Chaque bloc vit isolément. Le crawler doit deviner que le Person déclaré dans le premier script est le même author que celui référencé dans le second. Cette réconciliation coûte des ressources et échoue régulièrement sur les cas ambigus.
Le format @graph renverse la logique : un seul contexte, un tableau de nœuds, des références explicites par @id. L’entité Organization est déclarée une fois, avec une URI stable (https://iaba.tech/#organization), puis simplement référencée partout où elle apparaît. Le moteur ne devine plus : il lit un graphe RDF cohérent.
@id.Selon le Web Almanac 2024 par HTTP Archive, JSON-LD est désormais le format dominant pour les données structurées SEO, loin devant Microdata et RDFa. Mais l’adoption ne dit rien de la qualité de la modélisation : la majorité des implémentations empilent encore des scripts isolés. La modélisation en graphe reste un différenciateur technique fort, particulièrement valorisé par les LLM qui construisent des représentations vectorielles d’entités.
Avantages du @graph
- Un seul contexte à maintenir, moins de duplication
- Réconciliation explicite des entités via
@id - Meilleure lisibilité pour les LLM (RAG, Knowledge Graph)
- Empreinte réduite dans le HTML (utile en headless)
- Facilite l’audit et la validation à l’échelle
Limites / vigilance
- Courbe d’apprentissage pour les équipes habituées aux scripts isolés
- Erreurs de
@id= graphe cassé silencieusement - Certains plugins WordPress historiques ne produisent pas de graphe cohérent
- Les Rich Results Tests de Google demandent parfois des ajustements
Comment structurer et imbriquer les entités Schema.org avec @graph ?
La construction d’un @graph repose sur trois gestes : déclarer un @context unique, lister les nœuds dans un tableau, puis relier chaque entité aux autres via des @id stables. Le nœud racine est presque toujours l’objet WebPage représentant l’URL courante.
La spécification JSON-LD 1.1 du W3C définit @graph comme un moyen de sérialiser plusieurs nœuds sous un même contexte. En pratique, la structure canonique pour une page article ressemble à ceci.
{
"@context": "https://schema.org",
"@graph": [
{
"@type": "Organization",
"@id": "https://iaba.tech/#organization",
"name": "iaba",
"url": "https://iaba.tech",
"sameAs": [
"https://www.linkedin.com/company/iaba-agency",
"https://www.wikidata.org/wiki/Q0000000"
]
},
{
"@type": "WebSite",
"@id": "https://iaba.tech/#website",
"url": "https://iaba.tech",
"publisher": { "@id": "https://iaba.tech/#organization" }
},
{
"@type": "WebPage",
"@id": "https://iaba.tech/blog/donnees-structurees-graph#webpage",
"url": "https://iaba.tech/blog/donnees-structurees-graph",
"isPartOf": { "@id": "https://iaba.tech/#website" },
"primaryImageOfPage": { "@id": "https://iaba.tech/blog/donnees-structurees-graph#primaryimage" }
},
{
"@type": "Article",
"@id": "https://iaba.tech/blog/donnees-structurees-graph#article",
"isPartOf": { "@id": "https://iaba.tech/blog/donnees-structurees-graph#webpage" },
"author": { "@id": "https://iaba.tech/ulysse-berthelot#person" },
"publisher": { "@id": "https://iaba.tech/#organization" }
}
]
} Trois principes gouvernent cette schema.org imbrication. Premier principe : chaque entité déclarée dans le graphe possède un @id unique sous forme d’URI, idéalement une URL réelle avec un fragment (#organization, #webpage). L’URI n’a pas besoin d’être résolvable, mais elle doit être stable dans le temps.
Deuxième principe : les relations se déclarent par référence, jamais par duplication. Un author est un pointeur {"@id": "…"} vers le nœud Person déclaré ailleurs dans le graphe. Répéter les propriétés d’un auteur à plusieurs endroits multiplie les entités aux yeux du moteur — l’inverse de l’objectif.
Troisième principe : la racine sémantique de la page est presque toujours WebPage, qui relie l’URL crawlée à toutes les autres entités. C’est le pivot du graphe. Les autres nœuds (Article, Organization, BreadcrumbList) gravitent autour et se raccrochent via isPartOf, about, mainEntity.
-
Définir le nœud racine WebPage
Déclarez la page courante avec un
@idstable et sonurlcanonique. -
Rattacher les entités publisher
Organization et WebSite deviennent des nœuds indépendants, référencés par
@id. -
Modéliser le contenu principal
Article, Product ou Service pointe vers WebPage via
isPartOfoumainEntityOfPage. -
Enrichir avec les entités secondaires
Person (author), BreadcrumbList, ImageObject, FAQPage : chacune sur son propre nœud.
-
Ancrer les identités externes avec sameAs
Pour chaque Organization et Person, listez les URI d’autorité qui désambiguïsent l’entité.
Quel est le rôle de la propriété sameAs dans la cohérence des entités ?
La propriété sameAs déclare qu’une entité locale du @graph est identique à une entité déjà connue sur le web ouvert. C’est le pont entre le code d’un site et la compréhension algorithmique externe. Sans sameAs, une Organization déclarée dans un JSON-LD est une entité orpheline — le moteur ne sait pas si c’est la même que celle référencée ailleurs.
Un sameAs bien construit pointe vers des URI d’autorité : profil LinkedIn officiel de l’entreprise, entrée Wikipedia, page Crunchbase, registre d’entreprises (societe.com pour la France, SIRENE, Companies House au Royaume-Uni), profils vérifiés sur X/Facebook. Chaque URI ajoutée augmente la probabilité de réconciliation avec le graphe de connaissances global des moteurs.
Erreur fréquente : déclarer un sameAs vers une URL non canonique (redirection, page de résultats de recherche, profil abandonné). Le moteur suit le lien : s’il tombe sur un 301 ou un 404, la déclaration perd sa valeur. Vérifiez chaque URI en HEAD avant de la publier.
Pour les entités Person — auteurs, dirigeants, experts — la logique est identique. Un profil LinkedIn public, une page auteur sur un site tiers reconnu, une entrée ORCID pour un chercheur : autant de signaux qui aident les LLM à construire une représentation cohérente de la personne. Les moteurs génératifs comme ChatGPT ou Perplexity exploitent explicitement ces liens pour attribuer une expertise à un contenu.
Votre balisage @graph tient-il la route ?
Un audit GEO complet vérifie la cohérence de vos entités, la validité des sameAs et l’imbrication de votre JSON-LD.
Quel est l’impact de l’architecture @graph lors d’une migration SEO technique ?
Une refonte ou migration transfère les URLs et les backlinks, mais oublie souvent l’architecture sémantique. Si le @graph n’est pas reconstruit avec des @id stables sur le nouveau site, les moteurs voient de nouvelles entités et repartent de zéro dans la compréhension de la marque.
Si la préservation des classements nécessite de réussir une migration SEO technique par une gestion sans faille du plan de redirection, la sauvegarde de l’intégrité de vos entités via le format @graph garantit que les moteurs ne perdent pas la compréhension sémantique de vos nouvelles pages. Trop d’équipes traitent le JSON-LD comme un livrable annexe de la recette — c’est une erreur d’architecture.
Avant migration
- Scripts isolés générés par un plugin
@idsouvent absents ou instables- Aucune stratégie
sameAsdocumentée - Entités dupliquées d’une page à l’autre
Après refonte cadrée
- Un
@graphunique par page, généré côté serveur @idstables, versionnés dans la codebasesameAscentralisés dans la config Organization- Recette SEO incluant la validation JSON-LD
La priorité historique reste évidemment donnée aux redirections 301, au plan de redirection exhaustif et à l’analyse du profil de liens pour préserver le PageRank interne et sécuriser les backlinks hérités. Le netlinking et la carte des liens externes conditionnent la vitesse de récupération. Mais la recette SEO technique doit impérativement valider le maintien de la structure JSON-LD sur chaque template migré, sans quoi le graphe sémantique se rejoue de zéro dans les moteurs.
Lors de refontes complexes impliquant des changements de balises hreflang pour l’international, le @graph doit refléter ces nouvelles localisations avec précision : propriété inLanguage sur les objets WebPage, déclaration des variantes linguistiques via translationOfWork ou workTranslation, cohérence entre l’attribut HTML lang, le hreflang et le JSON-LD. Une incohérence entre ces trois signaux provoque des ambiguïtés que les moteurs résolvent souvent à votre défaveur. Pour approfondir, consultez notre analyse dédiée au SEO international hreflang.
Conseil actionnable : avant chaque mise en production d’une migration, exportez un échantillon de 50 URLs représentatives, générez leur JSON-LD sur préprod, et validez chaque bloc @graph avec le Schema Markup Validator et le Rich Results Test de Google. Un écart entre les deux outils signale presque toujours un défaut d’imbrication.
Comment tester et valider le balisage @graph en production ?
La validation à grande échelle ne peut plus reposer sur des tests URL par URL. Les sites headless ou multilingues génèrent des centaines de templates différents ; chaque déploiement peut casser silencieusement une entité. La rigueur passe par trois couches : validation syntaxique automatisée, tests de cohérence de graphe, monitoring continu en production.
Validation syntaxique
Schema Markup Validator, Rich Results Test, JSON-LD Playground. À intégrer en CI/CD.
Cohérence du graphe
Vérifier que chaque @id référencé existe bien comme nœud dans le tableau.
Monitoring production
Crawls réguliers avec extraction JSON-LD et diff vs référence.
Chez iaba, cette rigueur s’incarne dans un outillage propriétaire éprouvé en production : le mu-plugin v2.9, déployé sur nos audits multi-clients WordPress, génère et valide un JSON-LD @graph parfaitement imbriqué et sans erreur syntaxique à l’échelle. Le @graph unifié est notre signature technique — un différenciateur observable dans le code source de chaque site que nous accompagnons. Cette approche découle du pilier Technical Optimization de notre protocole d’optimisation, qui traite les données structurées comme une infrastructure sémantique, pas comme un plugin annexe.
« Un
@graphbien construit est la seule chose qui empêche un LLM d’inventer votre entreprise à votre place. Sans lui, le modèle bricole une représentation à partir de bribes ; avec lui, il lit exactement ce que vous avez déclaré. »
| Outil | Usage | Limite connue |
|---|---|---|
| Schema Markup Validator | Validation Schema.org pure | Ne vérifie pas les exigences Google |
| Rich Results Test (Google) | Éligibilité aux rich snippets | Ignore les types non supportés par Google |
| JSON-LD Playground | Expansion, compaction, framing | Test unitaire, pas d’audit à l’échelle |
| Screaming Frog + extraction custom | Crawl et export JSON-LD à grande échelle | Configuration XPath requise |
| Search Console — rapport données structurées | Vue post-indexation Google | Latence de plusieurs jours |
Headless et Edge SEO : comment déployer le JSON-LD @graph sur des stacks modernes ?
Sur une architecture headless (Next.js, Nuxt, SvelteKit), le JSON-LD doit être injecté côté serveur — jamais uniquement après hydratation client. L’Edge SEO permet d’injecter ou corriger un bloc @graph à la périphérie du CDN sans redéployer le back-end.
Les architectures headless découplent le contenu (via API) du rendu (SPA React, Vue, Next.js). Cette séparation crée un piège classique : le JSON-LD généré uniquement côté client, après hydratation JavaScript, arrive trop tard pour la première passe des crawlers. Certains moteurs — notamment les crawlers de LLM qui ne rendent pas systématiquement le JavaScript — ne verront jamais votre @graph.
La règle absolue : le JSON-LD @graph doit apparaître dans le HTML retourné par le serveur, en Server-Side Rendering (SSR) ou Static Site Generation (SSG). Dans un projet Next.js, cela signifie l’injecter dans getStaticProps / getServerSideProps ou via les métadonnées de app router, jamais dans un useEffect. Dans un projet Nuxt, via useHead avec SSR activé. Le payload API qui alimente le rendu peut porter la structure d’entités, mais la sérialisation JSON-LD finale s’effectue côté serveur.
L’edge SEO devient l’outil de rattrapage. Une Cloudflare Worker, une AWS Lambda@Edge ou une Vercel Edge Function peut intercepter la réponse HTML entre le serveur d’origine et le navigateur, puis injecter, corriger ou compléter le bloc @graph sans jamais toucher au code applicatif. C’est particulièrement précieux pour les DSI qui subissent des cycles de release longs : on corrige une entité mal déclarée en quelques heures, pas en trois sprints. Notre article dédié à l’Edge SEO en environnement headless détaille les patrons d’implémentation.
Cas typique : un client du secteur SaaS B2B, en refonte sur stack Next.js headless, avait perdu ses rich results après mise en production. Diagnostic : le JSON-LD était généré dans un composant client, invisible pour Googlebot en première passe. Correctif via edge function injectant le @graph reconstruit à la périphérie — retour des résultats enrichis en quelques semaines, sans attendre le prochain déploiement applicatif.
L’Edge permet aussi de scaler l’injection de maillage interne dynamique en plus du JSON-LD : ancres contextuelles, liens vers les pages piliers, cohérence des breadcrumbs. Le graphe de liens internes et le graphe sémantique se renforcent mutuellement. Pour piloter cette dimension, consultez notre approche du maillage interne et du PageRank interne.
@graph.Edge Functions
JSON-LD @graph
Schema.org
sameAs
hreflang
Knowledge Graph
LLM citation
Quels types Schema.org privilégier dans un @graph B2B en 2026 ?
Un @graph B2B efficace combine au minimum WebPage, Organization, Person (auteur), Article ou Service selon le template, BreadcrumbList et FAQPage quand la page s’y prête. Chaque type doit être justifié par le contenu réel de la page.
L’erreur symétrique du sous-balisage est le sur-balisage : déclarer des types Schema.org qui ne correspondent pas au contenu visible. Les moteurs pénalisent — silencieusement, mais efficacement — les incohérences entre données structurées et contenu perceptible. Un Product déclaré sur une page qui ne vend rien, une FAQPage sans questions visibles à l’écran, un Review fabriqué : autant de signaux qui déclassent la page et parfois le domaine entier.
| Type Schema.org | Page service B2B | Article blog | Page auteur |
|---|---|---|---|
| WebPage | ✓ | ✓ | ✓ |
| Organization | ✓ | ✓ | ✓ |
| Service | ✓ | ✗ | ✗ |
| Article / TechArticle | ✗ | ✓ | ✗ |
| Person | ~ | ✓ | ✓ |
| FAQPage | ~ | ~ | ✗ |
| BreadcrumbList | ✓ | ✓ | ✓ |
Pour une agence, un cabinet de conseil ou un éditeur SaaS, la combinaison la plus robuste sur les pages services est WebPage + Service + Organization (provider) + BreadcrumbList. Sur les articles de blog experts, on ajoute Article ou TechArticle, Person (author avec ses sameAs), et éventuellement FAQPage si les questions sont réellement présentes à l’écran.
À ne jamais faire : déclarer un type Schema.org uniquement dans l’espoir de déclencher un rich snippet, sans que le contenu correspondant existe visiblement sur la page. C’est la définition même du schéma trompeur, sanctionné par une action manuelle Google et par une perte de confiance des LLM qui recoupent le JSON-LD avec le texte rendu.
📌 Points clés à retenir
- Le
@graphunifie toutes les entités d’une page dans un seul JSON-LD au contexte partagé. - Les
@idstables sont la colonne vertébrale : ils permettent la réconciliation d’entités sans duplication. - La propriété
sameAsancre vos entités dans le web ouvert et facilite la reprise par les LLM. - Une migration doit préserver la structure JSON-LD au même titre que les redirections 301 et le profil de liens.
- Sur stack headless, le
@graphs’injecte en SSR — l’Edge SEO sert de rattrapage sans toucher au back-end. - Ne déclarez jamais un type Schema.org sans contenu correspondant visible à l’écran.
- Validez en continu : Schema Markup Validator + Rich Results Test + crawl automatisé.
À propos de l’auteur
Ulysse Berthelot est le co-fondateur et président de iaba, agence pionnière en marketing IA basée à Toulouse. Passé par Oreegami (certification Expert Marketing Digital co-financée par Google, RNCP niveau 6) et l’ESG Business School Bordeaux, il est l’architecte du protocole d’optimisation propriétaire de l’agence pour la visibilité dans les moteurs génératifs (ChatGPT, Perplexity, Gemini, Claude, Google AI Overviews). Expert en Generative Engine Optimization, SEO sémantique entity-first, Knowledge Graph Optimization, Schema.org (JSON-LD) et automatisation intelligente, il conçoit des systèmes d’acquisition algorithmiques complets pour les entreprises.
Expertises : GEO, AI Overviews, SEO sémantique, JSON-LD, Schema.org, Knowledge Graph, RAG, marketing automation. Profil LinkedIn.
FAQ — Données structurées @graph
Faut-il un seul bloc @graph par page ou plusieurs ?
Un seul @graph par page est la meilleure pratique. Il unifie le contexte, évite les conflits d’entités et facilite la réconciliation par les moteurs. Multiplier les scripts JSON-LD isolés augmente le risque d’incohérence.
Le @graph remplace-t-il complètement les scripts JSON-LD séparés ?
Techniquement oui : tout ce qu’on peut déclarer dans des scripts empilés peut être exprimé dans un @graph unique. Google, Bing et les LLM interprètent les deux formats, mais le graphe est mieux compris comme représentation d’entités reliées.
Comment gérer le sameAs sur un site multilingue ?
L’entité Organization reste unique — même @id et même liste sameAs sur toutes les versions linguistiques. Seules les entités WebPage et Article varient par langue, avec la propriété inLanguage et un @id propre à chaque URL localisée.
Les @id doivent-ils être des URLs réelles et accessibles ?
Non, les @id sont des URI, pas nécessairement des URL résolvables. La convention majoritaire consiste toutefois à utiliser des URLs réelles avec un fragment (#organization, #webpage) pour garantir l’unicité et la lisibilité. L’essentiel est la stabilité dans le temps.
Le @graph impacte-t-il le rendu client ou les Core Web Vitals ?
L’impact est négligeable : un bloc JSON-LD unique pèse quelques kilo-octets et n’est pas rendu visuellement. Sur stack headless, l’injection SSR n’affecte pas le TTFB de manière mesurable. À l’inverse, empiler dix scripts isolés alourdit le HTML sans bénéfice.
Comment auditer un @graph existant sans casser la production ?
Crawlez l’échantillon avec un outil qui extrait le JSON-LD par XPath, validez chaque bloc via l’API du Schema Markup Validator, puis testez les correctifs sur environnement de préprod avant tout déploiement. Un audit méthodique se prépare en quelques jours ; l’improvisation en production casse des rich results en quelques minutes.
Faites auditer votre architecture JSON-LD @graph
Cohérence des entités, validité du sameAs, robustesse sur stack headless, plan de migration : nous cartographions les points faibles et livrons un plan d’action technique exploitable par vos équipes.
📚 Sources et références
- Officielle / Standard : W3C — JSON-LD 1.1 Specification
- Officielle / Standard : W3C — JSON-LD 1.1 Framing
- Officielle : Schema.org — Vocabulaire officiel
- Officielle : JSON-LD.org — Ressources techniques
- Encyclopédique : Wikipedia — Schema.org
- Étude / Data : HTTP Archive — Web Almanac 2024, chapitre Structured Data
- Académique : Université de Mannheim — WDC JSON-LD/Microdata/RDFa Data Corpus 2024 (attribution sans lien direct).
- Officielle : Google Developers — Providing Structured Data
📖 À lire également