PRISMIC SEO AUDIT · HEADLESS CMS · SLICE MACHINE · AI VISIBILITY

Free Prismic SEO Audit

Prismic is headless — every SEO outcome depends on the frontend consuming its Content Delivery API. DeepSEOAnalysis audits the rendered output of Prismic-powered sites, detecting Slice Machine content rendering gaps, Custom Type SEO field coverage, sitemap generation with last_publication_date, and AI visibility signals — with Next.js and Gatsby fix guidance.

Audit my Prismic site →How we score

WHAT WE CHECK

6 Prismic-specific SEO checks

Prismic has no SEO output of its own. The audit evaluates the frontend consuming Prismic — detecting rendering mode (CSR vs SSR vs SSG), Slice Machine Rich Text content in server HTML, Custom Type SEO field coverage, sitemap sync via last_publication_date, robots.txt at the frontend domain (including preview and Slice Simulator paths), and AI visibility — with @prismicio/client query patterns and Next.js Server Component examples for each fix.

⚙️

Headless rendering gap detection

Prismic is a headless CMS that delivers structured content via its Content Delivery API — it has no HTML output of its own. A Next.js App Router frontend with Server Components fetches Prismic content server-side and renders complete HTML including metadata; Googlebot sees the full page on first-wave crawl. A React SPA frontend (Vite, Create React App) fetching Prismic client-side delivers an empty shell; Googlebot must wait for the second-wave JavaScript render, which can be delayed days to weeks. The audit detects the rendering mode by comparing the raw HTTP response (before JavaScript execution) against the fully rendered DOM. Content in headings, body text (from Rich Text fields rendered via `<PrismicRichText>`), or JSON-LD that is absent from the raw server response but present in the rendered DOM is flagged as a CSR rendering gap. Guidance covers migrating to Next.js App Router Server Components or Gatsby static generation.

📝

Custom Type SEO fields and metadata injection

In Prismic, each page type is defined as a Custom Type in Slice Machine. SEO fields must be added explicitly to every Custom Type that maps to a public URL. The recommended pattern: a "SEO & Metadata" Tab on each Custom Type containing `seo_title` (Key Text, placeholder: "Page title for Google — 50–60 chars"), `meta_description` (Key Text, placeholder: "Description for Google — 130–160 chars"), `og_image` (Image, target 1200×630px), and `noindex` (Boolean). The frontend fetches these fields alongside the main content fields in the `createClient().getByUID()` call and passes `seo_title` and `meta_description` to `generateMetadata()` in Next.js. Common gaps: the SEO tab exists on the "homepage" Custom Type but was never added to "blog-post", "product", or other types; content editors leave SEO fields empty because Prismic doesn\'t enforce them as required by default (add `NOT EMPTY` validation in Slice Machine to require them at publish time); the frontend falls back to the document\'s `data.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.

🔗

Slice Machine content and URL structure

Prismic\'s Slice Machine lets you define reusable content slices (e.g., Hero, TextSection, ImageGallery) that compose pages. For SEO, the key check is whether Rich Text slices render into the server-returned HTML. A Rich Text field rendered via `<PrismicRichText field={slice.primary.content} />` in a React Server Component produces HTML in the server response — Googlebot sees the body content. The same component in a `"use client"` component renders client-side — Googlebot sees nothing in the first wave. URL structure is determined by a `uid` field in each Prismic document (the URL slug). The `uid` must be keyword-descriptive (e.g., `my-article-title` not `a8f3kp2`) and the frontend must use it in routing. Common gaps: `uid` fields auto-generated as random strings when editors create documents without setting the UID; the frontend uses Prismic document IDs in routes instead of UIDs. The audit flags URL patterns that contain random-looking alphanumeric strings as critical on-page issues.

🗺️

Sitemap generation and last_publication_date sync

Sitemaps for Prismic sites must be generated by the frontend. In Next.js App Router: `app/sitemap.ts` queries Prismic for all published documents of each Custom Type using `createClient().getAllByType("page", { pageSize: 100 })` (repeat for each type), maps them to sitemap entries with `last_publication_date` for `lastModified`, and returns the array. For sites with more than 100 documents per type: use Prismic\'s pagination (`after` cursor, or iterate using the `getAllByType` convenience that handles pagination automatically). `last_publication_date` is a UTC ISO 8601 timestamp automatically maintained by Prismic — use it directly as `lastModified: new Date(document.last_publication_date)`. Configure Prismic webhooks to trigger frontend rebuilds on publish. Common gaps: the `Sitemap:` directive in `robots.txt` is missing or wrong; Prismic preview URLs (generated at routes like `/api/preview`) are accessible and not disallowed in robots.txt; draft content (not yet published) has no documents in the Content Delivery API and cannot accidentally appear in sitemaps (the CDA only serves published content — no filtering needed). The audit checks sitemap presence, URL count vs crawled pages, `lastmod` recency, and the Sitemap directive.

🤖

robots.txt at the frontend domain

