OSS Contentful Alternatives 2026

Contentful Costs More Than You Think

Contentful's free tier gives you 5 users, 1 million API calls per month, and 25,000 content records. That sounds workable for a side project. Then you outgrow it.

Here's what Contentful pricing looks like in 2026:

Plan	Monthly Price	Content Records	API Calls/Month	Users
Free	$0	25,000	1M	5
Basic	$300	50,000	2M	20
Premium	Custom ($2,000+)	Custom	Custom	Unlimited

A mid-size team on the Basic plan pays $3,600/year for a CMS. Premium contracts start well above $24,000/year. Content record limits apply even on paid plans. API rate limits throttle traffic spikes. And all your content lives on Contentful's infrastructure with no self-hosting option.

Five open source headless CMS projects offer real alternatives. Each one is free to self-host, gives you full control over your data, and eliminates per-seat and per-API-call pricing.

TL;DR

Strapi is the most popular open source headless CMS with 65K+ GitHub stars, a visual content type builder, and REST + GraphQL APIs out of the box. It's the closest drop-in replacement for Contentful. Payload CMS is the strongest choice for TypeScript developers who want code-first schema definitions and native Next.js integration. Directus is the best option when you have an existing SQL database and need a CMS layer without migrating data. Wagtail is the top pick for Python/Django teams who need a publishing-focused CMS with structured content modeling. KeystoneJS fits teams who want a GraphQL-native CMS built on Prisma with a minimal, developer-controlled architecture.

Key Takeaways

Strapi (65K+ stars, MIT): Most popular open source headless CMS. Visual content type builder, REST + GraphQL APIs, plugin marketplace, role-based access control. TypeScript-first since v5. Best Contentful replacement for most teams.
Payload CMS (31K+ stars, MIT): Code-first TypeScript CMS that runs inside your Next.js app. Auto-generated REST, GraphQL, and Local APIs. Serverless-compatible. Best for developer teams who want full programmatic control.
Directus (28K+ stars, BSL 1.1): Wraps any existing SQL database and generates REST + GraphQL APIs automatically. No data migration required. Built-in Flows automation engine. Best for teams with existing databases.
Wagtail (18K+ stars, BSD): Django-based CMS with StreamField structured content modeling, tree-based page hierarchy, and an admin interface designed for editors. Best for Python teams and publishing-heavy projects.
KeystoneJS (9K+ stars, MIT): GraphQL-native CMS built on Prisma ORM. Schema-driven, minimal footprint, tight React admin UI. Best for teams who want a lightweight, GraphQL-first CMS.
All five tools are free to self-host. Your costs are server infrastructure ($5-50/month for a VPS) and maintenance time.

Feature Comparison

Feature	Strapi	Payload CMS	Directus	Wagtail	KeystoneJS
GitHub Stars	65K+	31K+	28K+	18K+	9K+
Language	TypeScript/Node.js	TypeScript	TypeScript/Node.js	Python/Django	TypeScript/Node.js
Schema Definition	Visual builder + code	Code-first (TS config)	Auto-introspects DB	Django models + StreamField	Prisma schema (TS)
REST API	Yes (auto-generated)	Yes (auto-generated)	Yes (auto-generated)	Limited (add-ons)	No (GraphQL only)
GraphQL API	Yes (plugin)	Yes (auto-generated)	Yes (auto-generated)	Via Wagtail-grapple	Yes (core)
Admin UI	Yes (React)	Yes (React/Next.js)	Yes (Vue.js)	Yes (Django/React)	Yes (React)
Media Library	Yes (built-in)	Yes (built-in)	Yes (built-in)	Yes (built-in)	Basic (custom fields)
Webhooks	Yes	Yes	Yes	Via signals/packages	Yes
i18n	Yes (built-in)	Yes (built-in)	Yes (built-in)	Yes (wagtail-localize)	Community packages
Auth/RBAC	Yes (built-in)	Yes (built-in)	Yes (granular)	Yes (Django auth)	Yes (built-in)
License	MIT	MIT	BSL 1.1	BSD-3	MIT

Contentful comparison: Contentful offers REST and GraphQL APIs, a web-based content modeling interface, built-in CDN, image transformations, localization in 50+ locales, granular roles and permissions, and webhooks. The content delivery API is globally distributed. SDKs exist for JavaScript, Python, Ruby, Java, .NET, PHP, and Swift. The main trade-offs are vendor lock-in, API call limits, content record caps, and pricing that scales with team size and usage.

Strapi -- Most Popular Contentful Replacement

