Nous avons livré des données structurées sur 91 000+ pages programmatiques. Ce n'est pas une faute de frappe. Sur trois projets en production — Deluxe Astrology (30 langues, horoscopes, profils de célébrités), Not Another Sunday (137 000 listes de lieux) et HostList (25 000 profils d'entreprises) — nous avons construit des systèmes qui génèrent un schéma JSON-LD à partir de lignes de base de données au moment de la compilation, le valident automatiquement et le surveillent en production. Voici tout ce que nous avons appris, distillé en code fonctionnel que vous pouvez réellement utiliser.

Ce n'est pas un article « qu'est-ce que le balisage de schéma ». Vous savez ce que c'est. Ceci est le guide d'implémentation que j'aurais souhaité avoir quand nous avons commencé à intégrer les données structurées aux applications Next.js sauvegardées par Supabase servant des pages en 30 langues.

Table des matières

Balisage de schéma dans Next.js : Guide de données structurées JSON-LD pour 2026

Pourquoi le balisage de schéma est toujours important en 2026

Google traite plus de 8,5 milliards de requêtes quotidiennement. Les aperçus IA apparaissent maintenant sur environ 30 % des résultats de recherche aux États-Unis. Et voici ce qui importe pour vos décisions d'implémentation : les données structurées sont la façon dont les machines comprennent vos pages. Non seulement Google — ChatGPT, Perplexity, Claude et tous les autres outils de recherche alimentés par LLM qui analysent le web.

Le dossier du ROI est simple :

Métrique Sans schéma Avec schéma Delta observé
CTR depuis SERP Baseline +25-35% avec résultats enrichis +31% sur les pages de lieux Not Another Sunday
Inclusion dans les aperçus IA Faible Considérablement plus élevé 3,2x plus probable sur les pages annotées FAQ
Taux de citation LLM Minimal Mesurable Pages avec schéma FAQPage citées 4x plus par Perplexity
Éligibilité aux résultats enrichis Aucune Étoiles, FAQ, breadcrumbs, etc. Actif sur 87% des pages indexées

Pour les sites avec des dizaines de milliers de pages, le schéma manuel est impossible. Vous avez besoin d'un système. C'est ce que ce guide construit.

L'angle de la citation LLM : FAQPage comme or lisible par machine

Voici quelque chose que la plupart des guides de schéma ne couvrent pas : le schéma FAQPage est le format le plus lisible par machine pour les moteurs de recherche alimentés par LLM. Quand ChatGPT ou Perplexity analysent votre page, ils recherchent des paires Q&R clairement structurées. Le schéma FAQPage leur fournit exactement cela — des paires question-réponse pré-analysées, sans ambiguïté, qui ne nécessitent aucune extraction NLP.

Nous avons d'abord remarqué ce modèle sur Deluxe Astrology. Les pages avec schéma FAQPage étaient citées dans les réponses Perplexity à environ 4x le taux des pages équivalentes sans celui-ci. Les paires Q&R étaient levées presque mot pour mot.

Ce n'est plus seulement un jeu SEO. C'est un jeu d'optimisation de moteur génératif (GEO). Si vous voulez que votre contenu soit affiché dans les réponses générées par l'IA — et vous le voulez, parce que c'est là que va la recherche — le schéma FAQPage est votre investissement à plus fort effet de levier.

Modèle d'implémentation du routeur d'application Next.js

Parlons de code réel. Nous utilisons un modèle cohérent sur tous nos projets de développement Next.js : un composant JsonLd réutilisable rendu à l'intérieur de composants serveur.

Le composant de base

// components/json-ld.tsx
export function JsonLd({ data }: { data: Record<string, unknown> }) {
  return (
    <script
      type="application/ld+json"
      dangerouslySetInnerHTML={{
        __html: JSON.stringify({
          '@context': 'https://schema.org',
          ...data,
        }),
      }}
    />
  );
}

Simple. Pas de JavaScript côté client. Pas de désaccords d'hydratation. Ceci est rendu dans la sortie du composant serveur et expédié en tant que HTML statique. Le crawler de Google le voit immédiatement — aucune exécution JavaScript requise.

Schéma au niveau de la mise en page par rapport au niveau de la page

Nous divisons le schéma en deux catégories :