robots.txt must be served at the public frontend domain, not at Prismic\'s API CDN (`cdn.prismic.io`). In Next.js: `public/robots.txt` (served automatically) or `app/robots.ts` returning a `MetadataRoute.Robots` object. In Gatsby: `static/robots.txt`. Common gaps: robots.txt is missing at the frontend domain entirely; AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Applebot-Extended) are blocked by a catch-all `Disallow: /`; the Prismic preview route (`/api/preview` or `/preview`) is not disallowed — Prismic preview URLs expose draft content to crawlers if not blocked; the Prismic Slice Simulator route (`/slice-simulator`) used during Slice Machine development is accessible on the production site and not disallowed; the `Sitemap:` directive is absent or points to the Prismic CDN rather than the frontend sitemap URL. The audit checks all AI crawler user-agents, the preview route disallow, the Slice Simulator path, and the Sitemap directive.

🧠

AI visibility for Prismic-powered sites

Serve `llms.txt` from the frontend\'s static directory (Next.js `public/llms.txt`, Gatsby `static/llms.txt`). For FAQPage JSON-LD: add a `faq_items` group field to relevant Custom Types in Slice Machine (each item: `question` Key Text, `answer` Rich Text), fetch via the API, and render the FAQPage JSON-LD server-side. In Next.js App Router: include the FAQ JSON-LD as `script type="application/ld+json"` in the Server Component rendering the page, not in a `use client` component. Article JSON-LD for blog posts: build from Prismic fields — `data.title`, `first_publication_date`, `last_publication_date`, `data.author` (a Link field to an author document), `data.og_image` — and inject via a Server Component. The `PrismicRichText` component renders Rich Text fields to HTML with semantic heading structure; ensure heading levels are used appropriately (H2/H3 for sections, and ≥20% of headings phrased as questions for the question-heading ratio signal). The audit checks all five AI visibility signals with Prismic data fetching patterns and Next.js Server Component examples for each fix.

HOW IT WORKS

Audit your Prismic site in 60 seconds

  1. Enter your public site URL. Works regardless of frontend — Next.js, Gatsby, Nuxt, SvelteKit, or any framework consuming Prismic's Content Delivery API. Enter the public frontend URL (not cdn.prismic.io). No Prismic repository name, access tokens, or Slice Machine access needed — the audit crawls the rendered HTTP output.
  2. We crawl and analyse. The engine detects the rendering mode, checks Rich Text slice content in the server-returned HTML (before JavaScript), validates metadata presence, checks UID-based URL slug patterns, validates JSON-LD structured data, tests the sitemap and robots.txt (including Prismic preview and Slice Simulator path disallows), measures CrUX Core Web Vitals, and evaluates all five AI visibility signals.
  3. You get a prioritised report. Prismic-specific issues first — rendering gaps, Custom Type SEO field coverage, PrismicRichText Server Component patterns, sitemap last_publication_date sync, robots.txt preview route disallow — then general SEO, each with @prismicio/client query examples and Next.js/Gatsby fix code.

FAQ

Questions about the Prismic SEO audit

Does Prismic have built-in SEO features?

Prismic is a headless CMS — it stores content in a document store and delivers it via REST and GraphQL APIs, but has no rendering layer. All SEO output comes from the frontend framework consuming Prismic\'s API. For SEO metadata, you create a "SEO & Metadata" tab (or a dedicated group field) in each Custom Type in Prismic, containing SEO Title (Key Text field), Meta Description (Key Text, max 160 chars), OG Image (Image field), and Noindex (Boolean field). The frontend queries these fields alongside the document content and injects them into the server-rendered HTML. Prismic\'s Slice Machine (the local development tool for building content models) doesn\'t add SEO fields automatically — you define the schema yourself. The `prismic-next` and `@prismicio/client` packages provide the data-fetching layer; the SEO output is entirely your frontend\'s responsibility.

What frontend framework works best with Prismic for SEO?

Next.js App Router is Prismic\'s recommended frontend and the best-supported option for SEO. The `@prismicio/next` package provides `PrismicNextImage` (responsive images with proper width/height for CLS prevention) and `PrismicNextLink` (internal link handling). For SEO: use `generateMetadata()` in each page route to fetch the document\'s SEO fields via `createClient().getByUID()` and return a Next.js `Metadata` object — this injects title, description, and OG tags into the server-rendered HTML. Gatsby with `gatsby-source-prismic` pre-renders all pages at build time from Prismic content. Nuxt with `@prismicio/nuxt` renders server-side. The key: metadata must be injected into the HTTP response, not added client-side via `useEffect`.

How do I generate a sitemap for a Prismic-powered site?

In Next.js App Router: create `app/sitemap.ts` that uses `createClient().getAllByType("page")` and similar calls for each content type to fetch all published documents, map them to sitemap entries using the document\'s `last_publication_date` field for `lastModified`, and return the `MetadataRoute.Sitemap` array. The `last_publication_date` is Prismic\'s ISO 8601 last-modified timestamp — the equivalent of Sanity\'s `_updatedAt` or Contentful\'s `sys.updatedAt`. For Gatsby: `gatsby-plugin-sitemap` uses the Gatsby GraphQL data layer (populated by `gatsby-source-prismic`) to generate the sitemap. Configure Prismic webhooks (Settings → Webhooks) to trigger a Vercel/Netlify rebuild when content is published, keeping the sitemap\'s `lastModified` dates current.

Is the Prismic 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.