STRAPI SEO AUDIT · HEADLESS CMS · FRONTEND RENDERING · AI VISIBILITY
Free Strapi SEO Audit
Strapi is headless — every SEO outcome depends on the frontend framework consuming its API. DeepSEOAnalysis audits the rendered output of Strapi-powered sites, detecting metadata injection gaps, rendering mode issues (CSR vs SSR), sitemap configuration, and AI visibility signals — with Next.js, Nuxt, and Gatsby fix guidance.
WHAT WE CHECK
6 Strapi-specific SEO checks
Strapi has no SEO output of its own. The audit evaluates the frontend that consumes Strapi — detecting headless rendering mode (CSR vs SSR vs SSG), metadata injection into server-rendered HTML, SEO plugin field coverage, sitemap configuration, and AI visibility — with Strapi plugin names and frontend framework fix guidance.
Headless rendering gap detection
Strapi is a headless CMS — it provides no frontend output. The rendered pages that search engines see come entirely from the frontend framework (Next.js, Nuxt, Gatsby, SvelteKit, Astro) consuming Strapi\'s API. The SEO quality of a Strapi-powered site is therefore determined by two things: (1) the SEO fields populated in Strapi\'s content types, and (2) whether the frontend renders those fields server-side (SSR or SSG) or client-side (CSR). If the frontend is a plain React app (Create React App, Vite) or a Vue app without Nuxt, metadata and content render client-side — Googlebot sees an empty shell on first-wave crawl. The audit detects the rendering mode, compares server-rendered HTML against the full DOM, and flags content or metadata that is present in the browser but absent from the server-rendered HTML. Framework-specific fix guidance is provided: Next.js `generateMetadata()`, Nuxt `useSeoMeta()`, SvelteKit `+layout.server.ts`.
SEO field coverage in content types
The `strapi-plugin-seo` plugin adds a shared SEO component to Strapi content types with fields for `metaTitle`, `metaDescription`, `metaRobots`, `canonicalURL`, `structuredData` (JSON-LD as a text field), `metaViewport`, `keywords`, and social sharing metadata (OG and Twitter Card fields). Without this plugin, there\'s no standardised place in Strapi to store per-content SEO metadata — developers typically add ad hoc fields or rely on the content title and description fields for SEO. Common coverage gaps even with the SEO plugin installed: meta descriptions populated for only some content types (blog posts but not product pages or landing pages); canonical URLs left empty (causing the frontend to omit the canonical tag or default to a potentially incorrect value); structuredData field left blank (requiring the frontend to construct all JSON-LD from other content fields). The audit checks the downstream SEO output — meta description uniqueness, canonical tag presence, and JSON-LD coverage — on the live pages regardless of whether the data originated from Strapi\'s SEO plugin or custom fields.
Frontend metadata injection
The bridge between Strapi\'s SEO fields and the rendered HTML is the frontend\'s metadata layer. In Next.js App Router: a Server Component fetches the Strapi API in `generateMetadata()` and returns a `Metadata` object — Next.js injects the resulting tags into the server-rendered `head`. In Nuxt: `useSeoMeta()` or `useHead()` in a `script setup` block pulls from a `useAsyncData(() => $fetch(\'/api/strapi/...\'))` composable and is executed server-side, injecting tags into the Nuxt SSR HTML. In Gatsby: `gatsby-source-strapi` populates GraphQL data nodes; `gatsby-plugin-react-helmet` or Gatsby Head API injects metadata at build time. The most common failure: metadata injected in a client-only lifecycle hook (`useEffect`, `onMounted`) that doesn\'t run during SSR — resulting in pages with no title or meta description in the server-rendered HTML. The audit checks whether title, meta description, and canonical are present in the raw server-rendered HTML for every crawled page.
Sitemap plugin configuration
`strapi-plugin-sitemap` (community plugin by Boaz Poolman / Strapi community) generates XML sitemaps directly from Strapi content. Configuration: install via npm, add to `config/plugins.js`, then configure which content types to include and the URL pattern for each. The plugin can generate a sitemap on a cron schedule or on content publish/update events. It serves the sitemap at a configurable URL (typically `https://your-strapi-instance.com/api/sitemap/index.xml` or proxied through the frontend). For frontend-generated sitemaps (recommended for Next.js, Nuxt, Gatsby): use `next-sitemap`, `@nuxtjs/sitemap`, or `gatsby-plugin-sitemap`, configured to fetch dynamic routes from Strapi\'s content API. Common gaps: the sitemap is generated but uses Strapi\'s API URL rather than the frontend\'s public URL; dynamic content (blog posts, products) is excluded from a statically configured sitemap; the `Sitemap:` directive in `robots.txt` is missing or points to the wrong URL. The audit checks sitemap presence at the frontend domain, URL coverage, and the Sitemap directive.
robots.txt and AI crawler access
For Strapi-powered sites, `robots.txt` is typically served by the frontend, not Strapi. In Next.js: place `public/robots.txt` (App Router) or use a `robots.ts` route handler to return the robots content dynamically. In Nuxt: place `public/robots.txt` or use `@nuxtjs/robots`. In Gatsby: place `static/robots.txt`. In all cases, the file must be accessible at the frontend domain at `/robots.txt` — not at the Strapi API URL. Common gaps: robots.txt is only at the Strapi API URL (e.g. `https://api.example.com/robots.txt`) but not at the public frontend domain (`https://example.com/robots.txt`); AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Applebot-Extended) are blocked by an overly broad `Disallow: /` rule; the `Sitemap:` directive points to the wrong domain (Strapi API rather than frontend public URL). The audit checks the file at the crawled domain\'s `/robots.txt`, all AI crawler user-agents, and the Sitemap directive.
AI visibility for Strapi-powered sites
Serve `llms.txt` from the frontend\'s public/static directory — Next.js `public/llms.txt`, Nuxt `public/llms.txt`, Gatsby `static/llms.txt`, SvelteKit `static/llms.txt`. JSON-LD structured data (FAQPage, Article, Product, BreadcrumbList) should be generated from Strapi content fields and injected into the server-rendered HTML by the frontend — either hardcoded in templates for content type patterns, or populated from the `structuredData` JSON field in `strapi-plugin-seo`. The `strapi-plugin-seo`\'s `structuredData` field accepts raw JSON-LD that editors can fill in; the frontend renders it as a `script type="application/ld+json"` in the server-rendered HTML. The audit checks all five AI visibility signals — llms.txt presence, AI crawler access, FAQPage/HowTo schema in server-rendered HTML, question-heading ratio (≥20%), and content chunkability (avg section ≤400w) — with Strapi plugin names and frontend framework code patterns for each fix.
HOW IT WORKS
Audit your Strapi-powered site in 60 seconds
- Enter your public site URL. Works regardless of frontend — Next.js, Nuxt, Gatsby, SvelteKit, Astro, or any framework consuming Strapi\'s API. Enter the public frontend URL (not the Strapi admin URL). No Strapi admin access or API keys needed — the audit crawls the rendered output.
- We crawl and analyse. The engine detects the rendering mode, checks metadata presence in the server-rendered HTML (before JavaScript execution), validates JSON-LD structured data, tests the sitemap and robots.txt at the frontend domain, measures CrUX Core Web Vitals, and evaluates all five AI visibility signals.
- You get a prioritised report. Strapi-specific issues first — rendering gaps, metadata injection failures, sitemap configuration — then general SEO, each with Strapi plugin names (`strapi-plugin-seo`, `strapi-plugin-sitemap`), npm package names, and frontend framework code patterns for the fix.
FAQ
Questions about the Strapi SEO audit
Does Strapi have built-in SEO features?
Strapi itself has no SEO output — it\'s a headless CMS that provides a REST API and GraphQL API for content. SEO is entirely the responsibility of the frontend framework consuming Strapi\'s data. The `strapi-plugin-seo` community plugin adds SEO fields (metaTitle, metaDescription, metaRobots, canonicalURL, structuredData, keywords) to Strapi content types via a shared component, and a `seoChecker` utility for validation within the admin panel. Installing the SEO plugin provides the data structure; the frontend (Next.js, Nuxt, Gatsby, SvelteKit) must read those fields via the API and inject them into the page\'s `head` server-side.
What frontend frameworks work best with Strapi for SEO?
Any SSR or SSG framework: Next.js (App Router with `generateMetadata()` pulling from Strapi\'s REST API or GraphQL), Nuxt.js (with `useSeoMeta()` composable pulling from Strapi), Gatsby (static builds with Strapi source plugin), SvelteKit (with `+layout.server.ts` loading SEO fields from Strapi). The key requirement for SEO: the frontend must render metadata (title, description, canonical, JSON-LD) into the server-rendered HTML — not add it client-side via `useEffect` or `onMounted`. A React frontend using Create React App (CSR) or a Vue app without Nuxt will have the rendering gap problem regardless of how well Strapi\'s SEO fields are configured.
How do I generate a sitemap for a Strapi-powered site?
Two approaches: (1) Strapi-side — use `strapi-plugin-sitemap` which generates `sitemap.xml` by querying Strapi content types and can be configured to run on cron or on content publish events. The sitemap is served from Strapi directly. (2) Frontend-side — for Next.js, use `next-sitemap` which generates `sitemap.xml` at build time from the routes, and can fetch Strapi content via the API to include dynamic page URLs. For Nuxt, use `@nuxtjs/sitemap`. Frontend-generated sitemaps are easier to keep in sync with the page structure and can use the `lastmod` field from Strapi\'s content API response.
Is the Strapi SEO audit free?
Yes. The complete audit is free with no signup and no email gate. Paid plans add saved history, scheduled monitoring, larger crawls (up to 1,000 pages), and agency workflows.