Niveau de mise en page (rendu dans layout.tsx) : Organisation, Site Web, BreadcrumbList. Ceux-ci sont cohérents sur les pages ou les groupes de pages.

Niveau de page (rendu dans page.tsx) : Article, FAQPage, Personne, LocalBusiness, Produit. Ceux-ci sont uniques par page et généralement alimentés par le contenu de la base de données.

// app/layout.tsx
import { JsonLd } from '@/components/json-ld';

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html lang="en">
      <body>
        <JsonLd
          data={{
            '@type': 'Organization',
            name: 'Social Animal',
            url: 'https://socialanimal.dev',
            logo: 'https://socialanimal.dev/logo.png',
            sameAs: [
              'https://twitter.com/socialanimaldev',
              'https://github.com/social-animal',
            ],
            contactPoint: {
              '@type': 'ContactPoint',
              contactType: 'sales',
              url: 'https://socialanimal.dev/contact',
            },
          }}
        />
        <JsonLd
          data={{
            '@type': 'WebSite',
            name: 'Social Animal',
            url: 'https://socialanimal.dev',
            potentialAction: {
              '@type': 'SearchAction',
              target: {
                '@type': 'EntryPoint',
                urlTemplate: 'https://socialanimal.dev/search?q={search_term_string}',
              },
              'query-input': 'required name=search_term_string',
            },
          }}
        />
        {children}
      </body>
    </html>
  );
}

Cela signifie que chaque page du site obtient le schéma Organisation et Site Web sans aucun travail par page. Rendu serveur, zéro frais généraux JS client.

Balisage de schéma dans Next.js : Guide de données structurées JSON-LD pour 2026 - architecture

Tous les types de schéma avec code JSON-LD fonctionnel

Voici tous les types de schéma que nous utilisons en production, avec des modèles réels de nos projets.

Organisation

{
  "@type": "Organization",
  "name": "Social Animal",
  "url": "https://socialanimal.dev",
  "logo": "https://socialanimal.dev/logo.png",
  "description": "Agence de développement web headless spécialisée dans Next.js et Astro",
  "foundingDate": "2022",
  "sameAs": [
    "https://twitter.com/socialanimaldev",
    "https://linkedin.com/company/socialanimaldev"
  ],
  "address": {
    "@type": "PostalAddress",
    "addressLocality": "Remote",
    "addressCountry": "US"
  }
}

Site Web

Montré ci-dessus dans l'exemple de mise en page. La SearchAction est ce qui alimente la boîte de recherche de sitelinks dans Google. Ne la sautez pas.

Article / BlogPosting

// app/blog/[slug]/page.tsx
export default async function BlogPost({ params }: { params: { slug: string } }) {
  const post = await getPostBySlug(params.slug);

  return (
    <article>
      <JsonLd
        data={{
          '@type': 'Article',
          headline: post.title,
          description: post.excerpt,
          image: post.featuredImage,
          datePublished: post.publishedAt,
          dateModified: post.updatedAt,
          author: {
            '@type': 'Organization',
            name: 'Social Animal',
            url: 'https://socialanimal.dev',
          },
          publisher: {
            '@type': 'Organization',
            name: 'Social Animal',
            logo: {
              '@type': 'ImageObject',
              url: 'https://socialanimal.dev/logo.png',
            },
          },
          mainEntityOfPage: {
            '@type': 'WebPage',
            '@id': `https://socialanimal.dev/blog/${post.slug}`,
          },
        }}
      />
      {/* Contenu de l'article */}
    </article>
  );
}

FAQPage

C'est le grand pour les citations LLM :

function buildFaqSchema(faqs: Array<{ question: string; answer: string }>) {
  return {
    '@type': 'FAQPage',
    mainEntity: faqs.map((faq) => ({
      '@type': 'Question',
      name: faq.question,
      acceptedAnswer: {
        '@type': 'Answer',
        text: faq.answer,
      },
    })),
  };
}

function buildBreadcrumbSchema(items: Array<{ name: string; url: string }>) {
  return {
    '@type': 'BreadcrumbList',
    itemListElement: items.map((item, index) => ({
      '@type': 'ListItem',
      position: index + 1,
      name: item.name,
      item: item.url,
    })),
  };
}

