Contentful CMS Guide: Features, Pricing, GraphQL API & Code Examples [2026]

Contentful CMS Guide: Features, Pricing, GraphQL API & Code Examples [2026]

Contentful is an API-first headless CMS that stores your content in a central hub and delivers it via REST and GraphQL APIs to any frontend, web, mobile, IoT, digital signage, whatever you're building. This guide covers everything competitors skip: actual code examples, real pricing numbers, and honest limitations.

We use Sanity (a direct Contentful competitor) in production across four websites and ten languages, so we come at this from a practitioner's perspective, not a vendor pitch.

Quick Summary

What Is Contentful?

Contentful is a cloud-native, API-first headless CMS, or as the company now calls it, a "composable content platform." Unlike traditional systems like WordPress that bundle content management with a frontend, Contentful stores structured content centrally and delivers it through APIs to any channel you need.

The key concept is decoupled architecture. Your content lives in Contentful's cloud. Your frontend, whether that's a Next.js site, a React Native app, or a smart display, fetches content through Contentful's APIs at build time or runtime. The content doesn't know or care where it ends up.

Founded in Berlin in 2013, Contentful has grown into one of the largest headless CMS vendors. Brands like Spotify, Vodafone, Chanel, and Atlassian run their content operations on it. It's not open source, and there's no self-hosted option, it's SaaS only, which matters if you have compliance constraints around data residency.

According to Contentful's official documentation, the platform positions itself as infrastructure for content, a content hub that sits between your editorial team and your digital experiences.

How Does Contentful Work?

Contentful follows a three-layer architecture: you define your Content Model (the schema), create Content (the entries), and deliver it through APIs. Content is channel-agnostic, the same blog post can power your website, your mobile app, and your email newsletter without any duplication.

Everything flows through APIs. There's no server-side rendering built in, no templates, no theme layer. You build the frontend however you want, and Contentful handles the content storage and delivery.

The Three APIs

Contentful gives you three distinct APIs, each with its own purpose and authentication:

• Content Delivery API (CDA): Read-only access to published content. Backed by Fastly's CDN, so cached requests are fast and unlimited. Uncached requests are rate-limited to 55 per second.
• Content Management API (CMA): Read-write access for creating and updating content programmatically. Rate-limited to 10 requests per second. This is what you'd use for migrations, bulk imports, or CI/CD pipelines.
• Content Preview API (CPA): Same as CDA but serves draft content. Perfect for building preview modes in your frontend, editors can see unpublished changes before hitting publish.

All three support both REST and GraphQL. Authentication is via Bearer tokens, with separate tokens for delivery and management.

Environments and Spaces

Think of Spaces as projects and Environments as git branches for your content. You might have a master environment for production and a staging environment where editors can work without affecting live content.

Environments support aliasing, you can point the master alias to a new environment for zero-downtime content promotions. If you're choosing a frontend framework to pair with Contentful, this environment model works well with preview deployments on platforms like Vercel or Netlify.

Webhooks let you trigger builds, sync with external systems, or kick off workflows whenever content changes. Most teams hook these into their CI/CD pipeline to rebuild their static site on each publish event.

Content Modeling in Contentful

Content modeling is where you define the structure of your content, the "schema" that determines what fields exist, what types of data they hold, and how content types relate to each other. In our experience, this is where Contentful genuinely shines compared to simpler CMS options.

You're essentially designing a content schema, similar to database tables but more flexible. A "Blog Post" content type might have a title (short text), a body (rich text), an author (reference to an Author content type), and tags (array of strings). Every entry you create follows this structure.

Field Types and Validations

Contentful offers a solid range of field types:

• Short text (Symbol): Titles, slugs, labels, up to 256 characters
• Long text (Text): Markdown or plain text, no character limit
• Rich text: JSON-based (not HTML), gives you full rendering control
• Number: Integer or decimal
• Date/Time: ISO 8601 format
• Boolean: True/false toggles
• Media (Asset): Images, videos, documents, stored in Contentful's asset pipeline
• Reference (Link): Connect entries to other entries or assets
• JSON Object: Free-form structured data
• Location: Latitude/longitude pairs

