CONTENTSTACK SEO AUDIT · ENTERPRISE HEADLESS CMS · DELIVERY API · NEXT.JS
Free Contentstack SEO Audit
Contentstack is an enterprise headless CMS — SEO fields are defined in content type models, populated by editors, and consumed by the frontend via the Delivery API. Meta tags, JSON-LD, sitemaps, and Core Web Vitals are all frontend responsibilities. DeepSEOAnalysis audits the rendered frontend HTML — validating JSON-LD from Contentstack entry fields, real CrUX Core Web Vitals, Delivery API sitemap coverage, AI crawler access for enterprise-gated sites, and all five AI visibility signals — with Contentstack content type field paths and frontend SDK locations for every finding.
WHAT WE CHECK
6 Contentstack-specific SEO checks
Contentstack SEO auditing covers content type SEO field groups and generateMetadata() output, URL slug routing and environment configuration, JSON-LD from Delivery API fields with property-level validation (including Reference field resolution), Delivery API sitemap coverage with pagination handling, real CrUX Core Web Vitals with Contentstack CDN image optimisation and ISR, and AI visibility including enterprise security configurations that block AI crawlers.
Contentstack SEO fields and generateMetadata() output
Contentstack content types require custom SEO fields defined by developers — editors populate these fields per entry. The audit validates the rendered frontend meta tag output. The audit checks: meta title presence and quality (the `seo.title` Group field in the content type feeds `generateMetadata()` — if empty, the frontend falls back to the entry\'s title field, which is typically not optimised for search; all pages relying on the fallback are flagged); meta description coverage (the `seo.description` Group field — empty field means no meta description in the rendered page; the audit flags all pages missing a meta description); canonical tag accuracy (Contentstack has no auto-generated canonical — the frontend must set `alternates.canonical` from either the `seo.canonical_url` field or the entry\'s URL slug; missing canonical tags on Contentstack pages are flagged); Open Graph tags (the `seo.og_image` File field provides the OG image URL from images.contentstack.io CDN — the URL must be absolute, not a relative path; og:title and og:description sourced from SEO fields or fallback to title/description); noindex consistency (the `seo.no_index` boolean field must trigger `metadata.robots = "noindex"` in `generateMetadata()` — AND exclude the entry from the sitemap; the audit checks for pages noindexed in the HTML but still present in the sitemap); and environment configuration (if the API key used in production points to a staging environment, staging-only entries may be rendered publicly — a content exposure risk flagged in the audit).
Contentstack URL slug routing and content model structure
Contentstack entries use a URL or slug field that the frontend maps to public routes. The audit checks: URL slug quality (the slug field in Contentstack entries determines the public URL — auto-generated slugs from the entry title can include stop words, characters that CMS normalises differently from URL expectations, or inconsistent patterns; the audit checks for non-canonical URL patterns in the canonical tag); `generateStaticParams()` coverage (Next.js static generation for Contentstack requires querying all published entries via `Stack.ContentType().Query().toJSON().find()` — the audit checks that all sitemap URLs return 200 responses; 404s indicate gaps in `generateStaticParams()` or content that\'s published in Contentstack but not handled by the frontend routing); environment segregation (Contentstack uses environments to separate production from staging — the `CONTENTSTACK_ENVIRONMENT` in the production Next.js build must point to the production environment; entries published only to staging should return 404 from the public site); redirect handling (Contentstack doesn\'t manage frontend redirects — when a slug changes, the old URL returns 404 unless handled by Next.js redirects in `next.config.js` or a separate redirects content type); localization routing (for multi-locale Contentstack stacks, the locale is specified in the Delivery API request — the frontend must handle locale routing and implement hreflang tags linking locale variants; the audit checks for missing hreflang on multi-locale pages); and Reference field resolution (entries that reference other content types for related content, author data, or category taxonomy must use `includeReference()` to inline the referenced data — missing reference resolution results in null fields in JSON-LD and meta tags).
JSON-LD from Contentstack Delivery API entries
Contentstack\'s Delivery API returns content type entry fields that the frontend maps to JSON-LD structured data. The audit validates all JSON-LD against Google\'s Rich Results specifications. For `Article` JSON-LD: `headline` from `entry.seo.title` or `entry.title` — must be under 110 characters (Contentstack\'s Short text field can be configured with a max length validation in the content type editor — add a max:110 validation to prevent editors from entering oversized headlines); `datePublished` from `entry.publish_details.time` (Contentstack automatically includes publish details in the delivered entry — verify the frontend includes `include_publish_details: true` in the API request options); `dateModified` from `entry.updated_at` (included in every Contentstack entry metadata); `author` from the `entry.author` Reference field (use `Stack.ContentType().includeReference("author")` to resolve the Reference and access `entry.author[0].title` or `entry.author[0].name`); `image` from `entry.featured_image.url` (Contentstack files include a CDN URL — must be absolute; Contentstack\'s CDN supports format transformation parameters: `?format=webp&width=1200`). For `FAQPage` JSON-LD: the `faq_items` Blocks field returns an array of objects with `question` and `answer` properties — map to `mainEntity` array of Question objects. Common Contentstack-specific JSON-LD errors: null `author` when Reference field is not resolved inline (missing `includeReference()` call); null `datePublished` when `publish_details` is not requested in the API call; `image.url` returning a Contentstack management URL (beginning with `eu.api.contentstack.io` or `cdn.contentstack.io/v3`) instead of the CDN delivery URL (beginning with `images.contentstack.io`).
Contentstack Delivery API sitemap and crawl configuration
Contentstack has no native sitemap generation — the Next.js frontend queries the Delivery API to build `app/sitemap.ts`. The audit checks: sitemap accessibility (/sitemap.xml must return valid XML); content type coverage (the sitemap should include all published entries across all relevant content types — pages, articles, products, blog posts — each requiring a separate Delivery API query per content type; missing content types in the sitemap leave significant crawlable content undiscovered by Googlebot without sitemap guidance); `lastmod` accuracy (Contentstack entries include `updated_at` — map to sitemap `lastModified` via `new Date(entry.updated_at).toISOString()`); `no_index` exclusion (entries with `seo.no_index: true` must be excluded from the sitemap — the Delivery API query should filter for entries where `no_index` is not true, or the sitemap generation function must filter after retrieval); pagination handling (Contentstack\'s Delivery API returns a maximum of 100 entries per request by default — for stacks with more than 100 entries per content type, the sitemap query must paginate using `skip` and `limit` parameters to retrieve all entries; missing pagination results in incomplete sitemap coverage); environment-scoped queries (use the `environment` configuration in the Delivery API call to ensure only production-published entries appear in the sitemap); and robots.txt configuration (`app/robots.ts` should declare `Sitemap:` pointing to the sitemap URL; the Contentstack management API paths should be disallowed if the management API endpoints are publicly exposed).
Core Web Vitals for Contentstack-powered sites
Contentstack is a pure API-layer headless CMS — Core Web Vitals are entirely determined by the frontend framework and image delivery configuration. The audit uses real CrUX field data. **LCP** — Contentstack images are delivered from `images.contentstack.io` CDN with on-the-fly transformation support: `?width=1200&format=webp&quality=80` parameters on the CDN URL produce optimised images without additional tooling. For Next.js: configure `images.contentstack.io` in `next.config.js` `images.remotePatterns`, then wrap Contentstack image URLs in Next.js `Image` components with `priority` on the hero/LCP image. For the Article featured image (typically the LCP element on article pages): set the `priority` prop to add `fetchpriority="high"` and disable lazy loading. For Contentstack image URLs used as CSS backgrounds: add a `link rel="preload" as="image"` hint for the image URL in the page `head`. **INP** — Contentstack-powered Next.js sites using React Server Components for content rendering have minimal client-side JavaScript for content display, supporting low INP. Ensure Contentstack\'s JavaScript SDK is not imported on the client side in components that don\'t need it (`server-only` package prevents accidental client-side Contentstack SDK bundling). **CLS** — Contentstack image File fields include `dimension` metadata (width and height) when images are uploaded with dimension detection enabled; use these dimensions as the `width` and `height` props on `Image` components to prevent CLS. **TTFB** — implement Next.js ISR with `revalidate` for Contentstack page routes; Contentstack supports webhooks (on-publish triggers) that can call Next.js On-Demand Revalidation endpoints to invalidate ISR cache when content is updated.
AI visibility for Contentstack enterprise sites
Contentstack enterprise deployments often include security configurations (IP allowlisting, authentication) that can accidentally block AI crawlers. The audit checks all five AI visibility signals. For `llms.txt`: Contentstack has no native llms.txt feature. In the Next.js frontend, add `app/llms.txt/route.ts` that generates the llms.txt from the Contentstack Delivery API — querying a dedicated "LLMs Content" content type where editors can curate key pages and descriptions for AI consumption, or auto-generating from the sitemap content types. For `robots.txt`: in `app/robots.ts`, ensure GPTBot, ClaudeBot, PerplexityBot, Google-Extended (for Gemini), and CCBot are not in any Disallow block. Enterprise Contentstack deployments may use authentication gateways or Cloudflare WAF rules that block unrecognised user agents — verify AI crawler user agents can reach the public frontend. For `FAQPage` JSON-LD: the `faq_items` Blocks field in article content types provides the data structure for FAQPage JSON-LD — verify the frontend server component maps these blocks to FAQPage JSON-LD in the initial HTML response, not client-side. For question-heading ratio: Contentstack\'s Rich Text Editor (RTE) allows editors to add heading elements — verify the frontend renders RTE headings as semantic `<h2>` and `<h3>` elements (not `<div>` with styling), and that editors are using question-format headings in long-form content. For content chunkability: Contentstack\'s Modular Blocks field type (where content is structured as named blocks with specific field types per block) produces naturally chunked content — each block is a self-contained content unit. The audit verifies average section length in the rendered HTML.
HOW IT WORKS
Audit your Contentstack site in 60 seconds
- Enter your frontend URL. Use the public URL of your Contentstack-powered frontend — not the Contentstack management interface at app.contentstack.com. No Contentstack API key, Stack ID, or management credentials needed. Works with any frontend: Next.js, Nuxt, SvelteKit, Gatsby, Astro, or custom Node.js/React applications consuming the Contentstack Delivery API.
- We crawl and analyse. The engine validates all meta tags generated from Contentstack entry fields; checks every JSON-LD block (Article, FAQPage, Product) against Google's Rich Results specs with property-level errors including Reference field resolution gaps; verifies the Delivery API sitemap covers all published entries with correct pagination; measures CrUX Core Web Vitals from real Chrome field data; checks for enterprise security configurations blocking AI crawlers; and evaluates all five AI visibility signals in the server-rendered HTML.
- You get a prioritised report. Contentstack-specific issues first — missing SEO Group fields in content types, null JSON-LD author from unresolved Reference fields, OG images using management API URLs instead of CDN delivery URLs, entries published only to staging appearing at public URLs, Delivery API pagination gaps leaving content out of the sitemap, Cloudflare WAF rules blocking AI crawlers — then general SEO, each with the Contentstack content type field path or frontend SDK integration location for the fix.
FAQ
Questions about the Contentstack SEO audit
Does Contentstack have built-in SEO features?
Contentstack (contentstack.com) is an enterprise headless CMS that provides SEO capabilities through its content modelling and Delivery API rather than built-in page-level SEO settings. Key SEO-relevant Contentstack features: (1) **SEO field group in content types** — Contentstack allows adding a Group field called "SEO" to any content type (Page, Article, Product). The group can contain: Title (Short text field for meta title), Description (Multi-line text for meta description), OG Image (File field for Open Graph image), Canonical URL (Short text for canonical override), No Index (Boolean field), and Schema Type (Select field). These fields are populated by editors in the Contentstack management interface and retrieved via the Delivery API in the frontend application. (2) **URL Pattern / Slug field** — each content type entry typically has a URL field or slug field that maps to the frontend URL. Contentstack doesn\'t manage routing — the slug is used by the frontend framework to construct the page URL. (3) **Delivery API for sitemap generation** — Contentstack\'s Delivery API supports filtering by content type, environment (published), and locale, allowing the frontend to query all published entries to generate a sitemap programmatically. (4) **Localization** — Contentstack has built-in localization support; each content type can have locale variants, and the Delivery API supports locale-specific queries for hreflang implementation. (5) **Environments** — Contentstack uses environments (development, staging, production) with separate API keys per environment, preventing staging content from being exposed to Googlebot when the correct environment API key is used in production.
How do I implement generateMetadata() with Contentstack in Next.js?
In a Next.js App Router application using Contentstack as the headless CMS, `generateMetadata()` fetches content type entries via the Contentstack JavaScript Delivery SDK (`contentstack` npm package) or via direct REST API calls. Pattern: use the Contentstack SDK to query an entry by URL slug: `Stack.ContentType("page").Entry().Query().where("url", slug).toJSON().find()`, then map the returned entry fields to Next.js metadata. The mapping reads from the SEO group fields added to the content type: `entry.seo.title` → `metadata.title`; `entry.seo.description` → `metadata.description`; `entry.seo.canonical_url ?? \`/${slug}\`` → `metadata.alternates.canonical`; `entry.seo.og_image.url` → `metadata.openGraph.images`; `entry.seo.no_index` → `metadata.robots`. Contentstack file field values include a `.url` property pointing to Contentstack\'s built-in CDN (images.contentstack.io) — use this absolute URL for the OG image. For `generateStaticParams()`: query all published entries of the content type via `Stack.ContentType("page").Query().toJSON().find()`, extract the `url` field from each entry, and return them as params. Contentstack\'s environment and API key configuration: use `process.env.CONTENTSTACK_API_KEY`, `process.env.CONTENTSTACK_DELIVERY_TOKEN`, and `process.env.CONTENTSTACK_ENVIRONMENT` to configure the SDK — ensure these point to the Production environment in the production build, not staging or development.
How do I add structured data to a Contentstack-powered Next.js site?
JSON-LD structured data in a Contentstack-powered site is implemented in the Next.js frontend, reading from Contentstack entry fields. For `Article` JSON-LD: map Contentstack entry fields to JSON-LD properties. `headline`: from `entry.title` or `entry.seo.title` (must be under 110 characters — add a validation rule in Contentstack\'s content type field settings to enforce max length); `datePublished`: from `entry.publish_details.time` (the Contentstack publish timestamp in ISO 8601 format — Contentstack includes this in every delivered entry); `dateModified`: from `entry.updated_at` (the last modification timestamp from the entry metadata); `author`: from `entry.author` (a Reference field pointing to an Author content type — the author entry is fetched inline using the Contentstack SDK\'s `includeReference()` method; use the referenced author\'s `name` field for the `Person.name` property); `image`: from `entry.featured_image.url` (the Contentstack CDN URL for the featured image — must be an absolute URL). For `FAQPage` JSON-LD: add a Blocks field (or Group array field) named `faq_items` to the Article content type, with each block containing `question` (Short text) and `answer` (Multi-line text) fields. In the frontend server component, map `entry.faq_items` to the FAQPage JSON-LD `mainEntity` array. Output the JSON-LD via `script type="application/ld+json" dangerouslySetInnerHTML={{ __html: JSON.stringify(schema) }} /` in a React Server Component. Contentstack\'s Delivery API returns all field values in the server-side fetch — the JSON-LD is always server-rendered in the initial HTML response, visible to Googlebot in first-wave crawling.
Is the Contentstack SEO audit free?
Yes. The complete audit is free with no signup and no email gate. Enter the URL of the frontend application consuming your Contentstack Delivery API — the audit crawls the rendered HTML as Googlebot would. No Contentstack API key, Stack API key, or admin credentials needed. Works with any frontend framework consuming Contentstack: Next.js, Nuxt, SvelteKit, Gatsby, Astro, or custom framework integrations. Paid DeepSEOAnalysis plans add saved report history, scheduled monitoring, larger crawls (up to 1,000 pages), and white-label agency reporting.