Guide Strapi SEO

TL;DR — Strapi is a “headless” CMS — it stores votre content and hands it out via an API, but it has aucun website attached. Que signifie Strapi itself doesn’t decide votre SEO; the frontend que turns Strapi’s content into pages fait. The big rule is the même as pour quelconque headless setup: construire votre HTML on a server or at construire temps (SSR or SSG), pas entirely in the visitor’s navigateur. And tout the SEO stuff WordPress + Yoast did pour vous — titles, sitemaps, robots.txt — vous now définir up yourself.

Ce que Strapi en réalité is

Strapi is an open-source, Node.js-based CMS headless. “Headless” signifie it’s simplement the back half of a website — the placer vous écrire and store content — with aucun front half (aucun theme, aucun pages, aucun rendering). Vous obtenir votre content out via a REST or GraphQL API. Vous pouvez run Strapi on votre propre server or utiliser Strapi Cloud to have les host it.

Parce que there’s aucun built-in website, Strapi pairs with a separate frontend framework — Suivant.js, Nuxt, Astro, or Gatsby are the courant ones — que récupère content from Strapi and builds the réel pages personnes (and Googlebot) voir.

The un chose to comprendre

Strapi is neutral pour le SEO. It’s pas bon or bad on its propre. Ce que matters is how the frontend builds lune page. Là are two safe façons and un risky façon:

• At construire temps (SSG) — pages are pre-built into plain HTML fichiers. Fast and search-friendly.
• On a server, per requête (SSR) — le serveur builds the complet page and sends it. Aussi search-friendly.
• In the visitor’s navigateur (CSR) — le serveur sends a near-empty shell and JavaScript fills it in plus tard. Ce is the risky un.

Google peut eventually lire browser-rendered pages, but it’s slower and moins reliable. AI robot d’exploration rendering behavior varies by vendor — there’s aucun unique shared standard — but a robot d’exploration que récupère seulement the initial HTML (several of the bots behind ChatGPT and Perplexity currently fonctionner ce façon) sees exactly ce que CSR ships: an vide shell. Construire votre HTML on le serveur or at construire temps so le contenu is in the raw HTML aucun matter who’s fetching it.

The “where did my SEO settings go?” problem

Switching from WordPress + Yoast to Strapi, personnes are shocked que titles, meta descriptions, sitemaps, and balise canonicals don’t apparaître by themselves. There’s aucun plugin couche doing it quietly in the background. With Strapi vous have to:

• Ajouter SEO fields (title, description, canonical, social image) to votre content types — there’s an official-ish community SEO plugin que adds ces pour vous.
• Wire ceux fields into lune page’s HTML in the frontend.
• Construire a sitemap and a robots.txt.

None of ce is hard; it simplement won’t se produire on its propre.

A few choses que quietly break

• Drafts getting indexé. Strapi has a draft/publish workflow. Garder unpublished content out of search — don’t expose it via the public API.
• Preview sites getting indexé. Teams spin up preview/staging URLs to examiner drafts. Si Google trouve un, it peut index a whole duplicate copy. Block les.
• The admin panel and raw API. Votre /admin login and the /api/... JSON feed shouldn’t montrer up in search.

Vouloir the complet version — the four rendering modes, the SEO plugin, sitemaps, draft and preview hygiene, Strapi Cloud vs. self-hosted, and migrations? Switch to the Avancé tab.