Each field supports validations: required, unique, regex patterns, size limits, and custom validation messages. You can also set appearance options that control how the field renders in the editor UI.

References and Linked Entries

References are how you connect content types. An "Author" reference on a Blog Post links to an Author entry. A "Related Posts" field can reference multiple Blog Post entries. This creates a content graph, entries linked to entries, queryable in a single API call.

Here's what a Blog Post content type definition actually looks like when you create it via the Content Management API:

{
  "name": "Blog Post",
  "fields": [
    { "id": "title", "type": "Symbol", "required": true },
    { "id": "slug", "type": "Symbol", "validations": [{ "unique": true }] },
    { "id": "body", "type": "RichText" },
    { "id": "author", "type": "Link", "linkType": "Entry" },
    { "id": "publishDate", "type": "Date" },
    { "id": "tags", "type": "Array", "items": { "type": "Symbol" } }
  ]
}

This is the kind of thing you'd store in version control and apply through migration scripts. Zero competitors show this in their Contentful guides, they talk about content modeling in the abstract without showing what it actually looks like in code.

Querying Content: REST and GraphQL APIs

Contentful provides both REST and GraphQL APIs for fetching content. REST is straightforward for simple queries. GraphQL is better when you need nested data, multiple content types in one request, or want to avoid over-fetching. Both use the same authentication tokens.

The GraphQL endpoint is auto-generated from your content model. Every content type you create becomes a queryable type in the schema, with filtering, sorting, and pagination built in. The endpoint lives at:

https://graphql.contentful.com/content/v1/spaces/{SPACE_ID}

According to Contentful's GraphQL documentation, the schema updates automatically whenever you modify your content types, no manual schema management needed.

GraphQL Query Examples

Here's a basic query to fetch your ten most recent blog posts with their authors:

query {
  blogPostCollection(limit: 10, order: publishDate_DESC) {
    items {
      title
      slug
      publishDate
      author {
        name
      }
    }
  }
}

Need to filter by tag and pull content in German? Add a where clause and a locale parameter:

query {
  blogPostCollection(
    where: { tags_contains_some: ["javascript"] }
    locale: "de"
  ) {
    items {
      title
      body {
        json
      }
    }
  }
}

One thing to watch: GraphQL queries have complexity limits. Deeply nested queries with multiple linked references can hit the ceiling. Contentful calculates complexity based on the number of nodes and depth of your query. If you're pulling blog posts with authors, categories, related posts, and each related post's author, that adds up fast.

REST API Basics

The REST API is simpler but requires more requests for nested data. A basic fetch for blog posts hits https://cdn.contentful.com/spaces/{SPACE_ID}/entries?content_type=blogPost. You get JSON with a flat items array and a separate includes object for linked entries that you'll need to resolve client-side.

If you're working with TypeScript, Contentful's contentful.js SDK handles link resolution and type generation automatically. For raw fetch calls, here's the minimal JavaScript to query the GraphQL API:

