Strapi SEO

TL;DR — Strapi is a “headless” CMSA content management system (CMS) is software that lets users create, manage, and publish digital content — like blog posts and pages — without writing raw code. WordPress, Drupal, and Joomla are the most common open-source CMS platforms. — it stores your content and hands it out through an API, but it has no website attached. That means Strapi itself doesn’t decide your SEO; the frontend that turns Strapi’s content into pages does. The big rule is the same as for any headless setup: build your HTML on a server or at build time (SSR or SSG), not entirely in the visitor’s browser. And all the SEO stuff WordPress + Yoast did for you — titles, sitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing., robots.txtA plain-text file at the root of a host that tells crawlers which URLs they may and may not request. It controls crawling, not indexing — a blocked URL can still be indexed if it's linked from elsewhere. — you now set up yourself.

What Strapi actually is

Strapi is an open-source, Node.js-based headless CMSA headless CMS decouples content storage and editing (the backend) from how that content is rendered and delivered (the frontend), serving content over an API instead of a built-in templated 'head'. Its SEO outcomes come almost entirely from how the separate frontend renders pages.. “Headless” means it’s just the back half of a website — the place you write and store content — with no front half (no theme, no pages, no renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM.). You get your content out through a REST or GraphQL API. You can run Strapi on your own server or use Strapi Cloud to have them host it.