Strapi (65K+ GitHub stars) is the most deployed open source headless CMS. It occupies the same market position as Contentful -- a headless CMS with a visual content modeling interface and auto-generated APIs -- but runs on your own infrastructure with no usage limits.

What Makes Strapi a Strong Contentful Alternative

The content type builder is where Strapi matches Contentful most directly. You define content types visually in the admin panel -- add fields, set validations, configure relations between types -- and Strapi generates the database tables and API endpoints automatically. No code required for standard content modeling.

Strapi v5 brought a full TypeScript-first rewrite with the Document Service API replacing the older Entity Service. Performance improved across the board. The REST API supports deep filtering, sorting, pagination, field selection, and relation population out of the box. GraphQL is available via the official plugin.

The plugin marketplace covers common integrations: email providers (SendGrid, Mailgun), cloud storage (AWS S3, Cloudinary), search (Meilisearch, Algolia), and SEO. Custom plugins use a well-documented SDK. Role-based access control handles granular permissions for content types, fields, and API endpoints.

Internationalization is built into the core. Define locales, translate content per entry, and the API returns localized responses. This matches Contentful's localization workflow closely.

For a detailed walkthrough of running Strapi on your own server, see our guide to self-hosting Strapi in 2026.

Self-Hosting Requirements

Node.js 18+ (LTS recommended)
PostgreSQL 14+ (recommended) or MySQL 8+ or SQLite
2 GB RAM minimum, 4 GB recommended
Docker or direct Node.js deployment

A $10-20/month VPS handles most Strapi deployments. Docker Compose is the standard approach. Co-locate with your frontend framework on the same server to eliminate API latency.

Limitations

