Drupal vs Contentful (2026): who owns the content model vs who rents it

Contentful and Drupal solve the same problem from opposite directions. Contentful gives you a metered SaaS content platform: API endpoints on day one, no servers, a bill that scales with usage. Drupal gives you an open-source content model you run — an entity system with two decades of edge cases already handled, but yours to operate, patch, and pay for hosting.

This is a decision about ownership, not features. If you want to be shipping API calls in an afternoon and you're comfortable renting your content layer indefinitely, Contentful is built for exactly that. If you want deep, revisioned content modeling and workflow that you control at the database level — and you're willing to either run it yourself or pay someone to run it for you — Drupal is built for that instead.

This article is for a mixed team: a developer who has to build against the API, and whoever signs the invoice. It's for people evaluating both, not people who have already decided. Contentful wins outright on two fronts below — API/CDN maturity and integration ecosystem — and we say so plainly.

The short answer

• Contentful gets you to a working API faster than Drupal ever will.
• Drupal's content modeling — references, Paragraphs, taxonomy, revisions on every entity — is deeper than Contentful's content types out of the box.
• Contentful's pricing punishes growth: API calls, records, and locales are metered, and the jump from Free to Lite is a cliff.
• Drupal's editorial workflow (moderation states, role-based transitions) ships in core; Contentful's equivalent workflow tooling sits behind Premium.
• Contentful's integration marketplace and onboarding are genuinely best-in-class — nobody should pretend otherwise.
• Self-hosted Drupal's real cost is operational time, not just a hosting bill, and that's a legitimate reason to choose Contentful for a small team with no ops capacity.

Side by side

Content modeling

Drupal's content model is an entity/field system: every piece of content — nodes, users, taxonomy terms, media — is an entity with fields attached to it, and every entity gets a full revision history for free. Paragraphs let editors compose a page from reusable component blocks instead of one long body field. Entity references connect content types to each other natively, and taxonomy vocabularies handle classification without bolting on a separate system. This is the product of 20+ years of real editorial requirements getting folded into core.

Contentful's model is cleaner and narrower: content types with typed fields, references between entries, and rich text that can embed other entries inline. Validations are configurable per field. It's easy to reason about and easy to onboard a new developer into. What it doesn't have natively is Drupal's revision-per-entity history or a Paragraphs-style component system — you build component patterns yourself with reference fields, which works but takes more up-front design discipline than Drupal's Paragraphs give you automatically.

Neither is objectively better here. Contentful's model is simpler to learn in a week. Drupal's model has more built-in machinery for complex, long-lived content operations — which is exactly why large publishers and universities gravitate to it.

Developer experience and APIs

This is where Contentful should win, and does. The Content Delivery API and GraphQL API are polished, well-documented, and backed by a global CDN with an excellent uptime record. There's also a separate Content Preview API and a Content Management API for write operations — a clean separation of concerns. Read GraphQL docs and JSON:API docs for how Drupal's equivalents work, but be honest about the gap: Contentful's GraphQL is first-class; Drupal's GraphQL support comes from the contributed graphql_compose module, not core.

Drupal counters with JSON:API in core since Drupal 8.7 (2019) — every entity gets a working REST-ish endpoint with zero configuration, which is a genuinely different value proposition than "here's an SDK, go build the queries yourself." REST is also in core. Webhooks require contrib. See headless Drupal guide for the JSON:API and GraphQL setup in more depth.

Where Contentful pulls ahead decisively: the integration marketplace. With roughly 110 apps in the App Framework and one of the largest agency partner networks of any headless CMS, if you need a specific third-party connector, Contentful probably already has it built. Drupal's ~50,000 contributed modules are broader in scope but vary in quality — you're more likely to need custom integration work.

Editorial experience

Drupal ships Content Moderation and Workflows in core: define custom states, assign role-based transitions, and every entity — not just a top-level "page" type — can move through that workflow. Fine-grained permissions and roles are also core, so you can lock down who can publish what without an add-on. Drupal Canvas, the new visual page/layout builder in Drupal CMS 2.x, is genuinely new and still less mature than dedicated visual editors — that's a fair knock against Drupal today.

Contentful's editorial states are, out of the box, just draft and published. Real editorial workflow — approval chains, custom states — isn't a Premium-gated feature exactly, but the platform's differentiated editorial tooling (Studio's visual composition, Personalization, Analytics) is Premium-only, and Contentful's own April 2025 pricing change removed the mid tiers that used to sit between Free and enterprise. If your editorial team needs visual, no-code page composition, Studio is the answer — but you're buying into custom enterprise pricing to get it.

Neither has real-time collaborative editing (Google-Docs-style simultaneous editing) — that's a shared gap worth naming rather than pretending one side has it.

Pricing and total cost of ownership

Contentful publishes three platform tiers: Free ($0 — 10 users, 2 roles, 2 locales, 100K API calls/month, 50 GB CDN), Lite ($300/month — 20 users, 3 roles, 3 locales, 1M API calls/month, 100 GB), and Premium (custom quote). Studio, Personalization, AI Actions, and Analytics are Premium-only add-ons. Enterprise contracts are commonly quoted in the $5K–$70K+/year range depending on seats, environments, and records. The April 2025 pricing change cut the free tier and removed mid-tier options, so most teams that outgrow Free land directly on a $300/month floor — and API calls, records, and locales are all metered from there.