Because there’s no built-in website, Strapi pairs with a separate frontend framework — Next.js, Nuxt, Astro, or Gatsby are the common ones — that fetches content from Strapi and builds the actual pages people (and GooglebotGooglebot is Google's web crawler — the software that fetches pages so Google can index and rank them. It comes in two variants, Googlebot Smartphone (primary, under mobile-first indexing) and Googlebot Desktop, and runs an evergreen Chromium renderer.) see.

The one thing to understand

Strapi is neutral for SEO. It’s not good or bad on its own. What matters is how the frontend builds the page. There are two safe ways and one risky way:

• At build time (SSG) — pages are pre-built into plain HTML files. Fast and search-friendly.
• On a server, per request (SSR) — the server builds the full page and sends it. Also search-friendly.
• In the visitor’s browser (CSR) — the server sends a near-empty shell and JavaScript fills it in later. This is the risky one.

Google can eventually read browser-rendered pages, but it’s slower and less reliable. AI crawlerAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls. renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. behavior varies by vendor — there’s no single shared standard — but a crawlerA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. that fetches only the initial HTML (several of the bots behind ChatGPT and Perplexity currently work this way) sees exactly what CSR ships: an empty shell. Build your HTML on the server or at build time so the content is in the raw HTML no matter who’s fetching it.

The “where did my SEO settings go?” problem

Switching from WordPress + Yoast to Strapi, people are shocked that titles, meta descriptions, sitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing., and canonical tagsA rel=\"canonical\" annotation — in the HTML <head> or an HTTP Link header — that tells search engines which URL is the preferred version of duplicate or near-duplicate content. don’t appear by themselves. There’s no plugin layer doing it quietly in the background. With Strapi you have to:

• Add SEO fields (title, description, canonical, social image) to your content types — there’s an official-ish community SEO plugin that adds these for you.
• Wire those fields into the page’s HTML in the frontend.
• Build a sitemap and a robots.txtA plain-text file at the root of a host that tells crawlers which URLs they may and may not request. It controls crawling, not indexing — a blocked URL can still be indexed if it's linked from elsewhere..

None of this is hard; it just won’t happen on its own.

A few things that quietly break

• Drafts getting indexed. Strapi has a draft/publish workflow. Keep unpublished content out of search — don’t expose it through the public API.
• Preview sites getting indexed. Teams spin up preview/staging URLs to review drafts. If Google finds one, it can index a whole duplicate copy. Block them.
• The admin panel and raw API. Your /admin login and the /api/... JSON feed shouldn’t show up in search.

Want the full version — the four rendering modes, the SEO plugin, sitemaps, draft and preview hygiene, Strapi Cloud vs. self-hosted, and migrations? Switch to the Advanced tab.

TL;DR — Strapi is a backend-only headless CMSA headless CMS decouples content storage and editing (the backend) from how that content is rendered and delivered (the frontend), serving content over an API instead of a built-in templated 'head'. Its SEO outcomes come almost entirely from how the separate frontend renders pages. (REST + GraphQL, self-hosted or Strapi Cloud) with no renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. layer, so it is SEO-neutral — the frontend’s renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. mode decides everything. SSG/SSR ship fully-rendered HTML and are safe; CSR is risky (a crawlerA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. that fetches only the initial HTML sees an empty shell — that’s how several major AI crawlersAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls. currently behave); ISR has the stale-on-first-request trap. Model SEO fields in your content types (the community @strapi/plugin-seo stores and previews them but does not output HTML, sitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing., or robots.txtA plain-text file at the root of a host that tells crawlers which URLs they may and may not request. It controls crawling, not indexing — a blocked URL can still be indexed if it's linked from elsewhere. — that’s the frontend’s job). Keep drafts out via the publish workflow (never pass auth tokensA token is the smallest unit of text (or image/audio/video) an LLM processes — roughly 4 characters, or about ¾ of an English word. A context window is the maximum number of tokens (input plus output) a model can hold at once, like its short-term memory. in public requests), noindexNoindex is a directive that tells search engines to keep a page out of their index, so it won't appear in search results. It works only on pages a crawler can actually fetch — a page blocked in robots.txt can never be noindexed. preview/staging at the host level, keep /admin and raw /api/* JSON out of search, and build sitemap.xml + robots.txtA plain-text file at the root of a host that tells crawlers which URLs they may and may not request. It controls crawling, not indexing — a blocked URL can still be indexed if it's linked from elsewhere. at the frontend. Strapi is neutral; your architecture is the product.

Strapi is not the SEO decision — the frontend is

The single most important concept in Strapi SEOStrapi SEO is the practice of making content stored in Strapi — an open-source headless CMS — discoverable and rankable. Because Strapi has no built-in frontend, every SEO outcome is decided by the frontend framework that renders its API, not by Strapi itself.: Strapi has no rendering layer. It is content storage, a content model, an editing UI, and an API. Every SEO outcome — indexability, metadata, speed, structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. — is determined by the frontend framework consuming Strapi’s API. Strapi’s job is purely to store and serve the right fields.

That makes “Strapi is bad for SEO” the wrong frame. Strapi is neutral. As Strapi’s own team puts it, “headless architectures require developers to take ownership of SEO aspects that traditional content management systems handle automatically.” A Strapi + Next.js site rendering on SSG, with a disciplined metadata layer, will outperform a neglected WordPress install. A Strapi site fronted by a client-rendered React SPA with no metadata wiring will quietly fall apart. Same backend, opposite outcomes — because the rendering decisions differ. This is the same point I make about JavaScript SEO generally: the question to start with is always how is the frontend rendering this content?

The four rendering modes (the most critical decision)

• SSG — Static Site Generation. HTML built at build time, served as static files. Best-case SEO: fully-rendered HTML on first fetch, fast TTFBTime to First Byte — the time from the start of a request to when the first byte of the response arrives. It's a diagnostic metric (not a Core Web Vital) and a major input to FCP and LCP; ≤0.8 s is good. and Core Web Vitals. Tradeoff: new/changed content needs a rebuild. Gatsby and Astro are SSG-first; Next.js does it per route.
• SSR — Server-Side Rendering. HTML rendered per request on a server or edge. Always-fresh, fully-rendered HTML. Tradeoff: Strapi API latency lands directly in your TTFB on every request. Next.js, Nuxt, SvelteKit, Remix.
• ISR — Incremental Static Regeneration. Static pages regenerated in the background after a revalidation window. A good middle ground with one trap (below).
• CSR — Client-Side Rendering. A near-empty shell ships and the browser fetches from Strapi and builds the DOM. Worst SEO option: Google must queue the page for a later render wave — “GooglebotGooglebot is Google's web crawler — the software that fetches pages so Google can index and rank them. It comes in two variants, Googlebot Smartphone (primary, under mobile-first indexing) and Googlebot Desktop, and runs an evergreen Chromium renderer. queues all pages with a 200 HTTP status codeAn HTTP status code is the three-digit number a server returns with every response to tell a browser or crawler what happened to its request — success, redirect, client error, or server error. For SEO the code matters as much as the content: it tells Google and Bing whether to index a page, follow a redirect, retry later, or drop the URL from the index. for rendering, unless a robots meta tagThe robots meta tag is an HTML element in a page's head — <meta name=\"robots\" content=\"noindex\"> — that tells search engines how to index and serve that page. It's crawl-then-obey: a page blocked in robots.txt is never fetched, so the tag is never seen. or header tells Google not to index the page” — so your content doesn’t exist until that wave runs. AI crawlersAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls. and Bing handle this far worse than Google. Acceptable only for logged-in dashboards you don’t want indexed anyway. A raw React/Vue SPA over Strapi lands here by default — avoid it for public content.

The ISR trap: when the revalidation window expires, the next request — which could be Googlebot — still gets the stale cached page; the fresh one serves only on the following request. For volatile data (prices, stock), prefer SSR. ISR is ideal for content that changes on the order of hours or days.

Content modeling for SEO in Strapi

Strapi gives the frontend nothing to render unless you put the fields in the content model. For every public content type, add an SEO component with at minimum:

• metaTitle, metaDescription
• canonicalURL
• ogImage (and Open GraphOpen Graph (OG) tags are `<meta>` elements in a page's head, defined by the Open Graph protocol (ogp.me, created by Facebook), that describe a page as a shareable object — its title, description, image, URL, and type. They control how a link preview card looks when the page is shared on Facebook, LinkedIn, Slack, Discord, WhatsApp, and iMessage. They are not a direct Google ranking factor, though Google reads og:title, og:image, and og:site_name as inputs to how a result appears. / Twitter fields)
• a robots directive — e.g. a preventIndexing Boolean for per-entry noindexNoindex is a directive that tells search engines to keep a page out of their index, so it won't appear in search results. It works only on pages a crawler can actually fetch — a page blocked in robots.txt can never be noindexed. control

Use Strapi’s UID field for slugs — it auto-generates from the title and enforces uniqueness. For multilingual sites, enable Strapi’s built-in i18n per content type, localize the slug and SEO fields per locale, then output <link rel="alternate" hreflang="..."> in the frontend using the localizations relationship each entry exposes. As SALT.agency notes, the title “can either be populated with the Strapi SEO Plugin or by creating a text field where the title tagThe title tag is the HTML title element in a page's head that specifies the document's title. It's the primary source for the SERP title link and a confirmed light ranking factor — but since August 2021 Google doesn't always show it verbatim. will be stored, with conditions added such as not being shorter than or not exceeding a set amount of characters.”

The frontend then reads those fields from the API and populates the <head> — Next.js generateMetadata, Nuxt useSeoMeta, Astro’s layout <head>. The reliability rule is the same as all headless SEO: HTML-level metadata beats JS-injected metadata, because Google sees it on the first fetch.

The Strapi SEO plugin — what it does and doesn’t do

The community SEO plugin (@strapi/plugin-seo, formerly @strapi-community/plugin-seo, listed on the Strapi Market) is the standard tool. It “embeds a side panel in every Content-Type edit view where you can set meta titles, descriptions, canonical URLs, and social share images,” adds a SERP preview, and runs in-content analysis — green, orange, or red indicators for readability, keyword distribution, and schema compliance.

What it does not do, and this is the most common misconception:

• It does not generate the <head> HTML — the frontend renders the fields.
• It does not generate a sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. — that’s a separate plugin (on Strapi 5, the Webtools sitemap add-on or strapi-5-sitemap-plugin).
• It does not write robots.txt or implement structured data — frontend’s job.

In other words, the plugin gives editors a good authoring UX and stores clean fields. The frontend still has to do the actual SEO output.

Drafts, preview, /admin, and /api — keeping the wrong things out of the index

This is where Strapi has more failure modes than a hosted platform like Shopify.

• Draft/Publish. Strapi marks drafts with publishedAt: null; the API returns only published entries to unauthenticated requests. The critical discipline: never pass an authenticated API token in public frontend requests, or all draft content becomes fetchable. The sitemap plugin/add-on respects publish state and only includes published URLs.
• Preview / staging environments. Vercel branch deploys, Netlify deploy previews, and dedicated preview hosts consuming Strapi drafts are usually publicly reachable. Block them with a layered approach: an X-Robots-Tag: noindex header at the host level (not just a meta tag a CSR page injects late), Disallow: / in robots.txt, a noindex meta tag on every page, and HTTP authentication where possible. Watch Search ConsoleGoogle's free tool for monitoring crawling, indexing, and search performance. for unexpected hostnames — that’s your early warning.
• The /admin panel. Strapi’s admin is a React SPA; confirm it carries <meta name="robots" content="noindex"> (Strapi v4+ does), keep it off public links, and password-protect it — an unprotected /admin is discoverable via Google dorking.
• The raw /api/* JSON. It won’t rank as a page, but it wastes crawl budgetThe number of URLs an engine will crawl in a timeframe. and can leak data. Most production setups put the API on its own subdomain (cms.example.com / api.example.com); block that subdomain entirely in robots.txt and keep it off the sitemap. If API and frontend share a domain, Disallow: /api/.

Sitemaps and robots.txt — built at the frontend

There’s no Yoast, so both are explicit. Two sitemap routes:

1. A sitemap plugin inside Strapi — generates XML and only includes published entries. On Strapi 5 the maintained option is the Webtools sitemap add-on (strapi-plugin-webtools + webtools-addon-sitemap) for larger, multilingual sites, or strapi-5-sitemap-plugin for simpler ones. The older standalone strapi-plugin-sitemap (pluginpal) tops out at Strapi 4 — its own docs point v5 users to Webtools instead, so don’t install it on a v5 project. Quoting the plugin docs: when draft/publish is on, “this setting will make sure that all draft pages are excluded from the sitemap.”
2. Frontend-generated — Next.js sitemap.ts, Astro @astrojs/sitemap, Nuxt sitemap modules, fetching published URLs from the Strapi API. More control over canonical URLs, lastmod, and changefreq.

robots.txt is served from the frontend (Next.js robots.ts, Astro public/robots.txt). Include a Sitemap: directive, block preview hosts with Disallow: /, and — as with any headless stack — never 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 Google Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. and IndexNowIndexNow is an open push protocol that lets you instantly tell participating search engines (Bing, Yandex, Naver, Seznam, and Yep) which URLs you've added, changed, or removed via a simple HTTP request — and one submission is shared across all of them. Google does not use it.. Because headless content updates flow through an API rather than a plugin that pings search engines, IndexNow (Bing, Yandex, and others) is especially valuable wired to that publish webhook.

Strapi Cloud vs. self-hosted — the SEO implications

Strapi’s hosting affects API response time, which matters differently by rendering mode:

• SSG/ISR: Strapi API speed matters at build time, not runtime — pages are pre-built, so API latency doesn’t touch the user’s TTFB.
• SSR: Strapi API latency adds directly to TTFB on every request → affects LCPLargest Contentful Paint — render time of the largest visible image or text block, relative to when the page started loading. ≤2.5 s (at the 75th percentile) is good. → a real ranking input. This is the case to optimize.

Strapi Cloud is managed infrastructure with an asset CDN — good for teams without DevOps. Self-hosted gives you full control of caching (Redis), database indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed., and geographic proximity to the frontend. Either way: cache Strapi API responses at the CDN layer, or use ISR with short revalidation, to decouple frontend runtime from Strapi latency. One caveat worth stating plainly — Strapi Cloud’s CDN serves the Strapi API and assets, not your frontend website; your Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data. are measured against the frontend, which is hosted separately (Vercel, Netlify, Cloudflare Pages).

Migrating to or from Strapi

WordPress → Strapi is the common path, and migrations are where headless SEO actually goes wrong:

• Map every existing slug exactly onto Strapi’s UID field; any slug change needs a 301 redirectA 301 redirect is the HTTP status code for a permanent move: it tells browsers and search engines a URL has moved for good, and it's the strongest signal for consolidating a page's ranking signals onto the new URL. Google says permanent redirects don't cause a loss in PageRank. (use strapi-plugin-redirect-urls or Smart RedirectA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't. Manager, read by the frontend/middleware).
• Migrate meta titles, descriptions, and og:image from wp_postmeta into the SEO component fields, and image alt textAlt text is the value of the `alt` attribute on an HTML `<img>` element — a short text substitute chosen for the image's purpose and context, not a literal description of what it shows. It makes images accessible to screen-reader users and helps search engines understand images, mainly for image search. into the Media Library alternativeText field.
• Inventory every URL — not just posts: tag pages, paginated archives, parameter URLs — and build the redirect map before go-live.
• Migrate canonicals explicitly; don’t assume the frontend auto-generates them right.
• Post-launch: run a Screaming Frog crawl comparison, re-verify structured data with the Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test, resubmit sitemaps to GSC and Bing, and stand up IndexNow.

Strapi SEO is really a specialized application of JavaScript SEO and rendering — the sibling headless CMS SEOA headless CMS decouples content storage and editing (the backend) from how that content is rendered and delivered (the frontend), serving content over an API instead of a built-in templated 'head'. Its SEO outcomes come almost entirely from how the separate frontend renders pages. write-up covers the platform-agnostic version of all of this.

AI summary

A condensed take on the Advanced version:

• Strapi is SEO-neutral. It’s a backend-only headless CMSA headless CMS decouples content storage and editing (the backend) from how that content is rendered and delivered (the frontend), serving content over an API instead of a built-in templated 'head'. Its SEO outcomes come almost entirely from how the separate frontend renders pages. (REST + GraphQL, self-hosted or Strapi Cloud) with no renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. layer — the frontend decides everything. “Strapi is bad for SEO” is a myth.
• RenderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. mode is the product: SSG/SSR ship fully-rendered HTML and are safe; CSR is risky (content only exists after a later render wave, and AI crawlersA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index./Bing handle it poorly); ISR is a good middle ground with a stale-on-first-request trap — use SSR for volatile data.
• Model SEO fields in content types: metaTitle, metaDescription, canonicalURL, ogImage, a preventIndexing Boolean; UID field for slugs; i18n + localizations for hreflangHreflang is an annotation (in HTML, HTTP headers, or XML sitemaps) that tells search engines which language and optional region a page targets, and which alternate versions exist. It only works when every page in the cluster references all the others..
• The SEO plugin stores and previews fields but does not output <head> HTML, sitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing., or robots.txtA plain-text file at the root of a host that tells crawlers which URLs they may and may not request. It controls crawling, not indexing — a blocked URL can still be indexed if it's linked from elsewhere. — that’s the frontend’s job. The sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. 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-only.
• Keep the wrong things out of the indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed.: drafts (publish workflow; never pass auth tokensA token is the smallest unit of text (or image/audio/video) an LLM processes — roughly 4 characters, or about ¾ of an English word. A context window is the maximum number of tokens (input plus output) a model can hold at once, like its short-term memory. publicly), preview/staging (host-level noindex + robots Disallow: /
  • auth), /admin (noindexNoindex is a directive that tells search engines to keep a page out of their index, so it won't appear in search results. It works only on pages a crawler can actually fetch — a page blocked in robots.txt can never be noindexed. + password), and raw /api/* JSON (block, ideally on its own subdomain).
• Build sitemap.xml and robots.txtA plain-text file at the root of a host that tells crawlers which URLs they may and may not request. It controls crawling, not indexing — a blocked URL can still be indexed if it's linked from elsewhere. at the frontend; never block .js/.css; wire a publish webhook → rebuild → sitemap → GSC + IndexNowIndexNow is an open push protocol that lets you instantly tell participating search engines (Bing, Yandex, Naver, Seznam, and Yep) which URLs you've added, changed, or removed via a simple HTTP request — and one submission is shared across all of them. Google does not use it..
• Hosting: in SSR, Strapi API latency hits TTFBTime to First Byte — the time from the start of a request to when the first byte of the response arrives. It's a diagnostic metric (not a Core Web Vital) and a major input to FCP and LCP; ≤0.8 s is good./LCPLargest Contentful Paint — render time of the largest visible image or text block, relative to when the page started loading. ≤2.5 s (at the 75th percentile) is good. directly — cache it or use ISR. Strapi Cloud’s CDN is for the API/assets, not your frontend’s Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data..
• Migrations fail on broken 301s, lost metadata, and accidental CSR — full URL inventory + redirectA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't. map before go-live.

Official documentation

Primary-source documentation from the search engines (Strapi is renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM.-agnostic, so the SEO-relevant docs are the JavaScript/renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. ones).

Google

• Understand JavaScript SEO Basics — the crawl → render → indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. pipeline that governs how a Strapi frontend’s content gets indexed.
• Dynamic Rendering (deprecated workaround) — why Google deprecated it; use SSR, static rendering, or hydrationActivating server-rendered HTML in the browser by attaching JavaScript handlers. instead of prerendering a CSR Strapi frontend.
• Rendering for Content-Driven Web Apps — SSR vs. SSG vs. CSR tradeoffs for content sites like Strapi-powered editorial.
• Fix Search-Related JavaScript Problems — diagnosing rendered-DOM gaps in a JS frontend.
• Block Search indexing with noindex — the meta tag / X-Robots-Tag header used to keep drafts, preview hosts, and /admin out of the index.
• Introduction to robots.txt — what robots.txtA plain-text file at the root of a host that tells crawlers which URLs they may and may not request. It controls crawling, not indexing — a blocked URL can still be indexed if it's linked from elsewhere. does and doesn’t do (relevant for blocking the API subdomain and preview hosts).

Bing / Microsoft

• The new evergreen Bingbot (Microsoft Edge) — BingbotBingbot is Microsoft Bing's primary web crawler — the bot that discovers, fetches, and renders pages to build the Bing index. That index also powers Yahoo, DuckDuckGo, Ecosia, and Microsoft Copilot, so Bingbot's reach is far wider than Bing's own search-market share. renders JS, but less consistently than Google — another reason SSR/SSG matters on Strapi.
• IndexNow / indexnow.org — the push protocol to wire to your Strapi publish webhook.

Quotes from the source

On-the-record statements on JavaScript renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. (Google), plus the Strapi team and practitioners on headless SEO. Each link is a deep link that jumps to the quoted passage where the source supports it.

Google — how JavaScript pages are processed

• “GooglebotGooglebot is Google's web crawler — the software that fetches pages so Google can index and rank them. It comes in two variants, Googlebot Smartphone (primary, under mobile-first indexing) and Googlebot Desktop, and runs an evergreen Chromium renderer. queues all pages with a 200 HTTP status codeAn HTTP status code is the three-digit number a server returns with every response to tell a browser or crawler what happened to its request — success, redirect, client error, or server error. For SEO the code matters as much as the content: it tells Google and Bing whether to index a page, follow a redirect, retry later, or drop the URL from the index. for renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM., unless a robots meta tagThe robots meta tag is an HTML element in a page's head — <meta name=\"robots\" content=\"noindex\"> — that tells search engines how to index and serve that page. It's crawl-then-obey: a page blocked in robots.txt is never fetched, so the tag is never seen. or header tells Google not to indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. the page.” — Google Search 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.” — Google Search Central docs. Recommended instead: “server-side rendering, static rendering, or hydrationActivating server-rendered HTML in the browser by attaching JavaScript handlers..” Jump to quote

Strapi — headless shifts SEO ownership to developers

• “SEO in headless CMSA headless CMS decouples content storage and editing (the backend) from how that content is rendered and delivered (the frontend), serving content over an API instead of a built-in templated 'head'. Its SEO outcomes come almost entirely from how the separate frontend renders pages. 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, Headless CMSA content management system that separates the content repository from the presentation layer, delivering content via API to any front-end framework rather than rendering HTML server-side itself. It doesn't specify the rendering mode, hosting, cache, preview security, or publishing workflow — those are separate decisions. & Strapi SEOStrapi SEO is the practice of making content stored in Strapi — an open-source headless CMS — discoverable and rankable. Because Strapi has no built-in frontend, every SEO outcome is decided by the frontend framework that renders its API, not by Strapi itself. best practices. Read the post
• “When using the draft/publish functionality in Strapi, this setting will make sure that all draft pages are excluded from the sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing.. This ensures that only published content appears in search engine sitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing..” — Strapi Blog, Strapi SEO Plugins: Complete Guide for Strapi 5. Read the post
• “The official SEO plugin embeds a side panel in every Content-Type edit view where you can set meta titles, descriptions, canonical URLsHow search engines pick one canonical URL among duplicates and consolidate signals onto it., and social share images.” — Strapi Blog, Strapi SEO Plugins: Complete Guide for Strapi 5. Read the post

Practitioners — headless removes the defaults

• “Headless CMSA content management system (CMS) is software that lets users create, manage, and publish digital content — like blog posts and pages — without writing raw code. WordPress, Drupal, and Joomla are the most common open-source CMS platforms. platforms remove a lot of the defaults that traditional CMS platforms handle automatically — meta tagsMeta tags are HTML elements in a page's head that pass metadata about the page to search engines and browsers. For SEO only a few matter — the title element, the meta description, and the robots meta tag — while meta keywords and most others are ignored., canonical URLs, structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding., sitemaps, none of these come out of the box in a headless setup.” — Successive Digital, Headless CMS SEOA headless CMS decouples content storage and editing (the backend) from how that content is rendered and delivered (the frontend), serving content over an API instead of a built-in templated 'head'. Its SEO outcomes come almost entirely from how the separate frontend renders pages.: Avoid These Common Pitfalls. Read the post
• “The title can either be populated with the Strapi SEO Plugin or by creating a text field where the title tagThe title tag is the HTML title element in a page's head that specifies the document's title. It's the primary source for the SERP title link and a confirmed light ranking factor — but since August 2021 Google doesn't always show it verbatim. 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. Read the post

Two checklists: Strapi SEO health + migration

Strapi SEOStrapi SEO is the practice of making content stored in Strapi — an open-source headless CMS — discoverable and rankable. Because Strapi has no built-in frontend, every SEO outcome is decided by the frontend framework that renders its API, not by Strapi itself. health check

• The frontend renders content in HTML on first request (SSR or SSG), not only after client-side JavaScript runs.
• No public content type relies on CSR for its main content (many AI crawlersAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls. fetch only the initial HTML and never execute JavaScript).
• An SEO component (metaTitle, metaDescription, canonicalURL, ogImage, preventIndexing) exists on every public content type and is mapped into the <head>.
• Slugs use the UID field; canonicals are absolute URLs built from one SITE_URL, set at the renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. layer.
• The frontend never sends an authenticated API tokenA token is the smallest unit of text (or image/audio/video) an LLM processes — roughly 4 characters, or about ¾ of an English word. A context window is the maximum number of tokens (input plus output) a model can hold at once, like its short-term memory. in public requests (or drafts leak).
• Preview/staging hosts return a host-level X-Robots-Tag: noindex plus Disallow: / in robots.txtA plain-text file at the root of a host that tells crawlers which URLs they may and may not request. It controls crawling, not indexing — a blocked URL can still be indexed if it's linked from elsewhere. (and HTTP auth where possible).
• /admin is noindexed and password-protected; not linked publicly.
• The raw /api/* JSON is blocked in robots.txtA plain-text file at the root of a host that tells crawlers which URLs they may and may not request. It controls crawling, not indexing — a blocked URL can still be indexed if it's linked from elsewhere. (ideally on its own subdomain, kept off the sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing.).
• sitemap.xml is generated (sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. plugin or frontend) and lists only published, canonical URLsHow search engines pick one canonical URL among duplicates and consolidate signals onto it..
• robots.txt exists, includes a Sitemap: directive, and does not block .js/.css.
• A publish webhook triggers a rebuild/revalidate → sitemap regen → GSCA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. + IndexNowIndexNow is an open push protocol that lets you instantly tell participating search engines (Bing, Yandex, Naver, Seznam, and Yep) which URLs you've added, changed, or removed via a simple HTTP request — and one submission is shared across all of them. Google does not use it. ping.

Migration checklist (WordPress → Strapi)

• Full URL inventory — posts, pages, tag/category pages, paginated archives, parameter URLs.
• Slugs mapped exactly onto Strapi UID fields; 301 redirectA 301 redirect is the HTTP status code for a permanent move: it tells browsers and search engines a URL has moved for good, and it's the strongest signal for consolidating a page's ranking signals onto the new URL. Google says permanent redirects don't cause a loss in PageRank. map built before go-live (strapi-plugin-redirect-urls / Smart RedirectA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't. Manager).
• Meta titles, descriptions, og:image migrated into the SEO component.
• Image alt textAlt text is the value of the `alt` attribute on an HTML `<img>` element — a short text substitute chosen for the image's purpose and context, not a literal description of what it shows. It makes images accessible to screen-reader users and helps search engines understand images, mainly for image search. migrated into the Media Library alternativeText field.
• Canonicals verified on the new frontend (not assumed).
• RenderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. mode confirmed as SSR/SSG (not an accidental CSR default).
• Structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding. re-verified with the Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test.
• Sitemaps resubmitted to Google Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results. and Bing Webmaster ToolsMicrosoft's free portal for monitoring and improving how a site appears in Bing search — the peer to Google Search Console, plus IndexNow instant indexing, richer backlink data, and keyword volumes. Because Bing's index also feeds Microsoft Copilot, it doubles as a window into AI-search visibility.; IndexNowIndexNow is an open push protocol that lets you instantly tell participating search engines (Bing, Yandex, Naver, Seznam, and Yep) which URLs you've added, changed, or removed via a simple HTTP request — and one submission is shared across all of them. Google does not use it. stood up.

The mental models

1. Strapi is not the SEO decision — the frontend is. Strapi has no renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. layer. Before debugging anything, answer one question: how is the frontend renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. this content? Almost every Strapi SEOStrapi SEO is the practice of making content stored in Strapi — an open-source headless CMS — discoverable and rankable. Because Strapi has no built-in frontend, every SEO outcome is decided by the frontend framework that renders its API, not by Strapi itself. problem resolves to that.

2. The rendering-mode decision rule. Pick by how often the content changes:

• Mostly static (blogs, docs, marketing) → SSG.
• Always-fresh / volatile (prices, stock) → SSR.
• Hourly/daily, want static speed → ISR (mind the stale-first-request trap).
• Logged-in, not meant to be indexedStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. → CSR is acceptable.
• Public content you want ranked or cited by AIAn AI citation is the visible source link an AI answer engine shows next to its generated text — the clickable reference that credits the web page it used. A citation's presence is a separate thing from whether the cited page actually supports the statement, and from being retrieved (read behind the scenes) or merely mentioned (named without a link); citation is driven more by brand mentions and being retrievable than by traditional ranking. → never CSR.

3. “Rebuild what the plugin did.” Every automatic Yoast behavior is now a deliberate step in Strapi + frontend: SEO fields in the content model → mapped to <head> → sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. → robots.txtA plain-text file at the root of a host that tells crawlers which URLs they may and may not request. It controls crawling, not indexing — a blocked URL can still be indexed if it's linked from elsewhere. → canonicals → structured dataStructured data is a standardized way of labeling page content (using the schema.org vocabulary in JSON-LD, Microdata, or RDFa) so search engines can understand its meaning. It's not a direct ranking factor — its value is rich results and entity understanding.. If something’s “missing,” a plugin behavior was never re-implemented.

4. The plugin stores; the frontend renders. The SEO plugin gives editors fields and previews — it does not emit HTML, sitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing., or robots.txtA plain-text file at the root of a host that tells crawlers which URLs they may and may not request. It controls crawling, not indexing — a blocked URL can still be indexed if it's linked from elsewhere.. Keep those two responsibilities separate in your head and you won’t expect the plugin to do the frontend’s job.

5. Four things must never reach the index. Drafts, preview/staging deployments, /admin, and the raw /api/* JSON. Each has a different control (publish workflow, host-level noindexNoindex is a directive that tells search engines to keep a page out of their index, so it won't appear in search results. It works only on pages a crawler can actually fetch — a page blocked in robots.txt can never be noindexed., password + noindexNoindex is a directive that tells search engines to keep a page out of their index, so it won't appear in search results. It works only on pages a crawler can actually fetch — a page blocked in robots.txt can never be noindexed., robots block on its own subdomain). Audit all four explicitly.

Strapi SEO — cheat sheet

RenderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. modes at a glance

What Strapi/plugins do vs. what the frontend does

Keep out of the indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. — four controls

Fast rules

• Strapi is SEO-neutral — the renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. mode is the product.
• Use the UID field for slugs; canonicals = absolute URLs from one SITE_URL.
• The SEO plugin stores fields; it does not output HTML/sitemap/robots.
• Never disallow .js/.css in robots.txt.
• Wire a publish webhook → rebuild → sitemap → GSC + IndexNowIndexNow is an open push protocol that lets you instantly tell participating search engines (Bing, Yandex, Naver, Seznam, and Yep) which URLs you've added, changed, or removed via a simple HTTP request — and one submission is shared across all of them. Google does not use it..
• In SSR, cache the Strapi API (or use ISR) so latency doesn’t tank LCPLargest Contentful Paint — render time of the largest visible image or text block, relative to when the page started loading. ≤2.5 s (at the 75th percentile) is good..

How should a Strapi page render?

Incident playbook: published Strapi pages disappear from search

1. Confirm the public response. Check status, redirectsA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't., raw HTML, canonical, and robots directives. Fix a fetch or indexability failure before content analysis.
2. Trace publication. Match the Strapi publish event to webhook, build/revalidation, and cache logs. If the live page is stale, repair that chain.
3. Check template scope. Compare affected and healthy content types. If one template fails, inspect its frontend field mapping and route generation.
4. Check exposure. Ensure drafts, preview hosts, /admin, and raw API routes are excluded while public HTML routes remain crawlable.
5. Validate recovery. Confirm complete source HTML and a clean canonical/indexability state, then monitor normal recrawlCrawl frequency is how often a search engine comes back to re-fetch a page it already knows about. Popular pages that change often get refreshed many times a day; stable pages can go weeks or months between crawls — and you influence it indirectly, not by setting a dial. rather than repeatedly resubmitting unchanged pages.

Strapi SEO mistakes

• Treating an SEO plugin as a renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. layer. It creates fields; the frontend must output and validate them.
• Fetching essential content only in the browser. Use SSG, regeneration, or SSR for pages that need to rank.
• Exposing drafts and preview deployments. Require access and send server-visible noindex signals.
• Putting raw API URLs in sitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing.. SitemapsA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. should list canonical public HTML routes, not /api resources.
• Blocking all API access without checking the architecture. Protect private endpoints, but do not break server builds or renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. that legitimately depends on Strapi.

Content is published in Strapi but the page stays stale

Likely cause: webhook, build, revalidation, or cache failure. Fix: trace the content ID through each step and purge the affected route. Confirm: raw production HTML contains the published revision.

SEO fields are filled but tags are absent

Likely cause: the frontend query omits the SEO component or the head template does not map it. Fix: include the fields and render them during SSG/SSR. Confirm: curl returns the expected title, canonical, and robots tags.

Draft or preview content is indexable

Likely cause: a public preview host or client-only noindexNoindex is a directive that tells search engines to keep a page out of their index, so it won't appear in search results. It works only on pages a crawler can actually fetch — a page blocked in robots.txt can never be noindexed. logic. Fix: add authentication and server-level exclusion. Confirm: unauthenticated requests cannot access an indexable response.

A content type is missing from the sitemap

Likely cause: the frontend sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. query, publication filter, locale relation, or route mapping excludes it. Fix: correct the query and include canonical published routes only. Confirm: sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. entries resolve to indexable 200 pages.

Compare Strapi API data 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

Use the API response only from an authorized environment and do not print tokensA token is the smallest unit of text (or image/audio/video) an LLM processes — roughly 4 characters, or about ¾ of an English word. A context window is the maximum number of tokens (input plus output) a model can hold at once, like its short-term memory. into logs. The comparison checks delivery; it does not prove Google’s indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. decision.

Inspect rendered head values

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 change

Content-delivery test

Test to run: publish a controlled revision and trace Strapi, webhook, build/revalidation, cache, and live source. Expected result: one canonical production route serves the same published revision. Failure interpretation: delivery or invalidation is stale. Monitoring window: the normal publishing SLA. Rollback trigger: mixed contentMixed content is when a page served over HTTPS loads a sub-resource — a script, stylesheet, image, iframe, or similar — over insecure HTTP. Browsers' current taxonomy is upgradable versus blockable; active mixed content (scripts, styles, iframes) is blocked, and passive mixed content (images, audio, video) is warned about or increasingly auto-upgraded, with exceptions like CORS-enabled images and srcset/picture candidates that are blockable, not upgradable. and metadata versions reach production.

Source-rendering test

Test to run: compare raw and rendered HTML on representative content types. Expected result: primary content, links, metadata, and canonicals are present and agree. Failure interpretation: essential output depends on browser JavaScript. Monitoring window: every frontend release. Rollback trigger: a key template loses source content or indexability signals.

Exposure test

Test to run: request preview, draft, admin, API, and public routes without credentials. Expected result: sensitive routes are protected or excluded while canonical public pages remain crawlable. Failure interpretation: access and SEO controls are over- or under-scoped. Monitoring window: every routing or security change. Rollback trigger: drafts become public or public pages become blocked.

Tools for 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 them.
• Webtools sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. add-on (strapi-plugin-webtools + webtools-addon-sitemap, pluginpal) — the maintained Strapi 5 sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. option; generates sitemap.xml from published content and auto-splits into a sitemap indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. at scale. strapi-5-sitemap-plugin is a lighter alternative for simpler sites. Pluginpal’s older standalone strapi-plugin-sitemap only supports Strapi 4 — its README redirectsA redirect sends browsers and crawlers from a requested URL to a different one. An HTTP redirect specifically is a 3xx status code paired with a Location header; meta refresh and JavaScript redirects achieve a similar navigation without being a 3xx response themselves. Permanent redirects (301/308) are Google's signal the target should be canonical; temporary ones (302/303/307) aren't. v5 users to Webtools.
• strapi-plugin-redirect-urls / Smart Redirect Manager — manage 301/302 redirects in the admin for migrations and slug changes.
• URL InspectionA Google Search Console feature that reports how Google sees one specific URL on a property you own. By default it shows the last-indexed snapshot; a separate \"Test live URL\" mode fetches the current version. (Google Search ConsoleA free Google service that reports how a site performs in Google Search and surfaces problems with how Google crawls, indexes, and serves it. It's first-party data straight from Google — but you don't need it to appear in results.) — see how a single frontend URL was crawled and rendered; the rendered HTML tells you whether CSR left content out.
• Rich ResultsRich results (formerly 'rich snippets') are enhanced search listings — stars, images, prices, breadcrumbs, video thumbnails, and more — that Google and Bing build from structured data. They're a display feature, not a ranking factor, and eligibility never guarantees they'll show. Test — confirm JSON-LDJSON-LD (JavaScript Object Notation for Linked Data) is a script-based structured data format, typically paired with the schema.org vocabulary to describe page content for search engines and AI systems. Google recommends it over Microdata and RDFa because it's the easiest format to implement and maintain at scale — but all three work, and structured data isn't a ranking signal. is present in the rendered output after any renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. change.
• Screaming Frog SEO SpiderA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. — crawl with JS renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. on/off to compare raw vs. rendered HTML; build the pre/post crawl comparison for migrations; surface accidentally-indexable preview/admin/API URLs.
• Ahrefs Site Audit — surfaces broken canonicals, missing metadata, redirect chains, and indexability issues across the whole frontend.
• Bing Webmaster ToolsMicrosoft's free portal for monitoring and improving how a site appears in Bing search — the peer to Google Search Console, plus IndexNow instant indexing, richer backlink data, and keyword volumes. Because Bing's index also feeds Microsoft Copilot, it doubles as a window into AI-search visibility. — Bing’s rendering/indexingStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. view and where IndexNowIndexNow is an open push protocol that lets you instantly tell participating search engines (Bing, Yandex, Naver, Seznam, and Yep) which URLs you've added, changed, or removed via a simple HTTP request — and one submission is shared across all of them. Google does not use it. submissions show up.

Test yourself: Strapi SEO

Five quick questions on how SEO works on a Strapi-powered site. Pick an answer for each, then check.

Resources worth your time

My related writing

• JavaScript SEO Issues & Best Practices — my primary reference on renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM.; the core of how a Strapi frontend gets crawled and indexedStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed..
• The Beginner’s Guide to Technical SEO — where renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. and crawlingCrawling is how search engines use automated bots (like Googlebot and Bingbot) to discover URLs and download pages. A page has to be crawlable to be indexed, but crawling on its own isn't a ranking factor. fit in the bigger picture.

My speaking

• JavaScript SEO — Ungagged 2019 (SlideShare) — my walkthrough of how headless/decoupled CMSes split frontend from backend, plus GooglebotGooglebot is Google's web crawler — the software that fetches pages so Google can index and rank them. It comes in two variants, Googlebot Smartphone (primary, under mobile-first indexing) and Googlebot Desktop, and runs an evergreen Chromium renderer.’s stateless rendering. (Standing disclaimer: the dynamic-rendering recommendation in that deck is now outdated — Google deprecated it.)

On this site

• SEO for a Headless CMSA headless CMS decouples content storage and editing (the backend) from how that content is rendered and delivered (the frontend), serving content over an API instead of a built-in templated 'head'. Its SEO outcomes come almost entirely from how the separate frontend renders pages. — the platform-agnostic version of everything here.
• JavaScript SEOMaking sure search engines can crawl, render, and index content that depends on JavaScript. — the rendering pillar Strapi SEOStrapi SEO is the practice of making content stored in Strapi — an open-source headless CMS — discoverable and rankable. Because Strapi has no built-in frontend, every SEO outcome is decided by the frontend framework that renders its API, not by Strapi itself. sits on top of.

From around the industry

• React SEO: Best Practices (Sam Underwood, Ahrefs) — React is the most common frontend paired with Strapi and directly applicable; authored by Patrick’s Ahrefs colleague rather than Patrick.
• Headless CMS & Strapi SEO best practices (Strapi Blog) — Strapi’s own overview of where SEO ownership shifts in a headless setup.
• Strapi SEO Plugins: Complete Guide for Strapi 5 (Strapi Blog) — what the SEO and sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. plugins do, including the draft/publish-in-sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. 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.
• Headless CMS SEO: Avoid These Common Pitfalls (Successive Digital) — the duplicate-environment and missing-defaults problems that hit Strapi stacks.
• Webtools Sitemap add-on (docs) — the maintained Strapi 5 sitemap solution; the older strapi-plugin-sitemap (GitHub) only supports Strapi 4.
• @strapi/plugin-seo (npm) — the SEO plugin package and component reference.

Stats worth citing

• Strapi is open-source and dual-deploy. It’s a Node.js headless CMSA headless CMS decouples content storage and editing (the backend) from how that content is rendered and delivered (the frontend), serving content over an API instead of a built-in templated 'head'. Its SEO outcomes come almost entirely from how the separate frontend renders pages. with REST + GraphQL APIs, runnable self-hosted or on Strapi Cloud — the deployment choice affects API latency, which only touches Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data. in SSR (not SSG/ISR). Source
• The sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. add-on auto-splits past 50,000 URLs into a sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. and excludes drafts when draft/publish is enabled — the practical scale limit for a Strapi-generated sitemap. For Strapi 5, that’s the Webtools sitemap add-on, not the older standalone plugin (below). Source
• RenderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. behavior isn’t uniform across AI crawlersAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls., but the safe assumption is HTML-only. There’s no single shared spec — some fetchers execute JavaScript, most today don’t — so a crawlerA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. that reads only the initial HTML response sees an empty shell on a CSR page. SSR/SSG puts the content in the raw HTML and removes the guesswork, which is why it’s the safer default for AI visibilityLLM visibility (or AI visibility) is the aggregate measure of how often and how prominently a brand or page shows up in AI-generated answers — across AI Overviews, ChatGPT, Perplexity, Copilot, and Gemini. It's the AI-search analog of organic visibility, but it's driven by different signals. as well as Google/Bing. Context
• Google deprecated dynamic renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM.. Prerendering a CSR Strapi frontend is no longer the recommended workaround — Google now points to SSR, static rendering, or hydrationActivating server-rendered HTML in the browser by attaching JavaScript handlers.. Source

Strapi SEO

Strapi SEO is the practice of making content stored in Strapi — an open-source headless CMS — discoverable and rankable. Because Strapi has no built-in frontend, every SEO outcome is decided by the frontend framework that renders its API, not by Strapi itself.

Related: Headless CMS SEO, JavaScript SEO

Strapi SEO

Strapi SEO is what it takes to get search engines and AI crawlersAI crawlers are bots from AI companies that fetch web pages to train language models, build AI-search indexes, or answer live user questions. They come in three categories, each with its own user-agent tokens and its own robots.txt controls. to find, render, and rank content that lives in Strapi, an open-source, Node.js-based headless CMSA headless CMS decouples content storage and editing (the backend) from how that content is rendered and delivered (the frontend), serving content over an API instead of a built-in templated 'head'. Its SEO outcomes come almost entirely from how the separate frontend renders pages. that exposes content over REST and GraphQL APIs. Strapi can be self-hosted or run on Strapi Cloud, but it ships with no renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. layer — so on its own it neither helps nor hurts your SEO.

That’s the whole mental model: Strapi stores and serves the right content fields; the frontend framework consuming its API (Next.js, Nuxt, Astro, Gatsby, SvelteKit, Remix) is what actually renders the HTML search engines see. The renderingTurning HTML, CSS, and JavaScript into the final visual page and DOM. mode that frontend uses — SSG, SSR, ISR, or CSR — decides everything. SSG and SSR ship fully-rendered HTML and are the safe choices; CSR is the risky one because content only appears after JavaScript runs in the browser — and many AI crawlersA crawler — also called a spider or bot — is an automated program that fetches web pages, extracts their links, and queues new URLs to visit. Search engines use crawlers to discover and download content for their index. fetch only the initial HTML, so they never see it.

Strapi’s actual SEO surface area is narrow but important:

• Content modeling — adding an SEO component (meta title, description, canonical, Open GraphOpen Graph (OG) tags are `<meta>` elements in a page's head, defined by the Open Graph protocol (ogp.me, created by Facebook), that describe a page as a shareable object — its title, description, image, URL, and type. They control how a link preview card looks when the page is shared on Facebook, LinkedIn, Slack, Discord, WhatsApp, and iMessage. They are not a direct Google ranking factor, though Google reads og:title, og:image, and og:site_name as inputs to how a result appears., robots directive) to each public content type so the frontend has fields to render.
• The draft/publish workflow — keeping unpublished entries out of the indexStoring a crawled page in the search index so it can appear in results. Crawled is not the same as indexed — Google selects what to keep, and indexing isn't guaranteed. (the API only returns published content to unauthenticated requests).
• Plugins — the community SEO plugin populates and previews meta fields; a separate sitemapA sitemap is a file that lists the pages, images, videos, and other files on your site so search engines can discover them. It helps discovery, but submitting a sitemap doesn't guarantee crawling or indexing. plugin generates XML.
• Environment hygiene — keeping /admin, the raw /api/* JSON, and preview/staging deployments out of search engines.

Done well, a Strapi + Next.js site can outperform a traditional CMSA content management system (CMS) is software that lets users create, manage, and publish digital content — like blog posts and pages — without writing raw code. WordPress, Drupal, and Joomla are the most common open-source CMS platforms. on Core Web VitalsGoogle's three real-user UX metrics — LCP (loading), INP (responsiveness), and CLS (visual stability) — used by Google's ranking systems, with no official weight attached, measured on field data. and technical SEOTechnical SEO is the practice of making a site easy for search engines to crawl, render, index, and (now) be eligible for AI answers. It's the foundation that lets your content and links rank — not a ranking trick of its own.. Done with a client-rendered SPA and no metadata layer, it quietly falls apart — which is the source of the “Strapi is bad for SEO” myth.

Related: Headless CMS SEO, JavaScript SEO

Changelog