TL;DR — Strapi is a backend-only CMS headless (REST + GraphQL, self-hosted or Strapi Cloud) with aucun rendering couche, so it is SEO-neutral — the frontend’s rendering mode decides everything. SSG/SSR ship fully-rendered HTML and are safe; CSR is risky (a robot d’exploration que récupère seulement the initial HTML sees an vide shell — that’s how several major AI robots d’exploration currently behave); ISR has the stale-on-first-request trap. Model SEO fields in votre content types (the community @strapi/plugin-seo stores and previews les but fait pas output HTML, sitemaps, or robots.txt — that’s the frontend’s job). Garder drafts out via the publish workflow (jamais réussir auth tokens in public requêtes), noindex preview/staging at the host level, garder /admin and raw /api/* JSON out of search, and construire sitemap.xml + robots.txt at the frontend. Strapi is neutral; votre architecture is the product.

Strapi n’est pas the SEO decision — the frontend is

The unique la plupart important concept in Strapi SEO: Strapi has aucun rendering couche. It is content storage, a content model, an editing UI, and an API. Every SEO outcome — indexability, metadata, speed, données structurées — is determined by the frontend framework consuming Strapi’s API. Strapi’s job is purely to store and serve the correct fields.

Que rend “Strapi is bad for SEO” the incorrect frame. Strapi is neutral. As Strapi’s propre team puts it, “headless architectures exiger developers to prendre ownership of SEO aspects que traditional système de gestion de contenus handle automatically.” A Strapi + Suivant.js site rendering on SSG, with a disciplined metadata couche, va outperform a neglected WordPress install. A Strapi site fronted by a client-rendered React SPA with aucun metadata wiring va quietly fall apart. Même backend, opposite outcomes — parce que the rendering decisions differ. Ce is the même point I faire à propos de JavaScript SEO généralement: the question to commencer with is toujours how is the frontend rendering ce content?

The four rendering modes (the la plupart critical decision)

• SSG — Static Site Generation. HTML construit at construire temps, served as static fichiers. Best-case SEO: fully-rendered HTML on premier récupérer, fast TTFB and Core Web Vitals. Tradeoff: nouveau/modifié content nécessite a rebuild. Gatsby and Astro are SSG-first; Suivant.js fait it per route.
• SSR — Rendu côté serveur. HTML rendered per requête on a server or edge. Always-fresh, fully-rendered HTML. Tradeoff: Strapi API latency lands directement in votre TTFB on every requête. Suivant.js, Nuxt, SvelteKit, Remix.
• ISR — Incremental Static Regeneration. Static pages regenerated in the background après a revalidation window. A bon middle ground with un trap (ci-dessous).
• CSR — Rendu côté client. A near-empty shell ships and le navigateur récupère from Strapi and builds the DOM. Worst SEO option: Google doit queue lune page pour a plus tard render wave — “Googlebot queues tout pages with a 200 Code d’état HTTP pour rendering, unless a robots meta tag or header indique Google pas to index the page” — so votre content doesn’t exist jusqu’à que wave runs. AI robots d’exploration and Bing handle ce far worse que Google. Acceptable seulement pour logged-in dashboards vous don’t vouloir indexé anyway. A raw React/Vue SPA over Strapi lands ici by par défaut — éviter it pour public content.

The ISR trap: quand the revalidation window expires, the suivant requête — qui pourrait be Googlebot — encore obtient the stale mis en cache page; the fresh un sert seulement on the suivant requête. Pour volatile données (prices, stock), préférer SSR. ISR is ideal pour content que changements on the order of hours or days.

Content modeling pour le SEO in Strapi

Strapi donne the frontend nothing to render unless vous put the fields in le contenu model. Pour every public content type, ajouter an SEO component with at minimum:

• metaTitle, metaDescription
• canonicalURL
• ogImage (and Ouvrir Graph / Twitter fields)
• a robots directive — e.g. a preventIndexing Boolean pour per-entry noindex contrôler

Utiliser Strapi’s UID field pour slugs — it auto-generates from the title and enforces uniqueness. Pour multilingual sites, enable Strapi’s built-in i18n per content type, localize the slug and SEO fields per locale, alors output <link rel="alternate" hreflang="..."> in the frontend en utilisant the localizations relationship chaque entry exposes. As SALT.agency notes, the title “peut soit be populated with the Strapi SEO Plugin or by creating a text field où the title tag va be stored, with conditions ajouté tel as pas being shorter que or pas exceeding a définir amount of characters.”

The frontend alors reads ceux fields from the API and populates the <head> — Suivant.js generateMetadata, Nuxt useSeoMeta, Astro’s layout <head>. The reliability rule is the même as tout headless SEO: HTML-level metadata beats JS-injected metadata, parce que Google sees it on the premier récupérer.

The Strapi SEO plugin — ce que it fait and doesn’t do

The community SEO plugin (@strapi/plugin-seo, formerly @strapi-community/plugin-seo, listed on the Strapi Market) is the standard outil. It “embeds a side panel in every Content-Type edit view où vous pouvez définir meta titles, descriptions, URL canoniques, and social share images,” adds a SERP preview, and runs in-content analysis — green, orange, or red indicators pour readability, keyword distribution, and schema compliance.

Ce que it fait pas do, and ce is the la plupart courant misconception:

• It fait pas generate the <head> HTML — the frontend renders the fields.
• It fait pas generate a sitemap — that’s a separate plugin (on Strapi 5, the Webtools sitemap add-on or strapi-5-sitemap-plugin).
• It fait pas écrire robots.txt or implement données structurées — frontend’s job.

En d’autres termes, the plugin donne editors a bon authoring UX and stores clean fields. The frontend encore has to do the réel SEO output.

Drafts, preview, /admin, and /api — keeping the incorrect choses out of the index

Ce is où Strapi has plus échec modes que a hosted platform comme Shopify.

• Draft/Publish. Strapi marks drafts with publishedAt: null; the API renvoie seulement publié entries to unauthenticated requêtes. The critical discipline: jamais réussir an authenticated API token in public frontend requêtes, or tout draft content becomes fetchable. Le sitemap plugin/add-on respects publish state and seulement inclut publié URLs.
• Preview / staging environments. Vercel branch deploys, Netlify deploy previews, and dedicated preview hosts consuming Strapi drafts are usually publicly reachable. Block les with a layered approach: an X-Robots-Tag: noindex header at the host level (pas simplement a meta tag a CSR page injects late), Disallow: / in robots.txt, a noindex meta tag on every page, and HTTP authentication où possible. Watch Search Console pour unexpected hostnames — that’s votre early warning.
• The /admin panel. Strapi’s admin is a React SPA; confirmer it carries <meta name="robots" content="noindex"> (Strapi v4+ fait), garder it off public liens, and password-protect it — an unprotected /admin is discoverable via Google dorking.
• The raw /api/* JSON. It won’t rank as une page, but it wastes budget d’exploration and peut leak données. La plupart production setups put the API on its propre subdomain (cms.example.com / api.example.com); block que subdomain entirely in robots.txt and garder it off le sitemap. Si API and frontend share a domain, Disallow: /api/.

Sitemaps and robots.txt — construit at the frontend

There’s aucun Yoast, so les deux are explicit. Two sitemap routes:

1. A sitemap plugin à l’intérieur Strapi — generates XML and seulement inclut publié entries. On Strapi 5 the maintained option is the Webtools sitemap add-on (strapi-plugin-webtools + webtools-addon-sitemap) pour plus grand, multilingual sites, or strapi-5-sitemap-plugin pour simpler ones. The older standalone strapi-plugin-sitemap (pluginpal) tops out at Strapi 4 — its propre docs point v5 utilisateurs to Webtools à la place, so don’t install it on a v5 project. Quoting the plugin docs: quand draft/publish is on, “ce setting va assurez-vous que tout draft pages are excluded from le sitemap.”
2. Frontend-generated — Suivant.js sitemap.ts, Astro @astrojs/sitemap, Nuxt sitemap modules, fetching publié URLs from the Strapi API. Plus contrôler over URL canoniques, lastmod, and changefreq.

robots.txt is served from the frontend (Suivant.js robots.ts, Astro public/robots.txt). Inclure a Sitemap: directive, block preview hosts with Disallow: /, and — as with quelconque headless stack — jamais disallow .js or .css (it blocks rendering).

The high-value pattern is the webhook workflow: Strapi fires a webhook on publish → triggers a Vercel/Netlify rebuild or on-demand revalidation → regenerates the sitemap → pings Recherche Google Console and IndexNow. Parce que headless content updates flow via an API plutôt que a plugin que pings moteur de recherches, IndexNow (Bing, Yandex, and others) is surtout valuable wired to que publish webhook.

Strapi Cloud vs. self-hosted — the SEO implications

Strapi’s hosting affecte API réponse temps, qui matters differently by rendering mode:

• SSG/ISR: Strapi API speed matters at construire temps, pas runtime — pages are pre-built, so API latency doesn’t touch the user’s TTFB.
• SSR: Strapi API latency adds directement to TTFB on every requête → affecte LCP → a réel ranking input. Ce is the cas to optimize.

Strapi Cloud is managed infrastructure with an asset CDN — bon pour teams sans DevOps. Self-hosted donne vous complet contrôler of mise en cache (Redis), database indexation, and geographic proximity to the frontend. Soit façon: cache Strapi API réponses at the CDN couche, or utiliser ISR with short revalidation, to decouple frontend runtime from Strapi latency. Un caveat worth stating plainly — Strapi Cloud’s CDN sert the Strapi API and assets, pas votre frontend website; votre Core Web Vitals are mesuré contre the frontend, qui is hosted separately (Vercel, Netlify, Cloudflare Pages).

Migrating to or from Strapi

WordPress → Strapi is the courant chemin, and migrations are où headless SEO en réalité goes incorrect:

• Map every existing slug exactly onto Strapi’s UID field; quelconque slug modifier nécessite a 301 redirection (utiliser strapi-plugin-redirect-urls or Smart Redirection Manager, lire by the frontend/middleware).
• Migrate meta titles, descriptions, and og:image from wp_postmeta into the SEO component fields, and image texte alternatif into the Media Library alternativeText field.
• Inventory every URL — pas simplement posts: tag pages, paginated archives, parameter URLs — and construire the redirection map avant go-live.
• Migrate canonicals explicitly; don’t assume the frontend auto-generates les correct.
• Post-launch: run a Screaming Frog explorer comparison, re-verify données structurées with the Résultats enrichis Tester, resubmit sitemaps to GSC and Bing, and stand up IndexNow.

Strapi SEO is really a specialized application of JavaScript SEO and rendering — the sibling CMS headless SEO write-up covers the platform-agnostic version of tout of ce.

AI summary

A condensed prendre on the Avancé version:

• Strapi is SEO-neutral. It’s a backend-only CMS headless (REST + GraphQL, self-hosted or Strapi Cloud) with aucun rendering couche — the frontend decides everything. “Strapi is bad for SEO” is a myth.
• Rendering mode is the product: SSG/SSR ship fully-rendered HTML and are safe; CSR is risky (content seulement exists après a plus tard render wave, and AI robots d’exploration/Bing handle it poorly); ISR is a bon middle ground with a stale-on-first-request trap — utiliser SSR pour volatile données.
• Model SEO fields in content types: metaTitle, metaDescription, canonicalURL, ogImage, a preventIndexing Boolean; UID field pour slugs; i18n + localizations pour hreflang.
• The SEO plugin stores and previews fields but fait pas output <head> HTML, sitemaps, or robots.txt — that’s the frontend’s job. Le sitemap is a separate plugin — on Strapi 5 that’s the Webtools sitemap add-on or strapi-5-sitemap-plugin; the older standalone strapi-plugin-sitemap is Strapi-4-seulement.
• Garder the incorrect choses out of the index: drafts (publish workflow; jamais réussir auth tokens publicly), preview/staging (host-level noindex + robots Disallow: /
  • auth), /admin (noindex + password), and raw /api/* JSON (block, ideally on its propre subdomain).
• Construire sitemap.xml and robots.txt at the frontend; jamais block .js/.css; wire a publish webhook → rebuild → sitemap → GSC + IndexNow.
• Hosting: in SSR, Strapi API latency hits TTFB/LCP directement — cache it or utiliser ISR. Strapi Cloud’s CDN is pour the API/assets, pas votre frontend’s Core Web Vitals.
• Migrations échouer on broken 301s, lost metadata, and accidental CSR — complet URL inventory + redirection map avant go-live.

Documentation officielle

Primary-source documentation from the moteur de recherches (Strapi is rendering-agnostic, so the SEO-relevant docs are the JavaScript/rendering ones).

Google

• Comprendre JavaScript SEO Basics — the explorer → render → index pipeline que governs how a Strapi frontend’s content obtient indexé.
• Dynamic Rendering (deprecated workaround) — pourquoi Google deprecated it; utiliser SSR, static rendering, or hydration au lieu de prerendering a CSR Strapi frontend.
• Rendering pour Content-Driven Web Apps — SSR vs. SSG vs. CSR tradeoffs pour content sites comme Strapi-powered editorial.
• Fix Search-Related JavaScript Problems — diagnosing rendered-DOM gaps in a JS frontend.
• Block Search indexation with noindex — the meta tag / X-Robots-Tag header utilisé to garder drafts, preview hosts, and /admin out of the index.
• Introduction to robots.txt — ce que robots.txt fait and doesn’t do (relevant pour blocking the API subdomain and preview hosts).

Bing / Microsoft

• The nouveau evergreen Bingbot (Microsoft Edge) — Bingbot renders JS, but moins consistently que Google — un autre raison SSR/SSG matters on Strapi.
• IndexNow / indexnow.org — the push protocol to wire to votre Strapi publish webhook.

Quotes from the source

On-the-record statements on JavaScript rendering (Google), plus the Strapi team and practitioners on headless SEO. Chaque lien is a deep lien que jumps to the quoted passage où the source supports it.

Google — how JavaScript pages are processed

• “Googlebot queues all pages with a 200 HTTP status code for rendering, unless a robots meta tag or header tells Google not to index the page.” — Recherche Google Central docs. Jump to quote

Google — dynamic rendering is deprecated

• “Dynamic rendering was a workaround and not a long-term solution for problems with JavaScript-generated content in search engines.” — Recherche Google Central docs. Recommended à la place: “server-side rendering, static rendering, or hydration.” Jump to quote

Strapi — headless shifts SEO ownership to developers

• “SEO in headless CMS architectures is a more technical challenge that requires careful implementation, as headless architectures require developers to take ownership of SEO aspects that traditional content management systems handle automatically.” — Strapi Blog, CMS headless & Strapi SEO meilleur practices. Lire the post
• “When using the draft/publish functionality in Strapi, this setting will make sure that all draft pages are excluded from the sitemap. This ensures that only published content appears in search engine sitemaps.” — Strapi Blog, Strapi SEO Plugins: Complet Guide pour Strapi 5. Lire the post
• “The official SEO plugin embeds a side panel in every Content-Type edit view where you can set meta titles, descriptions, canonical URLs, and social share images.” — Strapi Blog, Strapi SEO Plugins: Complet Guide pour Strapi 5. Lire the post

Practitioners — headless removes the defaults

• “Headless CMS platforms remove a lot of the defaults that traditional CMS platforms handle automatically — meta tags, canonical URLs, structured data, sitemaps, none of these come out of the box in a headless setup.” — Successive Digital, CMS headless SEO: Éviter Ces Courant Pitfalls. Lire the post
• “The title can either be populated with the Strapi SEO Plugin or by creating a text field where the title tag will be stored, with conditions added such as not being shorter than or not exceeding a set amount of characters.” — SALT.agency, The SEO guide to Strapi. Lire the post

Two checklists: Strapi SEO health + migration

Strapi SEO health vérifier

• The frontend renders content in HTML on premier requête (SSR or SSG), pas seulement après client-side JavaScript runs.
• Aucun public content type relies on CSR pour its principal content (nombreux AI robots d’exploration récupérer seulement the initial HTML and jamais execute JavaScript).
• An SEO component (metaTitle, metaDescription, canonicalURL, ogImage, preventIndexing) exists on every public content type and is mapped into the <head>.
• Slugs utiliser the UID field; canonicals are absolute URLs construit from un SITE_URL, définir at the rendering couche.
• The frontend jamais sends an authenticated API token in public requêtes (or drafts leak).
• Preview/staging hosts retourner a host-level X-Robots-Tag: noindex plus Disallow: / in robots.txt (and HTTP auth où possible).
• /admin is noindexed and password-protected; pas lié publicly.
• The raw /api/* JSON is blocked in robots.txt (ideally on its propre subdomain, kept off le sitemap).
• sitemap.xml is generated (sitemap plugin or frontend) and listes seulement publié, URL canoniques.
• robots.txt exists, inclut a Sitemap: directive, and ne fait pas block .js/.css.
• A publish webhook triggers a rebuild/revalidate → sitemap regen → GSC + IndexNow ping.

Migration checklist (WordPress → Strapi)

• Complet URL inventory — posts, pages, tag/category pages, paginated archives, parameter URLs.
• Slugs mapped exactly onto Strapi UID fields; 301 redirection map construit avant go-live (strapi-plugin-redirect-urls / Smart Redirection Manager).
• Meta titles, descriptions, og:image migrated into the SEO component.
• Image texte alternatif migrated into the Media Library alternativeText field.
• Canonicals verified on the nouveau frontend (pas assumed).
• Rendering mode confirmed as SSR/SSG (pas an accidental CSR par défaut).
• Données structurées re-verified with the Résultats enrichis Tester.
• Sitemaps resubmitted to Recherche Google Console and Bing Webmaster Outils; IndexNow stood up.

The mental models

1. Strapi n’est pas the SEO decision — the frontend is. Strapi has aucun rendering couche. Avant debugging anything, réponse un question: how is the frontend rendering ce content? Almost every Strapi SEO problem resolves to que.

2. The rendering-mode decision rule. Pick by how souvent le contenu changements:

• Mostly static (blogs, docs, marketing) → SSG.
• Always-fresh / volatile (prices, stock) → SSR.
• Hourly/daily, vouloir static speed → ISR (mind the stale-first-request trap).
• Logged-in, pas meant to be indexé → CSR is acceptable.
• Public content vous vouloir ranked or cited by AI → jamais CSR.

3. “Rebuild what the plugin did.” Every automatic Yoast behavior is now a deliberate step in Strapi + frontend: SEO fields in le contenu model → mapped to <head> → sitemap → robots.txt → canonicals → données structurées. Si something’s “missing,” a plugin behavior was jamais re-implemented.

4. The plugin stores; the frontend renders. The SEO plugin donne editors fields and previews — it fait pas emit HTML, sitemaps, or robots.txt. Garder ceux two responsibilities separate in votre head and vous won’t expect the plugin to do the frontend’s job.

5. Four choses doit jamais reach the index. Drafts, preview/staging deployments, /admin, and the raw /api/* JSON. Chaque has a différent contrôler (publish workflow, host-level noindex, password + noindex, robots block on its propre subdomain). Audit tout four explicitly.

Strapi SEO — cheat sheet

Rendering modes En un coup d’œil

Ce que Strapi/plugins do vs. ce que the frontend fait

Garder out of the index — four contrôle

Fast rules

• Strapi is SEO-neutral — the rendering mode is the product.
• Utiliser the UID field pour slugs; canonicals = absolute URLs from un SITE_URL.
• The SEO plugin stores fields; it fait pas output HTML/sitemap/robots.
• Jamais disallow .js/.css in robots.txt.
• Wire a publish webhook → rebuild → sitemap → GSC + IndexNow.
• In SSR, cache the Strapi API (or utiliser ISR) so latency doesn’t tank LCP.

How devrait a Strapi page render?

Incident playbook: publié Strapi pages disappear from search

1. Confirmer the public réponse. Vérifier status, redirections, raw HTML, canonical, and robots directives. Fix a récupérer or indexability échec avant content analysis.
2. Trace publication. Match the Strapi publish event to webhook, construire/revalidation, and cache logs. Si the live page is stale, repair que chain.
3. Vérifier template scope. Comparer affected and sain content types. Si un template fails, inspect its frontend field mapping and route generation.
4. Vérifier exposure. Garantir drafts, preview hosts, /admin, and raw API routes are excluded pendant que public HTML routes remain crawlable.
5. Validate recovery. Confirmer complet source HTML and a clean canonical/indexability state, alors monitor normal recrawl plutôt que repeatedly resubmitting unchanged pages.

Strapi SEO mistakes

• Treating an SEO plugin as a rendering couche. It creates fields; the frontend doit output and validate les.
• Fetching essential content seulement in le navigateur. Utiliser SSG, regeneration, or SSR pour pages que besoin to rank.
• Exposing drafts and preview deployments. Exiger accès and send server-visible noindex signals.
• Putting raw API URLs in sitemaps. Sitemaps devrait liste canonical public HTML routes, pas /api resources.
• Blocking tout API accès sans checking the architecture. Protéger private endpoints, but ne faites pas break server builds or rendering que legitimately dépend on Strapi.

Content is publié in Strapi but lune page stays stale

Probable causer: webhook, construire, revalidation, or cache échec. Fix: trace le contenu ID via chaque step and purge the affected route. Confirmer: raw production HTML contient the publié revision.

SEO fields are filled but tags are absent

Probable causer: the frontend requête omits the SEO component or the head template ne fait pas map it. Fix: inclure the fields and render les during SSG/SSR. Confirmer: curl renvoie the attendu title, canonical, and robots tags.

Draft or preview content is indexable

Probable causer: a public preview host or client-only noindex logic. Fix: ajouter authentication and server-level exclusion. Confirmer: unauthenticated requêtes ne peut pas accès an indexable réponse.

A content type is manquant from le sitemap

Probable causer: the frontend sitemap requête, publication filter, locale relation, or route mapping excludes it. Fix: correct the requête and inclure canonical publié routes seulement. Confirmer: sitemap entries resolve to indexable 200 pages.

Comparer Strapi API données with production HTML

curl -fsS 'https://cms.example.com/api/articles/SLUG' > strapi.json
curl -fsSL 'https://www.example.com/SLUG/' > page.html
grep -Eio '<title>[^<]+|<link[^>]+rel="canonical"[^>]*|<meta[^>]+name="robots"[^>]*' page.html

Utiliser the API réponse seulement from an authorized environment and ne faites pas print tokens into logs. The comparison checks delivery; it ne fait pas prove Google’s indexation decision.

Inspect rendered head valeurs

Run in DevTools Console:

({title: document.title, canonical: document.querySelector('link[rel="canonical"]')?.href, robots: document.querySelector('meta[name="robots" i]')?.content});

Prove a Strapi SEO modifier

Content-delivery tester

Tester to run: publish a controlled revision and trace Strapi, webhook, construire/revalidation, cache, and live source. Attendu result: un canonical production route sert the même publié revision. Échec interpretation: delivery or invalidation is stale. Monitoring window: the normal publishing SLA. Rollback trigger: mixed content and metadata versions reach production.

Source-rendering tester

Tester to run: comparer raw and rendered HTML on representative content types. Attendu result: principal content, liens, metadata, and canonicals are présent and agree. Échec interpretation: essential output dépend on navigateur JavaScript. Monitoring window: every frontend release. Rollback trigger: a clé template loses source content or indexability signals.

Exposure tester

Tester to run: requête preview, draft, admin, API, and public routes sans credentials. Attendu result: sensitive routes are protected or excluded pendant que canonical page publiques remain crawlable. Échec interpretation: accès and SEO contrôle are over- or under-scoped. Monitoring window: every routing or security modifier. Rollback trigger: drafts become public or page publiques become blocked.

Outils pour Strapi SEO

• @strapi/plugin-seo (community SEO plugin) — adds the SEO component, SERP preview, and in-content analysis to the Strapi admin. Install via yarn add @strapi/plugin-seo. Stores fields; doesn’t render les.
• Webtools sitemap add-on (strapi-plugin-webtools + webtools-addon-sitemap, pluginpal) — the maintained Strapi 5 sitemap option; generates sitemap.xml from publié content and auto-splits into a sitemap index at scale. strapi-5-sitemap-plugin is a lighter alternative pour simpler sites. Pluginpal’s older standalone strapi-plugin-sitemap seulement supports Strapi 4 — its README redirections v5 utilisateurs to Webtools.
• strapi-plugin-redirect-urls / Smart Redirection Manager — manage 301/302 redirections in the admin pour migrations and slug changements.
• Inspection d’URL (Recherche Google Console) — voir how a unique frontend URL was crawled and rendered; the rendered HTML indique vous si CSR left content out.
• Résultats enrichis Tester — confirmer JSON-LD is présent in the rendered output après quelconque rendering modifier.
• Screaming Frog SEO Spider — explorer with JS rendering on/off to comparer raw vs. rendered HTML; construire the pre/post explorer comparison pour migrations; surface accidentally-indexable preview/admin/API URLs.
• Ahrefs Site Audit — surfaces broken canonicals, manquant metadata, redirection chains, and indexability problèmes à travers the whole frontend.
• Bing Webmaster Outils — Bing’s rendering/indexation view and où IndexNow submissions montrer up.

Testez vos connaissances: Strapi SEO

Five rapide questions on how SEO fonctionne on a Strapi-powered site. Pick an réponse pour chaque, alors vérifier.

Ressources utiles

My connexe writing

• JavaScript SEO Problèmes & Meilleur Practices — my principal référence on rendering; the core of how a Strapi frontend obtient crawled and indexé.
• The Beginner’s Guide to SEO technique — où rendering and exploration fit in the bigger picture.

My speaking

• JavaScript SEO — Ungagged 2019 (SlideShare) — my walkthrough of how headless/decoupled CMSes split frontend from backend, plus Googlebot’s stateless rendering. (Standing disclaimer: the dynamic-rendering recommendation in que deck is now outdated — Google deprecated it.)

On ce site

• SEO pour a CMS headless — the platform-agnostic version of everything ici.
• JavaScript SEO — the rendering pillar Strapi SEO sits on top of.

From autour the industry

• React SEO: Meilleur Practices (Sam Underwood, Ahrefs) — React is the la plupart courant frontend paired with Strapi and directement applicable; authored by Patrick’s Ahrefs colleague plutôt que Patrick.
• CMS headless & Strapi SEO meilleur practices (Strapi Blog) — Strapi’s propre overview of où SEO ownership shifts in a headless setup.
• Strapi SEO Plugins: Complet Guide pour Strapi 5 (Strapi Blog) — ce que the SEO and sitemap plugins do, notamment the draft/publish-in-sitemap behavior.
• The SEO guide to Strapi (SALT.agency) — an independent technical-SEO-agency walkthrough of modeling SEO fields in Strapi.
• Strapi SEO Tips and Tricks (Notum Tech) — from the team behind the original SEO plugin.
• CMS headless SEO: Éviter Ces Courant Pitfalls (Successive Digital) — the duplicate-environment and missing-defaults problems que hit Strapi stacks.
• Webtools Sitemap add-on (docs) — the maintained Strapi 5 sitemap solution; the older strapi-plugin-sitemap (GitHub) seulement supports Strapi 4.
• @strapi/plugin-seo (npm) — the SEO plugin package and component référence.

Stats worth citing

• Strapi is open-source and dual-deploy. It’s a Node.js CMS headless with REST + GraphQL APIs, runnable self-hosted or on Strapi Cloud — the deployment choice affecte API latency, qui seulement touches Core Web Vitals in SSR (pas SSG/ISR). Source
• Le sitemap add-on auto-splits past 50 000 URLs into a sitemap index and excludes drafts quand draft/publish is enabled — the practical scale limite pour a Strapi-generated sitemap. Pour Strapi 5, that’s the Webtools sitemap add-on, pas the older standalone plugin (ci-dessous). Source
• Rendering behavior isn’t uniform à travers AI robots d’exploration, but the safe assumption is HTML-only. There’s aucun unique shared spec — some fetchers execute JavaScript, la plupart today don’t — so a robot d’exploration que reads seulement the initial HTML réponse sees an vide shell on a CSR page. SSR/SSG puts le contenu in the raw HTML and removes the guesswork, qui is pourquoi it’s the safer par défaut pour AI visibility as bien as Google/Bing. Context
• Google deprecated dynamic rendering. Prerendering a CSR Strapi frontend is aucun plus long the recommended workaround — Google now points to SSR, static rendering, or hydration. Source

Journal des modifications