// Utilisation pour une page de lieu sur Not Another Sunday :
<JsonLd
  data={buildBreadcrumbSchema([
    { name: 'Home', url: 'https://notanothersunday.com' },
    { name: 'London', url: 'https://notanothersunday.com/london' },
    { name: 'Restaurants', url: 'https://notanothersunday.com/london/restaurants' },
    { name: venue.name, url: `https://notanothersunday.com/venue/${venue.slug}` },
  ])}
/>

Service

{
  "@type": "Service",
  "name": "Développement Next.js",
  "description": "Développement personnalisé du routeur d'application Next.js avec intégration CMS headless",
  "provider": {
    "@type": "Organization",
    "name": "Social Animal"
  },
  "serviceType": "Développement web",
  "areaServed": "Mondial",
  "url": "https://socialanimal.dev/capabilities/nextjs-development"
}

LocalBusiness

Cela alimente les 137 000 listes de lieux de Not Another Sunday :

function buildLocalBusinessSchema(venue: Venue) {
  return {
    '@type': venue.type === 'restaurant' ? 'Restaurant' : 'LocalBusiness',
    name: venue.name,
    description: venue.description,
    image: venue.images[0],
    address: {
      '@type': 'PostalAddress',
      streetAddress: venue.address,
      addressLocality: venue.city,
      postalCode: venue.postcode,
      addressCountry: venue.country,
    },
    geo: {
      '@type': 'GeoCoordinates',
      latitude: venue.lat,
      longitude: venue.lng,
    },
    url: venue.website,
    telephone: venue.phone,
    priceRange: venue.priceRange,
    aggregateRating: venue.reviewCount > 0 ? {
      '@type': 'AggregateRating',
      ratingValue: venue.rating,
      reviewCount: venue.reviewCount,
    } : undefined,
  };
}

Produit

{
  "@type": "Product",
  "name": "Package de développement CMS Headless",
  "description": "Configuration complète du CMS headless avec modélisation de contenu et intégration API",
  "offers": {
    "@type": "Offer",
    "price": "5000",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "url": "https://socialanimal.dev/pricing"
  }
}

HowTo

{
  "@type": "HowTo",
  "name": "Comment ajouter un balisage de schéma au routeur d'application Next.js",
  "description": "Guide étape par étape pour implémenter des données structurées JSON-LD dans les composants serveur Next.js",
  "step": [
    {
      "@type": "HowToStep",
      "name": "Créez un composant JsonLd",
      "text": "Créez un composant serveur réutilisable qui rend une balise script avec le type application/ld+json"
    },
    {
      "@type": "HowToStep",
      "name": "Ajoutez un schéma au niveau de la mise en page",
      "text": "Placez le schéma Organisation et Site Web dans votre layout.tsx racine"
    },
    {
      "@type": "HowToStep",
      "name": "Générez un schéma au niveau de la page à partir de données",
      "text": "Créez des objets de schéma à partir de votre contenu CMS ou base de données dans chaque composant serveur de page"
    }
  ]
}

Personne

Utilisé sur les profils de célébrités de Deluxe Astrology :

function buildPersonSchema(celebrity: Celebrity) {
  return {
    '@type': 'Person',
    name: celebrity.name,
    description: celebrity.bio,
    image: celebrity.photo,
    birthDate: celebrity.birthDate,
    birthPlace: celebrity.birthPlace ? {
      '@type': 'Place',
      name: celebrity.birthPlace,
    } : undefined,
    nationality: celebrity.nationality,
    url: `https://deluxeastrology.com/celebrities/${celebrity.slug}`,
    sameAs: celebrity.externalLinks || [],
  };
}

Schéma dynamique pour les pages programmatiques

C'est là que ça devient intéressant. Quand vous avez 91 000+ pages sauvegardées par des lignes Supabase, vous avez besoin d'un pipeline qui transforme les enregistrements de base de données en JSON-LD valide sans intervention humaine.

Voici notre modèle réel :

// app/[lang]/horoscope/[sign]/[period]/page.tsx
import { createClient } from '@/lib/supabase/server';
import { JsonLd } from '@/components/json-ld';

export async function generateStaticParams() {
  const supabase = createClient();
  const { data: pages } = await supabase
    .from('horoscope_pages')
    .select('lang, sign, period');

  return (pages || []).map((p) => ({
    lang: p.lang,
    sign: p.sign,
    period: p.period,
  }));
}