const response = await fetch(
  `https://graphql.contentful.com/content/v1/spaces/${SPACE_ID}`,
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${CDA_TOKEN}`,
    },
    body: JSON.stringify({ query }),
  }
);
const { data } = await response.json();

That's it. No SDK required, no build step, no dependencies. This works in Node.js, Deno, Cloudflare Workers, the browser, anywhere you can make HTTP requests.

Key Features Worth Knowing

Contentful ships with a broad feature set, but not every feature matters equally. Here are the ones that actually affect your day-to-day experience and architecture decisions.

Localization (Strengths and Gaps)

Contentful's localization model is solid at the infrastructure level. You define locales for your space (up to 100+ on Enterprise plans), and every field can store per-locale values. Field-level locale overrides mean your German title can differ from your English one while sharing the same hero image.

The gap is translation management. Contentful gives you the fields to store translations, but no workflow to produce them. There's no translation memory, no glossary, no assignment system, no progress tracking. You need a third-party integration, Phrase, Smartcat, or Lokalise, to handle the actual translation process. For teams managing 10+ languages (we manage 10 across our sites), this gap becomes expensive fast.

Environments and Branching

Environments work like git branches for your content model and entries. Create a staging environment, make schema changes, test with content, then promote to master when you're ready. Aliases let you swap which environment master points to without changing API URLs.

This is genuinely useful for schema migrations. You can test a new content type in an isolated environment, verify the frontend handles it correctly, then promote, all without touching production content. Most teams we've seen use two to three environments: production, staging, and occasionally a feature branch for large migrations.

Other features worth mentioning:

• Roles and permissions: Granular access control, restrict editors to specific content types, block publish access for junior roles, custom roles on Enterprise plans, SSO
• Webhooks: Trigger builds, Slack notifications, or external workflows on any content event
• Rich Text: JSON-based, giving full rendering control but requiring custom renderers for every frontend framework
• App Framework: Marketplace with extensions for custom field editors, sidebar widgets, and integrations
• Image API: On-the-fly resizing, cropping, format conversion (WebP, AVIF), and focal point cropping, no separate image CDN needed

What's New in Contentful for 2026

Contentful has shipped significant updates through 2025 and into 2026, and zero competitor guides cover any of them. If you're evaluating Contentful based on 2023 or 2024 information, you're working with an incomplete picture.

AI Actions and Content Automation

Contentful launched AI Actions, automated content workflows powered by large language models directly inside the editor. These handle translation drafts, SEO metadata generation, alt-text writing, tone adjustments, and content summarization. You access them from the editor sidebar, and they operate on the entry you're currently editing.

According to Diginomica's coverage, AI Actions are part of Contentful's broader push toward positioning as a full digital experience platform (DXP), not just a headless CMS. The feature is genuinely useful for automating repetitive editorial tasks, though the translation output still needs human review, it's a first draft, not a finished product.

Contentful Studio (Visual Builder)

Contentful Studio went GA in spring 2024 and has matured significantly through 2025. It's a visual page builder that lets non-developers compose pages with drag-and-drop components and live preview. If you've heard the criticism that "Contentful has no visual editing", Studio is the answer, though with caveats.

Studio requires frontend integration (your components need to be registered with Studio's SDK), and it's a paid add-on, not included in base plans. For teams who've been asking for WordPress-like page building on top of Contentful's structured content model, it's a real option now. Storyblok still has the edge for visual-first workflows, but the gap is closing.

Personalization with Ninetailed

Contentful acquired Ninetailed in 2024 and rebranded it as Contentful Personalization. As CMS Critic reported, this gives you native A/B testing, audience segmentation, and AI-driven variant suggestions, all accessible from an Optimization tab in the editor.

This is notable because personalization historically required a separate vendor (Optimizely, Dynamic Yield, etc.). Having it built into the CMS reduces integration complexity. The catch: Ninetailed is a separate product with its own pricing. It's not "free with Contentful."

Contentful Pricing: What It Actually Costs

Contentful offers four tiers, but most competitor guides only name them without giving you actual numbers. Here's what you're looking at as of April 2026, based on Contentful's pricing page:

The free tier is generous for prototyping and learning. You get 10 users, 100K API calls, and enough bandwidth to build a real project. But costs escalate quickly once you outgrow it.

Hidden costs to budget for:

• API overage charges on Lite: Go over 1M calls/month and you'll see overage line items on your bill
• Locale costs: Each additional locale counts toward your space limits -- 50 locales at the field level adds up
• Contentful Studio: The visual builder is a paid add-on, not included in Lite or even some Premium plans
• Ninetailed personalization: Separate product, separate contract, separate pricing
• Professional services: Migration assistance, onboarding, and training are billed separately
• Rich Text renderers: Not a direct cost, but the development time to build custom renderers for your framework is real

Our honest take: Contentful's free tier is solid for evaluation and small projects. But if budget is a primary concern, open-source CMS alternatives like Strapi or Payload eliminate licensing costs entirely, you only pay for hosting.

Contentful vs Sanity vs Strapi: How They Compare

These are the three headless CMS options that come up in almost every evaluation. We've built production systems on Sanity, so we know its strengths and weaknesses firsthand. Here's an honest comparison:

Contentful wins for enterprise teams with large content operations and strict governance needs. The mature role system, SSO, audit logs, and 99.99% SLA on Enterprise plans are hard to match.

Sanity wins for developer experience and schema flexibility. If you prefer schema-as-code, want GROQ's query power, and value the real-time collaboration features, Sanity is the better fit. Read our full Sanity CMS guide for the deep dive.

Strapi wins on cost. It's free to self-host with no API call limits. If you have the DevOps capacity to manage your own infrastructure and don't need enterprise support, Strapi gives you the most CMS per dollar.

For a broader comparison including Storyblok, Payload, and Hygraph, see our full headless CMS comparison.

Limitations You Should Know Before Choosing Contentful

Every CMS has tradeoffs. Here are Contentful's, with specific numbers, not vague hand-waving. We hit several of these when evaluating Contentful for our own content pipeline.

Rate limits are real. The CDA allows 55 uncached requests per second. CDN-cached responses are unlimited, but if your app bypasses the cache (server-side rendering on every request, for example), you'll hit limits fast. The CMA is even tighter at 10 requests per second, relevant for migration scripts and bulk imports.

No built-in visual editing (without paying extra). Contentful Studio exists, but it's a paid add-on that requires frontend integration. If your team expects WordPress-style page building in the base product, prepare for that conversation. Storyblok includes visual editing at every tier.

No translation management. You get locale fields, that's it. No translation workflows, no assignment system, no translation memory, no progress tracking. For a platform that sells localization as a key feature, the actual translation experience relies entirely on third-party tools like Phrase, Smartcat, or Lokalise.

Developer dependency for everything frontend. Content editors can create and manage entries. They cannot change page layouts, add new sections, modify navigation, or update the frontend in any way without a developer. This is inherent to headless architecture, but it's amplified in Contentful because the base product doesn't include a page builder.

Pricing gets unpredictable at scale. API call overages, locale-based limits, add-on costs for Studio and Personalization, and professional services create a pricing model that's hard to forecast. Multiple teams we've spoken with were surprised by their first post-free-tier invoice.

Rich Text complexity. Contentful's Rich Text is JSON-based, not HTML. Every frontend framework needs a custom renderer, @contentful/rich-text-react-renderer for React, rich-text-html-renderer for vanilla JS, etc. It gives you full control over rendering, but it's significantly more development work than HTML-based competitors.

Vendor lock-in. Closed source, SaaS only, no self-hosting option. Your content is exportable via API, but your content model, workflows, and integrations are Contentful-specific. If pricing changes or features get deprecated, your options are limited.

Who Should (and Shouldn't) Use Contentful

Contentful is a strong platform, but it's not the right choice for every project. Here's a decision framework to help you self-select.

Use Contentful if:

• You're an enterprise team managing content across multiple channels (web, mobile, IoT, digital signage)
• You need native localization with 50+ locales and field-level overrides
• You want a mature, battle-tested platform with dedicated support and 99.99% SLA
• Your team includes developers comfortable with API-first architecture
• You need granular roles, permissions, audit logs, and SSO

Skip Contentful if:

• You're a solo developer or small team with budget constraints, look at Strapi or Payload
• You want a visual page builder included in the base product, look at Storyblok
• You prefer code-first schema definitions and maximum flexibility, look at Sanity
• You need a simple blog CMS, WordPress or Ghost is cheaper and faster to set up
• You want to self-host for compliance reasons, look at Strapi or Payload

For a deeper look at all these alternatives, check out our full headless CMS comparison.

Getting Started: Your First 15 Minutes with Contentful

Here's a practical walkthrough, not theory, but the exact steps to go from zero to querying content via GraphQL in about 15 minutes.

Step 1: Sign up. Go to contentful.com and create a free account. No credit card needed.

Step 2: Create a Space. A Space is your project container. The free tier gives you one Starter Space. Name it something descriptive.

Step 3: Define a Content Type. Go to Content Model, click "Add content type," and create an "Article" type. Add fields: Title (Short text, required), Slug (Short text, unique validation), Body (Rich text), Cover Image (Media), and Published Date (Date & time).

Step 4: Create an Entry. Navigate to Content, click "Add Article," and fill in the fields. Hit Publish.

Step 5: Grab your API keys. Go to Settings -> API Keys. Create a new API key. You'll get a Space ID, Content Delivery API token, and Content Preview API token. Save these.

Step 6: Query via GraphQL Playground. Open this URL in your browser (replace with your credentials):

https://graphql.contentful.com/content/v1/spaces/{SPACE_ID}/explore?access_token={CDA_TOKEN}

Step 7: Fetch from your app. Use the JavaScript fetch example from the APIs section above, swap in your Space ID and CDA token, and you're pulling live content.

Pro tip: The GraphQL Playground URL isn't obvious in the Contentful UI. You can find it under Settings -> API Keys -> GraphQL Playground URL, or construct it manually using the template above. Bookmark it, you'll use it constantly during development.

FAQ

What is Contentful CMS and how does it work?

Contentful is an API-first headless CMS that stores structured content in a cloud hub and delivers it via REST and GraphQL APIs. Unlike WordPress, it has no frontend, you build your own using any framework. Content editors manage entries through Contentful's web app, and developers fetch that content through APIs.

Is Contentful free to use?

Yes, Contentful offers a free Community tier that includes 10 users, 100K API calls per month, 50 GB CDN bandwidth, and one Starter Space. It's enough for prototyping and small projects. Paid plans start at $300/month for the Lite tier, with Premium and Enterprise tiers priced on custom quotes.

What is content modeling in Contentful?

Content modeling means defining structured content types with fields, validations, and references, like designing a database schema but for content. You create types like "Blog Post" or "Product" with specific fields (title, body, image, category), and every entry follows that structure. It's Contentful's foundation.

How does Contentful compare to WordPress?

Contentful is headless (API-only, no built-in frontend), while WordPress bundles content management with theme-based rendering. Contentful excels at multi-channel delivery, the same content can serve web, mobile, and IoT. WordPress excels at simplicity, you get a working site in minutes with no developer needed.

Is Contentful good for enterprise use?

Yes, Contentful is one of the most enterprise-adopted headless CMS platforms. Enterprise plans include SSO, granular role-based access, audit logs, dedicated support, a 99.99% SLA, and unlimited API calls. Companies like Spotify, Vodafone, Chanel, and Atlassian use it for large-scale content operations.

What are the disadvantages of Contentful?

Key limitations include: no built-in visual editing in the base product (Studio is a paid add-on), pricing unpredictability at scale from API overages and add-on costs, no translation management workflow, developer dependency for all frontend changes, Rich Text JSON requiring custom renderers, and vendor lock-in with no self-hosting option.

Does Contentful support GraphQL?

Yes, natively. Every Contentful space gets an auto-generated GraphQL schema based on your content types. You can query with filtering, pagination, sorting, and locale-specific requests. The endpoint is at graphql.contentful.com/content/v1/spaces/{SPACE_ID}, authenticated with your Content Delivery API token.

How much does Contentful cost per month?

Free tier costs $0. Lite is $300/month with 20 users and 1M API calls. Premium starts around $2,000+/month with custom pricing. Enterprise runs mid-five to six figures annually. Watch for hidden costs: API overage charges, Contentful Studio add-on fees, Ninetailed personalization pricing, and professional services.

Can Contentful handle multiple languages?

Yes, Contentful has native locale support with field-level overrides, each field can store different values per locale. However, there's no built-in translation workflow, memory, or glossary. You need third-party integrations like Phrase, Smartcat, or Lokalise to manage the actual translation process at scale.

What is Contentful Studio?

Contentful Studio is a visual page builder add-on that went GA in spring 2024. It lets non-developers compose pages using drag-and-drop components with live preview. It requires frontend integration (your components must be registered with Studio's SDK) and is a paid add-on, not included in base Contentful plans.