Wagtail vs Contentful:
Which CMS in 2026?

When organisations start evaluating headless CMS platforms, Contentful tends to come up first. It has strong brand recognition, a mature API, and a large ecosystem of integrations. Wagtail, being a Python CMS rather than a SaaS product, gets less marketing spend behind it — but it has a formidable track record in production, particularly in publishing, education, and organisations that need precise control over their content model.

We've built production systems on both. This comparison is based on that experience — not on feature matrices assembled from documentation.

The fundamental difference

Before comparing features, it's worth understanding what kind of product each one is, because they come from completely different philosophies.

Contentful is a cloud-hosted SaaS headless CMS. You define content types in a web UI, manage content through that UI, and access everything via a REST or GraphQL API. Your content lives on Contentful's infrastructure. You pay for it monthly.

Wagtail is an open-source Django CMS. You install it in your Python project, define content models in code, deploy it on infrastructure you control, and access content via Wagtail's API or Django's ORM. Your content lives in your own database. You pay for hosting — not the CMS itself.

That distinction — hosted SaaS versus self-hosted open source — drives almost every difference between them in practice.

Content modelling

Both platforms have genuinely strong content modelling capabilities, but they work very differently.

In Contentful, you define content types through the web UI: add fields, set validations, link content types to each other as references. It's accessible to non-developers and fast to iterate on. The downside is that your content model lives in Contentful's database, not in your codebase. There's no version history for model changes, no pull request process, no easy way to promote model changes from staging to production without manual reproduction.

In Wagtail, you define content models in Python. A news article, a case study, a product page — all defined as Django models with Wagtail's field types. This means your content model is in your codebase, versioned in git, reviewed in pull requests, deployed with your application.

class CaseStudyPage(Page):
    client_name = models.CharField(max_length=255)
    industry = models.CharField(max_length=100, choices=INDUSTRY_CHOICES)
    summary = models.TextField()

    body = StreamField([
        ('text', RichTextBlock()),
        ('pullquote', BlockQuoteBlock()),
        ('result', StructBlock([
            ('metric', CharBlock()),
            ('description', CharBlock()),
        ])),
        ('image', ImageChooserBlock()),
    ])

    related_services = ParentalManyToManyField('services.Service')

    content_panels = Page.content_panels + [
        FieldPanel('client_name'),
        FieldPanel('industry'),
        FieldPanel('summary'),
        FieldPanel('body'),
        InlinePanel('related_services', label='Related services'),
    ]

Every field, every validation, every relationship is explicit and reviewable. When you change your content model, Django's migration system handles the database change, and your content in staging versus production is always in sync with your deployed code.

Pricing

This is where the comparison shifts decisively for many organisations.

Contentful's free tier is limited to 5 users and basic features. Their Growth plan starts around $300/month. The Scale plan — needed for larger teams, more content types, and higher API call volumes — is significantly more expensive and requires a custom contract. At meaningful scale, Contentful costs can run to thousands of pounds per month.

Wagtail is free. The CMS itself has no licence cost. You pay for hosting — a well-configured VPS or PaaS instance — which for most projects runs £50–200/month. For high-traffic sites you'll add a CDN, but that cost is orders of magnitude lower than enterprise Contentful pricing.

For organisations with budget constraints, or with content that will grow significantly, the economics of Wagtail are very hard to argue with. The upfront cost is engineering time to build and deploy — but you're not committing to a recurring SaaS bill that scales with your success.

API and headless capability

Contentful is headless by design — the API is the product. The REST Content Delivery API and GraphQL API are polished, well-documented, and have SDKs for every major language and framework. If you need to deliver content to multiple frontends (web, mobile app, smart TV), Contentful's API-first architecture makes that natural.

Wagtail has a fully capable headless mode through its API layer. You can expose pages, snippets, and images via REST or GraphQL (via the wagtail-graphql package). It's not as plug-and-play as Contentful's API — you configure which fields to expose — but that explicitness means you're not accidentally leaking internal fields to public consumers.

class CaseStudyPage(Page):
    api_fields = [
        APIField('client_name'),
        APIField('industry'),
        APIField('summary'),
        APIField('body', serializer=StreamFieldSerializer()),
        APIField('related_services'),
    ]

For pure headless architectures — Wagtail as the content backend feeding a Next.js or SvelteKit frontend — this approach works very well in production. We've built several such systems. The main difference from Contentful is that you're running your own infrastructure, which brings operational overhead but also complete control.

Editorial experience

Contentful's editorial interface is clean and functional. It works well for managing content types defined in the UI, supports multiple locales, and has a reasonable media library. The content entry forms are generic — they don't adapt to the shape of specific content — which is fine for structured data entry but less suitable for rich page editing.

Wagtail's editorial interface is one of its genuine strengths. The panel system lets you design the editing experience to match the actual workflow of your editors — field ordering, contextual help, inline related content, image cropping with focal points. The page tree gives a clear mental model of site structure. StreamField provides rich in-context page editing for editorial teams used to tools like WordPress's Gutenberg.

Wagtail also includes editorial workflow features that Contentful's lower tiers don't match: moderation workflows with per-page approval chains, full revision history with side-by-side diff view, scheduled publishing, and live preview. For organisations with structured editorial processes — a publisher, a university, a large content team — these features matter significantly.

Vendor lock-in and data ownership

This is an underappreciated consideration. With Contentful, your content lives in Contentful's infrastructure. Migrating away requires exporting all content (Contentful provides a CLI for this) and rebuilding your content model elsewhere. It's possible, but it's a project in itself — and the longer you've been on the platform, the larger that migration is.

With Wagtail, your content is in your PostgreSQL database. You own it. Moving to a different CMS means migrating database content, but you have complete access to the raw data at all times. Changing hosting providers, upgrading your infrastructure, or switching frontends requires no negotiation with a SaaS vendor.

For public sector organisations, universities, and businesses with data residency requirements, self-hosted Wagtail is frequently the only viable option regardless of other considerations.

When we recommend Contentful

• The project is genuinely omnichannel — web, mobile app, and additional surfaces — and the API-first architecture is a requirement from day one
• No Python developers are available, and the team needs a hosted, managed platform
• Non-technical stakeholders need to modify the content model without developer involvement
• The organisation already has a Contentful contract or existing Contentful content to build on
• The project is exploratory and needs rapid prototyping with minimal infrastructure setup

When we recommend Wagtail

• The team has Python/Django capability, or you're engaging a specialist agency
• Cost at scale matters — Contentful's pricing would become significant as content and users grow
• Data ownership or data residency is a requirement
• You need rich editorial workflows: moderation, scheduling, revision history, preview
• The content model is complex and benefits from being versioned alongside application code
• You need both traditional server-rendered pages and headless API output from the same CMS
• You want to extend the CMS with custom business logic — Python gives you the full power of the Django ecosystem

Our honest recommendation

For most organisations we work with — publishers, universities, SaaS companies, non-profits — Wagtail is the better choice. The economics are more favourable, the editorial experience is stronger for complex content, the data ownership story is cleaner, and the integration with Python business logic is often essential.

Contentful is the right call when the project is genuinely API-first from day one and the team has no Python capability. It's an excellent product for what it does. But the narrative that "headless CMS means Contentful" is a simplification that leads organisations to pay for a SaaS product when an open-source alternative would serve them better.

The honest answer, as always, is that it depends on your content, your team, and your trajectory. We're happy to talk through which one fits your situation — and we'll tell you if Contentful is the right call for your project, even though we build in Wagtail.