Drupal has no license fee. Cost is hosting plus operational time: a typical mid-size self-hosted site runs $50–$500/month in cloud infrastructure, plus developer time for updates and maintenance — a few hours a month at minimum. That's a range, not a number, because it depends entirely on how much of the operational burden (patching, PHP version upgrades, database tuning) your team absorbs versus outsources. Enterprise Drupal PaaS providers like Acquia and Pantheon typically run into the thousands of dollars a month at enterprise scale, on custom quotes.

Worked example. A team with 10 editors, 3 locales, 50,000 entries, and 2 million API calls/month:

• Contentful: 3 locales and 20-user support push you past Lite's 1M API call cap at 2M calls/month, so you're negotiating a Premium contract — realistically in the low-to-mid five figures annually once you account for seats and call volume, on a custom quote.
• Drupal (self-hosted): infrastructure sized for 50K entities and 2M requests/month sits comfortably in the $200–$500/month range, plus ongoing maintenance time; no per-locale or per-API-call charge exists.
• Drupal on Acquia/Pantheon: enterprise Drupal PaaS at this scale is commonly quoted in the low thousands per month, custom.

Locale count and API volume are exactly the two levers Contentful meters and Drupal doesn't, which is why this scenario tips toward Drupal on raw platform cost — even before adding operational time to Drupal's side of the ledger.

Operations, hosting, and security

Contentful is fully managed. You don't patch anything, you don't run a database, and the CDN and uptime record are, on the numbers Contentful publishes, excellent. That operational simplicity is real and it's the primary reason small teams without dedicated ops pick Contentful.

Drupal has a dedicated Security Team that publishes advisories and ships regular security releases — but if you're self-hosting, applying them is your job. That means owning PHP versions, Composer dependencies, database maintenance, and caching layers. This is Drupal's most honest weakness: the security process is mature, but the operational burden of staying current sits with you unless you pay a host (Acquia, Pantheon, or a managed provider) to absorb it.

Lock-in and exit

Contentful's contentful CLI space export produces a Contentful-specific JSON format — usable, but it's a proprietary shape you have to map to whatever you migrate to. Combined with being SaaS-only with no self-hosting path, leaving Contentful means a genuine data migration project, not a git clone.

Drupal's content lives in a standard, open database schema that dozens of hosts and tools already understand. You can export config and content and stand it up on any Drupal-compatible host — including moving between Acquia, Pantheon, self-hosted infrastructure, or a managed provider — without a proprietary export format standing between you and your own content.

Choose Contentful if…

• You need a working, well-documented API in days, not weeks, and have no in-house ops capacity.
• Your integration list is long and you'd rather browse an app marketplace than build connectors.
• Your procurement process wants a vendor with a decade of enterprise sales history and reference customers.
• You don't need deep editorial workflow or component-based content modeling out of the box.

Choose Drupal if…

• Your content model has real structural complexity — components, deep taxonomies, multi-state moderation.
• You need localization and workflow together, not localization as a bolt-on.
• Your API volume or locale count would push you into Contentful's metered Premium tier.
• You want an exit path that doesn't depend on a vendor's proprietary export format.

The best of both worlds

decoupled.io is managed headless Drupal: every tenant is a real Drupal instance on its own Fly.io machine, with JSON:API and GraphQL included on every tier — no metering by API call, locale, or content item. You get Drupal's content modeling and workflow depth, plus a Puck visual page builder and 25+ MCP tools for AI agents, without owning the PHP/Composer/patching burden — updates are automatic. Plans run $0 (Free), $20/month (Starter), and $60/month (Pro), a flat structure that doesn't cliff the way Contentful's Free-to-Lite jump does.

What decoupled.io doesn't match yet: Contentful's integration marketplace. Contentful's roughly 110 apps and mature partner network cover more third-party connectors out of the box than decoupled.io's curated module set does today — if your stack depends on a specific niche integration, check for it before assuming decoupled.io has it. See the fuller feature breakdown at Decoupled.io vs Contentful, and if you're migrating existing content, Contentful migration guide walks through moving your entries over. Pricing is at pricing.

FAQ

Is migrating from Contentful to Drupal hard? It's a real project, not a button press — Contentful's export is a proprietary JSON format that you have to map onto Drupal's entity/field system. The mapping is usually mechanical (content types to content types, references to references) but rich text with embedded entries needs manual attention. See Contentful migration guide for the process.

Which one is cheaper? It depends on scale. Contentful's Free and Lite tiers ($0 and $300/month) are cheaper than any hosted Drupal option for a small, low-traffic site. Once you exceed Lite's 1M API calls/month or need more than 3 locales, Contentful pushes you into a custom Premium quote, while Drupal's self-hosted cost ($50–$500/month plus maintenance time) doesn't have that per-call or per-locale ceiling.

Does Drupal have anything like Contentful's Studio? Drupal Canvas, shipped with Drupal CMS 2.x, is Drupal's visual page/layout builder — but it's new and currently less mature than Studio or comparable dedicated visual editors. If no-code visual composition is a hard requirement today, weigh that maturity gap seriously.

Can I get Drupal's modeling without running the servers myself? Yes — that's what managed Drupal hosts including decoupled.io, Acquia, and Pantheon are for. decoupled.io specifically includes JSON:API, GraphQL, and automatic security updates on every tier with flat, unmetered pricing; see pricing for current plans.

Part of the Drupal vs the headless CMS field series.