CONTENTFUL SEO AUDIT · HEADLESS CMS · FRONTEND RENDERING · AI VISIBILITY
Free Contentful SEO Audit
Contentful is headless — every SEO outcome depends on the frontend consuming its API. DeepSEOAnalysis audits the rendered output of Contentful-powered sites, detecting metadata injection gaps, CSR rendering mode problems, sitemap configuration, and AI visibility signals — with Next.js, Gatsby, and Nuxt fix guidance.
WHAT WE CHECK
6 Contentful-specific SEO checks
Contentful has no SEO output of its own. The audit evaluates the frontend that consumes Contentful — detecting rendering mode (CSR vs SSR vs SSG), metadata injection into server-rendered HTML, SEO content model coverage, sitemap configuration, robots.txt at the correct domain, and AI visibility — with Contentful SDK calls and frontend framework patterns for each fix.
Headless rendering gap detection
Contentful is a headless CMS that delivers content via API — it has no rendering output of its own. The SEO quality of a Contentful-powered site depends entirely on the frontend framework. A Next.js App Router frontend with SSR renders all content (including metadata) into the server-returned HTML — Googlebot sees the full page on first-wave crawl. A React SPA frontend without SSR (Vite + React, Create React App) renders client-side — Googlebot sees an empty shell and must wait for the second-wave JavaScript render, which can be delayed days to weeks. The audit detects the rendering mode by comparing the server-returned HTML against the full rendered DOM. If headings, body content, or JSON-LD are absent from the raw HTTP response but present in the browser-rendered output, the page is flagged as CSR-affected. Guidance is provided for migrating to Next.js SSR/SSG or Gatsby SSG to fix the rendering gap.
SEO field model and metadata injection
Contentful has no native SEO field model — you create it. The recommended pattern: a reusable `Seo` content type with fields `seoTitle` (Short text), `metaDescription` (Short text, max 160 chars), `canonicalUrl` (Short text), `noindex` (Boolean), `ogTitle` (Short text), `ogDescription` (Short text), and `ogImage` (Media). This `Seo` content type is linked as a reference field (`seoMetadata`) on every primary content type (Page, Article, Product). The frontend fetches both the content entry and its linked `seoMetadata` and injects the fields into the HTML head. In Next.js App Router: `generateMetadata()` fetches the entry, reads `entry.fields.seoMetadata.fields`, and returns the `Metadata` object. Common gaps: the `Seo` content type exists but many entries leave `metaDescription` empty (Contentful doesn\'t enforce required fields at the API level, only at publish time if configured); the frontend falls back to the entry\'s `title` field for the page title but has no description fallback — producing pages with titles but empty meta descriptions. The audit checks every crawled page for a unique, non-empty title and meta description in the server-rendered HTML.
URL structure from frontend routing
Contentful stores content in entries identified by entry IDs (e.g., `2uNOpLMJioKeoMq8W...`). URLs are generated by the frontend, not by Contentful — a page entry might have a `slug` field that the frontend uses to build the URL. The critical check: the `slug` field must contain keyword-rich, hyphen-separated, lowercase slugs (`/blog/my-article-title` not `/blog/2uNOpLMJioKeoMq8`), and the frontend must use this slug field in its routing. Common gaps: slugs auto-generated from entry IDs rather than from the `title` field; slug field exists but is never populated by content editors for some content types; the frontend has inconsistent URL conventions (some routes use slugs, others use Contentful entry IDs in the path). The audit checks URL patterns across all crawled pages and flags any that contain Contentful entry ID patterns (long alphanumeric strings) as critical on-page issues.
Sitemap generation and Contentful sync
Sitemap generation for Contentful-powered sites must be done by the frontend, not Contentful. In Next.js App Router: `app/sitemap.ts` (or `app/sitemap.xml/route.ts`) fetches all published entries from Contentful\'s Content Delivery API and generates the sitemap dynamically or at build time. The `lastmod` value should come from the Contentful entry\'s `sys.updatedAt` timestamp — this ensures the sitemap reflects when content was actually updated, not when the build ran. For Gatsby: `gatsby-plugin-sitemap` uses the GraphQL data layer (populated by `gatsby-source-contentful`) to generate the sitemap from all pages created from Contentful content. Common gaps: the sitemap is generated at build time but Contentful content is updated between builds (static builds need scheduled rebuilds or ISR to stay current); the `Sitemap:` directive in `robots.txt` is absent or points to the wrong URL (Contentful CDN URL instead of the frontend domain). The audit checks sitemap presence, URL count vs crawled pages, `lastmod` recency, and the Sitemap directive.
robots.txt at the frontend domain
For Contentful-powered sites, `robots.txt` must be served at the public frontend domain, not at the Contentful CDN (`cdn.contentful.com` which returns Contentful\'s own robots.txt). In Next.js: place `public/robots.txt` (served directly) or create `app/robots.ts` to return a `MetadataRoute.Robots` object. In Gatsby: place `static/robots.txt`. In Nuxt: place `public/robots.txt`. Common gaps: `robots.txt` exists at the Contentful API domain but not at the frontend domain; AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Applebot-Extended) are blocked by a security-default `Disallow: /`; the `Sitemap:` directive points to the Contentful CDN rather than the frontend\'s sitemap URL; Contentful\'s preview API URLs (`preview.contentful.com`) are not disallowed (they serve unpublished draft content and should not be indexed if accessible). The audit checks the file at `/robots.txt` on the public frontend domain, all AI crawler user-agents, and the Sitemap directive.
AI visibility for Contentful-powered sites
Serve `llms.txt` from the frontend\'s static directory (Next.js `public/llms.txt`, Gatsby `static/llms.txt`, Nuxt `public/llms.txt`). FAQPage JSON-LD for pages with FAQ content: add a `faqItems` array field to your Contentful content type, fetch the FAQ entries via the Content Delivery API, and render the JSON-LD schema server-side in the frontend template. In Next.js App Router: include the FAQ JSON-LD as a `script type="application/ld+json"` in the page\'s Server Component or in `generateMetadata()` via the `other` metadata field. Article JSON-LD for blog posts: build the schema from Contentful entry fields (`title`, `sys.createdAt`, `sys.updatedAt`, `author` reference field, `seoMetadata.ogImage`) and inject via a Server Component. 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 Contentful SDK calls and Next.js/Gatsby component patterns for each fix.
HOW IT WORKS
Audit your Contentful site in 60 seconds
- Enter your public site URL. Works regardless of frontend — Next.js, Gatsby, Nuxt, SvelteKit, Astro, Remix, or any framework consuming Contentful's Content Delivery API. Enter the public frontend URL (not `cdn.contentful.com`). No Contentful space ID, API keys, or admin access 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), checks for Contentful entry ID patterns in URLs, 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. Contentful-specific issues first — rendering gaps, SEO field model coverage, metadata injection, sitemap sync, robots.txt domain — then general SEO, each with Contentful content model field names, SDK code patterns, and Next.js/Gatsby component examples for the fix.
FAQ
Questions about the Contentful SEO audit
Does Contentful have built-in SEO features?
Contentful is a headless CMS — it stores and delivers structured content via REST and GraphQL APIs but has no rendering layer. SEO is entirely the responsibility of the frontend framework consuming Contentful\'s content delivery API. Contentful does not generate HTML, title tags, meta descriptions, sitemaps, or structured data on its own. For SEO fields, you add a dedicated SEO content model in Contentful (a content type with fields like `seoTitle`, `metaDescription`, `canonicalUrl`, `noindex`, `ogImage`) and populate them per entry; the frontend reads these fields via the API and injects them into the server-rendered HTML. Apps in the Contentful Marketplace (e.g., the SEO by Yoast for Contentful app) can add SEO guidance in the editor sidebar, but the actual SEO output still comes from the frontend.
What frontend framework works best with Contentful for SEO?
Any SSR or SSG framework. Next.js App Router is the most commonly used: fetch from Contentful\'s content delivery API in `generateMetadata()` (pulls `seoTitle` and `metaDescription` from the entry and injects them as HTML head tags server-side) and in the page Server Component (renders content in server-side HTML). Gatsby with `gatsby-source-contentful` pre-renders all pages at build time from Contentful content — excellent for SEO (all content in static HTML). Nuxt with `useAsyncData(() => $fetch(...))` renders server-side. The key: whichever framework, metadata must be injected into the server-rendered HTML, not added client-side via `useEffect` or `document.title`.
How do I generate a sitemap for a Contentful-powered site?
Frontend-generated sitemaps are the most reliable approach. In Next.js App Router: create `app/sitemap.ts` that fetches all published entries from Contentful\'s content delivery API (using the `contentful` SDK or a plain fetch to `https://cdn.contentful.com/spaces/{SPACE_ID}/entries`), maps them to `MetadataRoute.Sitemap` objects with URL and `lastModified` from the Contentful `sys.updatedAt` field, and returns the array — Next.js generates the XML. In Gatsby: `gatsby-plugin-sitemap` generates `sitemap.xml` from the GraphQL pages query, which includes all Contentful-sourced pages. Add a `Sitemap:` directive to `robots.txt` pointing to the generated sitemap URL.
Is the Contentful 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.