Strapi creates its own database schema -- you cannot point it at an existing database and have it auto-discover your tables (that's Directus). The admin UI is React-based and not as easily customizable as Payload's approach. The free Community Edition covers most needs, but some enterprise features (SSO, audit logs, review workflows) require Strapi Cloud or an Enterprise license. Build times for large content models with many relations can be slow.

Best for: Teams migrating from Contentful who want a visual content type builder, auto-generated APIs, and the largest open source CMS community. Works with any frontend framework.

Payload CMS -- Best for TypeScript Developers

Payload CMS (31K+ stars) takes a fundamentally different approach from Contentful and Strapi. Instead of a visual builder, you define your entire content schema in TypeScript configuration files. Payload then generates the admin UI, REST API, GraphQL API, and Local API from that config.

What Makes Payload a Strong Contentful Alternative

The code-first approach means your content model lives in your repository alongside your application code. Version it with Git. Review changes in pull requests. Deploy schema changes through your CI/CD pipeline. No clicking through admin panels to add a field -- write TypeScript, push, deploy.

Payload runs inside your Next.js application. Not alongside it. Not as a separate service. Inside it. Your CMS admin panel is a Next.js route. Your API endpoints are Next.js API routes. Your frontend pages and your CMS share the same Node.js process, which means the Local API can fetch content with zero network overhead -- a performance characteristic no SaaS CMS can match.

The auto-generated admin UI is built with React and is fully customizable. Swap out components, add custom views, inject your own React components into any part of the admin panel. Access control uses function-based policies written in TypeScript -- not a checkbox matrix.

Payload supports serverless deployment (Vercel, Netlify, AWS Lambda) without modification. This is unusual for a self-hosted CMS and makes it viable for teams who don't want to manage servers.

For a deeper comparison of Payload against other CMS options, see our Ghost vs WordPress vs Payload CMS breakdown.

Self-Hosting Requirements

Node.js 18+ (runs inside Next.js)
MongoDB or PostgreSQL
Deploys anywhere Next.js runs: Vercel, Docker, VPS, serverless

Because Payload embeds in Next.js, deployment is identical to deploying a Next.js app. If you already deploy Next.js to Vercel, adding Payload requires no infrastructure changes. For Docker or VPS setups, a single container runs both your frontend and CMS.

Limitations

The code-first approach is a hard requirement. Non-technical content editors cannot create new content types or modify schemas -- a developer must change the TypeScript config and redeploy. This is a feature for developer teams but a dealbreaker for teams where editors need to define content structures independently.

The learning curve is steeper than Strapi's visual builder. Documentation is thorough but assumes TypeScript fluency. The ecosystem of pre-built plugins and integrations is smaller than Strapi's marketplace, though it's growing quickly. If your stack isn't JavaScript/TypeScript, Payload won't fit.

Best for: TypeScript/Next.js teams who want their CMS embedded in their application, full programmatic control over schema and access, and serverless deployment compatibility.

Directus -- Best for Existing Databases

Directus (28K+ stars) is a "data engine" rather than a traditional CMS. It wraps any SQL database -- PostgreSQL, MySQL, MariaDB, SQLite, MSSQL, even Oracle and CockroachDB -- and automatically generates REST and GraphQL APIs plus a visual admin interface around your existing tables.

What Makes Directus a Strong Contentful Alternative

The zero-migration approach is what sets Directus apart from every other tool on this list. Point Directus at a PostgreSQL database that already has tables and data. Directus introspects the schema, discovers relationships, and generates a full API and admin panel in minutes. No data migration, no schema recreation, no import/export cycle.

This makes Directus uniquely useful in two scenarios: teams with existing databases who need a CMS layer on top, and teams who want their CMS data stored in standard SQL tables that any other application can query directly.

The built-in Flows automation engine replaces the need for external tools like Zapier or n8n for many CMS automation tasks. Triggers fire on CRUD events, schedules, or webhooks. Actions include sending emails, calling external APIs, transforming data, and conditional branching. This is a feature Contentful charges extra for via its Compose + Launch add-ons.

The admin interface is Vue.js-based, clean, and handles complex relational data well. Role-based access control is granular down to individual fields. The dashboard system lets you build custom analytics views within the admin.

For a complete deployment walkthrough, see our guide to self-hosting Directus in 2026.

Self-Hosting Requirements

Node.js 18+ or Docker
Any supported SQL database (PostgreSQL recommended)
2 GB RAM minimum
Redis or Memcached (optional, for caching)

Docker deployment is straightforward -- a single container connects to your database. For production, add Redis for caching and a reverse proxy. Directus Cloud exists as a managed option if you want the software without server management.

Limitations

The BSL 1.1 license is not technically open source by the OSI definition. You can self-host and use Directus freely for your own projects, but offering Directus as a managed service to third parties requires a commercial license. For most teams replacing Contentful, this is not an issue -- you're running it for your own project.

Because Directus wraps an existing schema rather than defining its own, the content modeling workflow is different from Contentful's. You work with database tables and columns rather than "content types" and "fields." This is powerful for developers but can feel less intuitive for editors who think in terms of content, not data.

GraphQL support is solid but the REST API is more mature. Some advanced query patterns are easier in REST. The extension system exists but requires more effort than Strapi's plugin marketplace.

Best for: Teams with existing SQL databases who need a headless CMS layer without migrating data. Also strong for teams who want their content stored in standard database tables with direct SQL access.

Wagtail -- Best for Python/Django Teams

Wagtail (18K+ stars) is the leading CMS for the Python ecosystem. Built on Django, it provides a structured content modeling system with StreamField -- a block-based content editor that lets editors compose rich pages from predefined component types.

What Makes Wagtail a Strong Contentful Alternative

StreamField is Wagtail's defining feature and its closest equivalent to Contentful's content modeling. You define blocks in Python -- text, images, embeds, custom components -- and editors assemble pages by stacking and nesting these blocks. The result is structured content that's both flexible for editors and predictable for developers.

The page tree model gives Wagtail a built-in site structure that Contentful lacks. Pages are organized hierarchically with parent-child relationships, URL routing, and navigation generated from the tree. For teams building websites (not just APIs), this eliminates the need to manage routing and navigation separately.

The admin interface is purpose-built for editors. Image focal point cropping, built-in search indexing (Elasticsearch/OpenSearch integration), workflow and moderation systems, scheduled publishing, and draft/live content separation are all core features. The editorial experience is more polished than most headless CMS admin panels.

Wagtail's API mode serves content as JSON via REST endpoints, making it viable as a headless CMS for decoupled frontends. The wagtail-grapple package adds GraphQL support. For teams already running Django, adding Wagtail to an existing project is a pip install and a few configuration lines.

Self-Hosting Requirements

Python 3.8+
Django 4.2+
PostgreSQL (recommended) or any Django-supported database
2 GB RAM minimum
Elasticsearch/OpenSearch (optional, for search)

Wagtail deploys wherever Django deploys: Docker, PaaS platforms (Heroku, Railway, Render), VPS, or bare metal. Django's deployment ecosystem is mature with extensive documentation. A basic Wagtail site runs comfortably on a $10/month VPS.

Limitations

Wagtail is Python/Django-only. If your frontend team works in JavaScript/TypeScript and your backend is Node.js, Wagtail introduces a language boundary. The headless API mode works but is an add-on rather than Wagtail's primary architecture -- the admin UI assumes you're building a Django-rendered site by default.

The REST API is less feature-rich than Strapi's or Directus's auto-generated APIs. You may need to write custom API serializers for complex content structures. The JavaScript/TypeScript ecosystem of CMS tools is larger and moves faster than the Python CMS ecosystem.

StreamField is powerful but has a learning curve. Defining blocks, understanding the block structure in templates, and handling StreamField data in API responses requires Django knowledge that Contentful's visual modeler doesn't demand.

Best for: Python/Django teams who want a CMS with structured content modeling, a polished editorial experience, and page hierarchy. Strong choice for publishing and editorial-heavy projects.

KeystoneJS -- Best for GraphQL-First Teams

KeystoneJS (9K+ stars) is a GraphQL-native CMS and application framework built on Prisma ORM. It takes a minimal, schema-driven approach -- you define your data models in TypeScript, and Keystone generates a GraphQL API, a React admin UI, and database migrations from that schema.

What Makes KeystoneJS a Strong Contentful Alternative

KeystoneJS puts GraphQL at the center. Not as an add-on or plugin -- as the primary API. If your frontend fetches content via GraphQL queries (common with React, Next.js, Gatsby, and mobile apps), Keystone delivers exactly what you need without REST overhead or GraphQL-to-REST translation layers.

The schema definition uses a clean TypeScript DSL:

import { list } from '@keystone-6/core';
import { text, relationship, timestamp, select } from '@keystone-6/core/fields';
import { document } from '@keystone-6/fields-document';

export const lists = {
  Post: list({
    fields: {
      title: text({ validation: { isRequired: true } }),
      status: select({
        options: [
          { label: 'Draft', value: 'draft' },
          { label: 'Published', value: 'published' },
        ],
        defaultValue: 'draft',
      }),
      content: document({
        formatting: true,
        links: true,
        dividers: true,
        layouts: [
          [1, 1],
          [1, 1, 1],
        ],
      }),
      publishDate: timestamp(),
      author: relationship({ ref: 'Author.posts', many: false }),
    },
  }),
};

From this config, Keystone generates the database tables (via Prisma migrations), a full GraphQL schema with queries, mutations, and filters, and an admin UI with forms for each list. The Document field type provides a structured rich text editor similar to Contentful's rich text field.

Prisma ORM underneath means you get type-safe database access, automatic migrations, and support for PostgreSQL, MySQL, and SQLite. The admin UI is lightweight, React-based, and customizable through custom views and field types.

Access control uses function-based policies similar to Payload's approach:

access: {
  operation: {
    query: ({ session }) => !!session,
    create: ({ session }) => session?.data.role === 'admin',
    update: ({ session }) => session?.data.role === 'admin',
    delete: ({ session }) => session?.data.role === 'admin',
  },
},

Self-Hosting Requirements

Node.js 18+
PostgreSQL, MySQL, or SQLite (via Prisma)
2 GB RAM minimum
Docker or direct Node.js deployment

Keystone runs as a standard Node.js application. Deploy to any hosting that supports Node.js -- Docker, VPS, PaaS, or serverless with some configuration. The footprint is small compared to Strapi or Directus.

Limitations

GraphQL-only means no REST API out of the box. If your consumers need REST, you'll need to add an Express layer or use a GraphQL-to-REST gateway. The community is smaller than Strapi's, which means fewer plugins, integrations, and Stack Overflow answers.

The admin UI is functional but less polished than Strapi's or Directus's. Media management is basic -- you'll likely need to integrate an external service (Cloudinary, S3) for serious image handling. Keystone's development pace has slowed compared to Strapi and Payload, which is worth monitoring.

Documentation is adequate but not as comprehensive as Strapi's. Complex use cases sometimes require reading the source code. The project had a significant rewrite from v5 to v6, and some community resources reference the older architecture.

Best for: Teams building GraphQL-first applications who want a minimal, schema-driven CMS with Prisma underneath. Good fit for developers who prefer less framework overhead.

Pricing Comparison: Self-Hosted vs Cloud

The biggest cost advantage of open source is eliminating per-seat and per-API-call pricing. Here's what the numbers look like for a 10-person team managing 50,000 content records.

Contentful (SaaS)

Cost Item	Monthly	Annual
Basic plan (20 users)	$300	$3,600
Overage: API calls beyond 2M	Variable	Variable
Compose + Launch add-ons	$300+	$3,600+
Estimated total	$300-600+	$3,600-7,200+

Self-Hosted Open Source

Cost Item	Monthly	Annual
VPS (4 GB RAM, 2 vCPU)	$20-40	$240-480
Managed database (optional)	$15-30	$180-360
Object storage (media)	$5-10	$60-120
CDN (Cloudflare free tier)	$0	$0
Estimated total	$40-80	$480-960

Managed Open Source (Cloud Editions)

Several projects offer managed hosting for teams who want open source software without server management:

Service	Starting Price	What You Get
Strapi Cloud	$99/month	Managed Strapi, 100K API calls/month, 1M assets
Directus Cloud	$99/month	Managed Directus, automatic updates, backups
Payload Cloud	$50/month	Managed Payload, serverless, integrated with Vercel
Wagtail (various PaaS)	$10-25/month	Deploy on Railway, Render, Fly.io
KeystoneJS (any Node.js host)	$5-20/month	Deploy on any Node.js-compatible platform

The pattern: self-hosting costs 80-90% less than Contentful. Managed open source editions cost 50-70% less than Contentful while removing server management burden.

When to Choose Each

Choose Strapi When

You want the closest feature-for-feature replacement for Contentful
Your team includes non-technical editors who need a visual content type builder
You need the largest community and plugin ecosystem
You're building content APIs for multiple frontends (web, mobile, IoT)
You want both REST and GraphQL API options

Choose Payload CMS When

Your stack is TypeScript and Next.js
You want your CMS embedded in your application, not running as a separate service
Developers define and control the content model via code
You need serverless deployment (Vercel, Netlify)
You want the Local API for zero-latency content fetching

Choose Directus When

You have an existing SQL database and need a CMS layer without data migration
Your team needs both a CMS for content and an admin panel for operational data
You want built-in workflow automation (Flows) without external tools
You need to query your content directly via SQL alongside the API
Data sovereignty and standard SQL storage are priorities

Choose Wagtail When

Your backend is Python/Django
You're building a content-heavy publishing site with hierarchical page structure
Editorial experience (workflow, moderation, scheduled publishing) is a priority
You need StreamField for flexible, structured content composition
Your project is a website first, API second

Choose KeystoneJS When

GraphQL is your primary API layer
You want a minimal CMS with low framework overhead
Prisma is already in your stack or you want type-safe database access
You prefer a lightweight, developer-controlled architecture
Your content modeling needs are moderate (not highly complex nested structures)

Migration Path from Contentful

Moving from Contentful to any of these alternatives follows a common pattern:

Export content using the Contentful CLI (contentful space export) or the Content Management API. This produces JSON files with all content types, entries, and assets.
Map content types to your target CMS. Contentful content types map most directly to Strapi content types, Payload collections, Directus collections, Wagtail page models, or Keystone lists.
Write migration scripts to transform Contentful's JSON structure into your target CMS's import format. Rich text fields require the most attention -- Contentful's rich text JSON structure differs from each CMS's rich text format.
Migrate assets (images, files, documents) to your self-hosted storage (S3-compatible, local filesystem) or keep them on a CDN.
Update frontend code to use the new CMS's API endpoints. If you used Contentful's JavaScript SDK, you'll replace it with Strapi SDK, Payload Local API, Directus SDK, Wagtail API client, or Keystone GraphQL queries.

Strapi and Directus have the smoothest migration paths from Contentful because their content modeling paradigms are closest. Payload and KeystoneJS require translating visual content models into code-first schemas. Wagtail requires rethinking content as Django models with StreamField blocks.

Methodology

This comparison is based on the following sources, all verified as of March 2026:

GitHub repositories: Star counts, commit activity, release frequency, and issue response times checked directly on GitHub for all five projects
Official documentation: Strapi v5 docs (docs.strapi.io), Payload CMS docs (payloadcms.com/docs), Directus docs (docs.directus.io), Wagtail docs (docs.wagtail.org), KeystoneJS docs (keystonejs.com/docs)
Contentful pricing page: contentful.com/pricing, verified March 2026
Self-hosting costs: Based on current pricing from Hetzner, DigitalOcean, and Vultr for VPS instances; Neon and Supabase for managed PostgreSQL; Cloudflare R2 and Backblaze B2 for object storage
Managed cloud pricing: Strapi Cloud (strapi.io/pricing), Directus Cloud (directus.io/pricing), Payload Cloud (payloadcms.com/pricing)
Community data: npm weekly downloads, Docker Hub pull counts, GitHub Discussions activity, and Discord/forum member counts as of March 2026
License texts: Verified from each project's LICENSE file in their GitHub repositories

Star counts and pricing are snapshots and change over time. We re-verify these figures monthly. If you spot an outdated number, let us know.

The SaaS-to-Self-Hosted Migration Guide (Free PDF)