export default async function HoroscopePage({
  params,
}: {
  params: { lang: string; sign: string; period: string };
}) {
  const supabase = createClient();
  const { data: page } = await supabase
    .from('horoscope_pages')
    .select('*')
    .eq('lang', params.lang)
    .eq('sign', params.sign)
    .eq('period', params.period)
    .single();

  if (!page) return notFound();

  const articleSchema = {
    '@type': 'Article',
    headline: page.title,
    description: page.meta_description,
    datePublished: page.published_at,
    dateModified: page.updated_at,
    inLanguage: page.lang,
    author: {
      '@type': 'Organization',
      name: 'Deluxe Astrology',
    },
    mainEntityOfPage: {
      '@type': 'WebPage',
      '@id': `https://deluxeastrology.com/${page.lang}/horoscope/${page.sign}/${page.period}`,
    },
  };

  const faqSchema = page.faqs?.length
    ? {
        '@type': 'FAQPage',
        mainEntity: page.faqs.map((faq: any) => ({
          '@type': 'Question',
          name: faq.q,
          acceptedAnswer: {
            '@type': 'Answer',
            text: faq.a,
          },
        })),
      }
    : null;

  return (
    <main>
      <JsonLd data={articleSchema} />
      {faqSchema && <JsonLd data={faqSchema} />}
      {/* Contenu de la page */}
    </main>
  );
}

Les décisions architecturales clés ici :

  1. Le schéma est généré au moment de la compilation via SSG — generateStaticParams crée tous les 91 000+ chemins, et le schéma de chaque page est intégré dans le HTML statique.
  2. Ligne Supabase = données de schéma — La base de données est la source unique de vérité. Pas de dérive de contenu entre ce qui est visible et ce qui est dans le schéma.
  3. Plusieurs blocs de schéma par page — Google supporte explicitement plusieurs balises de script JSON-LD. Nous utilisons des blocs séparés pour Article, FAQPage et BreadcrumbList sur la même page.
  4. ISR pour la fraîcheur — Nous définissons revalidate = 3600 pour que les pages se reconstruisent toutes les heures sans déploiements complets.

Pour les 25 000 profils d'entreprises de HostList, le même modèle s'applique mais avec schéma Organisation généré à partir de chaque ligne Supabase de l'entreprise. Pour les 137 000 lieux de Not Another Sunday, c'est LocalBusiness.

Schéma multilingue avec inLanguage

Deluxe Astrology fonctionne en 30 langues. Chaque bloc de schéma inclut inLanguage, et nous utilisons des URL conscientes de hreflang :

function buildMultilingualArticleSchema(
  page: HoroscopePage,
  allLanguages: string[]
) {
  return {
    '@type': 'Article',
    headline: page.title,
    description: page.meta_description,
    inLanguage: page.lang,
    datePublished: page.published_at,
    dateModified: page.updated_at,
    author: {
      '@type': 'Organization',
      name: 'Deluxe Astrology',
    },
    // Dites aux moteurs de recherche à propos des traductions
    workTranslation: allLanguages
      .filter((lang) => lang !== page.lang)
      .map((lang) => ({
        '@type': 'Article',
        inLanguage: lang,
        url: `https://deluxeastrology.com/${lang}/horoscope/${page.sign}/${page.period}`,
      })),
  };
}

La propriété inLanguage utilise les balises de langue BCP 47 (en, fr, de, ja, etc.). Ceci est critique pour les sites multilingues — sans cela, Google peut mal identifier la langue de vos données structurées et les servir au mauvais public.

Outils de validation et de surveillance

Expédier le schéma sans validation, c'est comme déployer sans tests. Voici notre boîte à outils :

Outil Objectif Coût Quand utiliser
Test des résultats enrichis de Google Valide l'éligibilité aux résultats enrichis Gratuit Avant déploiement, vérifications ponctuelles
Validateur de balisage de schéma Validation complète de la spécification schema.org Gratuit Détecte les erreurs de propriété que l'outil de Google ignore
Screaming Frog Extraction personnalisée Analyse le site, extrait JSON-LD de chaque page £199/an (licence payante) Validation en masse sur 91K+ pages
Google Search Console Surveille le schéma indexé, affiche les erreurs Gratuit Surveillance en production continue
Rapports d'état des résultats enrichis Affiche quelles pages ont un schéma valide/invalide Gratuit Révision hebdomadaire

Extraction personnalisée Screaming Frog pour le schéma à l'échelle

C'est ainsi que vous validez 91 000 pages sans vérifier manuellement chacune d'elles. Dans Screaming Frog :

  1. Allez à Configuration → Personnalisé → Extraction
  2. Ajoutez une extraction personnalisée avec CSSPath : script[type="application/ld+json"]
  3. Définissez l'extraction sur "Extraire le HTML interne"
  4. Analysez votre site
  5. Exportez et analysez le JSON pour valider programmatiquement

Nous passons l'export par un script Node qui vérifie les propriétés requises par type de schéma et signale toutes les pages avec des données manquantes ou malformées. Cela détecte les problèmes comme les champs headline vides ou les dates au mauvais format avant que Google ne le fasse.

Erreurs courantes qui détruiront vos résultats enrichis

Nous avons commis la plupart de celles-ci. Apprenez de notre douleur.

1. Le contenu du schéma ne correspond pas au contenu visible. Si votre schéma Article dit que le titre est « Meilleurs restaurants à Londres » mais le <h1> réel dit quelque chose de différent, Google ignorera ou pénalisera le schéma. Les données doivent refléter ce qui est sur la page.

2. Utiliser des types de schéma pour des pages qui ne se qualifient pas. N'appliquez pas de schéma FAQPage sur une page qui n'affiche pas réellement du contenu FAQ. L'équipe des actions manuelles de Google détecte cela, et la pénalité supprime TOUS vos résultats enrichis, pas seulement les pages contrevenantes.

3. Propriétés requises manquantes. Article nécessite headline et image. LocalBusiness nécessite name et address. Vérifiez la documentation Google sur les données structurées pour les exigences par type.

4. Rendu du schéma dans les composants clients. Dans Next.js App Router, si vous rendez JSON-LD à l'intérieur d'un composant 'use client', il ne sera pas dans le HTML initial. Googlebot exécutera généralement JS, mais les autres crawlers (y compris certains crawlers LLM) ne le feront pas. Utilisez toujours les composants serveur.

5. Schéma dupliqué sur les mises en page imbriquées. Si votre layout.tsx racine et un layout.tsx imbriqué rendent tous deux le schéma Organisation, vous aurez des doublons. Dédupliquéz en plaçant chaque type de schéma uniquement au niveau approprié le plus spécifique.

6. Ne pas échapper les caractères spéciaux dans JSON. Si votre titre d'article ou réponse FAQ contient des guillemets ou des crochets non échappés, le JSON se brise silencieusement. JSON.stringify() gère la plupart des cas, mais attention au contenu provenant de données générées par les utilisateurs.

7. Utiliser des types de schéma dépréciés ou non supportés. Voir la section suivante.

Dépréciations et modifications de Google 2025-2026

Google a resserré quels types de schéma déclenchent des résultats enrichis :

  • Résultats enrichis FAQPage supprimés pour la plupart des sites (août 2023, toujours en vigueur) : Seuls les sites des autorités gouvernementales et sanitaires obtiennent les résultats enrichis FAQ dans les SERP maintenant. MAIS — et c'est crucial — Google continue de lire et traiter le schéma FAQPage. Il ne montre juste pas le FAQ extensible dans les résultats de recherche pour la plupart des sites. Pour les citations LLM, le schéma est toujours de l'or.
  • Résultats enrichis HowTo supprimés sur mobile (septembre 2023, toujours en vigueur) : Le bureau les affiche toujours occasionnellement, mais Google a considérablement déprioritisé les résultats enrichis HowTo.
  • Dépréciations de la boîte de recherche Sitelinks (novembre 2024) : La SearchAction du schéma WebSite ne garantit plus une boîte de recherche de sitelinks, mais Google peut toujours l'utiliser en interne.
  • Les aperçus IA priorisent les données structurées (2025-2026) : Les aperçus IA de Google extraient de plus en plus de pages avec des données structurées. Le schéma ne garantit pas l'inclusion, mais les pages sans celui-ci sont mesurément moins susceptibles d'être citées.

Notre recommandation : continuez à implémenter FAQPage, HowTo et tous les types de schéma même si les fonctionnalités SERP de Google ont été réduites. Les données sont consommées par plusieurs systèmes maintenant — l'IA de Google, le mode de navigation de ChatGPT, Perplexity, Bing Copilot. La valeur s'étend bien au-delà des résultats enrichis traditionnels.

Si vous construisez un site headless et voulez de l'aide pour implémenter cela à l'échelle, consultez nos capacités de développement CMS headless ou contactez-nous.

FAQ

Le schéma FAQPage fonctionne-t-il toujours pour le SEO en 2026 ? Oui, mais différemment qu'avant. Google a supprimé les résultats enrichis FAQ pour la plupart des sites en 2023, vous ne verrez donc pas d'extraits FAQ extensibles dans les résultats de recherche. Cependant, Google continue de traiter le schéma en interne, et les outils de recherche alimentés par LLM comme ChatGPT, Perplexity et les aperçus IA de Google extraient activement les paires Q&R du balisage FAQPage. Nous avons mesuré une augmentation de 4x des citations LLM sur les pages avec schéma FAQPage par rapport à celles sans.

Comment ajouter le balisage du schéma JSON-LD dans le routeur d'application Next.js ? Créez un composant serveur qui rend une balise <script type="application/ld+json"> en utilisant dangerouslySetInnerHTML avec JSON.stringify() sur votre objet de schéma. Placez-le à l'intérieur du composant serveur de votre page — jamais dans un composant client. Pour le schéma à l'échelle du site comme Organisation, mettez-le dans layout.tsx. Pour le schéma spécifique à la page comme Article ou FAQPage, générez-le à partir de vos données dans chaque page.tsx.

Pouvez-vous avoir plusieurs balises de script JSON-LD sur une page ? Absolument. Google supporte explicitement plusieurs blocs JSON-LD sur une seule page. Nous rendons régulièrement des blocs séparés pour Article, FAQPage, BreadcrumbList et Organisation sur la même page. Chacun obtient sa propre balise <script type="application/ld+json"> avec son propre @context.

Comment générez-vous le balisage de schéma pour des milliers de pages programmatiques ? Créez des objets de schéma à partir de vos lignes de base de données dans les composants serveur. Nous utilisons generateStaticParams dans Next.js pour créer des chemins pour toutes les pages, puis le composant serveur de chaque page récupère ses données de Supabase et construit le JSON-LD dynamiquement. Le schéma est intégré dans le HTML statique au moment de la compilation. Pour 91 000 pages, cela s'exécute pendant le processus de compilation avec ISR gérant les mises à jour.

Quelle est la différence entre le schéma Article et BlogPosting ? BlogPosting est un sous-type d'Article. Utilisez BlogPosting pour les articles de blog avec une date de publication et un auteur clairs. Utilisez Article pour un contenu éditorial plus général comme les articles d'actualité ou les guides. En pratique, Google les traite presque de manière identique. Nous utilisons Article pour la plupart du contenu et BlogPosting uniquement pour les articles au format blog explicite.

Le balisage de schéma aide-t-il avec les aperçus IA de Google ? Oui. Les pages avec données structurées sont mesuralement plus susceptibles d'être citées dans les aperçus IA. Le schéma aide l'IA de Google à comprendre les relations d'entités, le type de contenu et la précision des données. Le schéma FAQPage est particulièrement efficace car il fournit des paires Q&R pré-structurées que l'IA peut extraire directement. Ce n'est pas une garantie d'inclusion, mais cela améliore considérablement vos chances.

Quels outils devrais-je utiliser pour valider le balisage de schéma à l'échelle ? Pour les pages individuelles, utilisez le test des résultats enrichis de Google et le validateur de balisage de schéma sur validator.schema.org. Pour la validation en masse sur des milliers de pages, utilisez la fonction d'extraction personnalisée de Screaming Frog pour analyser votre site et extraire tout JSON-LD, puis exécutez la sortie via un script de validation. Surveille les problèmes en cours dans les rapports de données structurées de Google Search Console.

Devrais-je implémenter les types de schéma pour lesquels Google ne montre plus de résultats enrichis ? Oui. Les fonctionnalités SERP de Google ne sont qu'un consommateur de vos données structurées. ChatGPT, Perplexity, Bing Copilot et d'autres systèmes IA lisent tous le balisage de schéma. Même si Google a arrêté de montrer les résultats enrichis HowTo sur mobile, le schéma aide toujours les LLM à comprendre votre contenu. Pensez aux données structurées comme une couche universelle lisible par machine, pas seulement une fonctionnalité Google.