Contentful vs Strapi: when each option fits
Contentful fits teams that want the vendor to run hosting, the content API and most platform operations, and that accept a hosted model in exchange. Strapi fits teams that need the content model, the database and the media files inside infrastructure they control, and that can staff upgrades, backups and security patches. The decision turns on four questions: how much hosting control the organization requires, which Enterprise features it needs, how much operations capacity its own engineers have, and what their time costs. Be precise about the licensing: Strapi Community Edition is MIT licensed, but code under `ee` directories falls under the Strapi Enterprise Edition license unless the customer holds a signed agreement or a Strapi Cloud subscription, as the Strapi LICENSE file states. Read that file against your feature list before you commit.
Start with the Enterprise features, because they often decide the outcome. Per Strapi's self-hosted pricing page, audit logs and review workflows are Enterprise features, SSO is an add-on on the Growth plan and included in Enterprise, and content history and releases start at Growth. Strapi SSO covers administrator login to the admin panel only, so confirm whether your editors need SSO and whether your approval process needs workflow controls the Community Edition does not provide. Ask Contentful to confirm which roles, workflows and audit capabilities your current plan includes, so you compare like with like. Also confirm current pricing directly with both vendors, since list prices change.
Then size the operations work honestly. With Strapi you own the Node.js runtime (check the supported Active or Maintenance LTS versions in the installation requirements), a PostgreSQL, MySQL, MariaDB or SQLite database, backups, the media store, the CDN and upgrades. Strapi 5 minor releases ship frequently, so plan a standing upgrade cadence rather than an occasional project. Estimate the engineering hours that cost represents, then compare them with the subscription and usage charges you pay Contentful. If your team lacks that capacity, a hosting or implementation partner can take on part of the work under a written scope, but the staffing question remains yours to answer.
Which platform fits which situation
This table matches common buyer situations to the better fit between hosted Contentful and self-hosted Strapi, with the condition that decides each choice. Read each row against your own staffing, hosting and content governance, because the better fit often depends on who runs the database, upgrades and backups.
| Situation | Better fit | Reason and condition |
|---|---|---|
| Small marketing team with no platform engineers | Contentful (hosted) | Hosting, upgrades and database backups stay with the vendor. Self-hosted Strapi suits this team only if someone can own patching and restores. |
| Regulated publisher that must keep content in its own cloud account | Strapi (self-hosted) | Content and the database can sit in your account. This holds only if your security team accepts running the admin panel, database and media storage yourselves. |
| Team with an existing Node.js and PostgreSQL stack | Strapi (self-hosted) | Strapi 5 runs on PostgreSQL 14 or later and Active or Maintenance LTS Node.js versions. It fits when your PostgreSQL backups and restore tests already exist. |
| Multi-brand organization needing strict editorial approvals | Confirm before choosing | Strapi review workflows and audit logs are listed as Enterprise features. Confirm the approval model you need against both plans before deciding. |
| Team on Strapi v4 planning an upgrade | Plan the upgrade either way | Strapi v4 reached end of life on April 30, 2026. Back up the database first because downgrading is not supported, and weigh the migration effort against staying on Contentful. |
| Team that needs SSO for editors | Confirm before choosing | Strapi SSO covers administrator login to the admin panel, and the self-hosted Growth plan lists it as an add-on. Confirm whether your end-user and editor logins need a different path. |
| Team wanting a fixed, vendor-run uptime commitment | Contentful (hosted) or Strapi Cloud | Self-hosted Strapi places uptime on your own operations. Strapi Cloud lists a 99.9% uptime SLA on its Business plan, so ask for the written terms. |
How content modeling and editing differ in Contentful and Strapi
In Contentful, content types are defined in a hosted model that you change through the web app or the management API, and the same space holds the schema, entries and assets. In Strapi, content types are code-backed collections and single types that live in the project's source files, so a schema change is a commit that gets reviewed, merged and deployed like any other code change. Strapi stores that model in a database you run yourself: PostgreSQL 14 or later, MySQL 8.0 or later, MariaDB 10.3 or later or SQLite 3. Strapi 5 does not support MongoDB or other NoSQL databases, so teams whose content lives in a document store will need to plan a different data layer before they move.
The promotion path changes with that model. In Contentful, teams commonly use environments within a space to test a model change before it reaches production, and the web app is where editors and developers see the same schema. In Strapi, the usual path is development, staging and production, with the schema changes committed to the repository and the database migrated in each environment. Ask your team who approves a schema change, how a content-type edit is rolled back, and whether editors can add fields in production or only developers can. The export of a Contentful space includes the content model, which maps to Strapi content types, but field types, validations, references and rich text settings usually need manual rework, so budget review time for the model itself.
Content operations in Strapi 5 run through the Document Service API, which replaces the Entity Service API from Strapi 4 and is where custom code should read and write documents. Developers should confirm which responses their front end expects, since Strapi 5 changes the API response format and offers a Strapi-Response-Format: v4 header for backward compatibility during migration. Editorial experience is harder to judge from documentation. Whether the Strapi admin panel meets your editors' needs depends on their drafts, previews, approvals and bulk edits, so run a timed editing session with real editors on a copy of your content and record where they stop.
Capability by capability: Contentful against Strapi
This table compares Contentful's hosted capabilities with self-hosted Strapi across the areas a CMS decision turns on. Strapi cells rely on its published plan and licensing facts, while Contentful cells say where you must confirm current behavior with Contentful before deciding. Read the Strapi column for what you would need to pay for or operate yourself, and use the confirm items as a checklist for your vendor call.
| Capability | Contentful | Strapi (self-hosted) |
|---|---|---|
| Content modeling | Content types defined in the hosted web app; confirm current field and model limits with Contentful | Content types defined in the admin panel and code; the Community Edition is MIT licensed |
| Localization | Locales configured per space; confirm locale limits and fallback rules with Contentful | Internationalization is available in the self-hosted build; verify plugin and version support for your locales |
| Rich text and references | Structured rich text and entry links; confirm embed and reference depth limits with Contentful | Rich text and relations are part of the content model; check editor support for your block types |
| Roles and permissions | Roles and permissions managed per space; confirm granularity and whether roles export with the space | Roles managed in the admin panel; review workflows and audit logs are Enterprise features |
| Editorial workflows | Confirm which review and approval steps are included in your Contentful plan | Review workflows are an Enterprise feature; content history and releases start at the Growth plan |
| REST and GraphQL delivery | Delivery and preview APIs offered; confirm current GraphQL and rate limits with Contentful | REST and GraphQL APIs are included on every self-hosted plan, with unlimited entries and API calls |
| Caching and CDN delivery | Hosted CDN for published content; confirm cache behavior and purge options with Contentful | No built-in CDN; you place a CDN and cache layer in front of the API in your own infrastructure |
| Webhooks | Webhooks configured per space; the CLI export carries webhook definitions but not credentials | Webhooks are configured in the server; you own delivery, retries and monitoring |
| Asset management | Hosted asset storage and image transforms; confirm transform and storage terms with Contentful | Media library stores files in local or external storage that you provision and back up |
| SSO for administrators | Confirm which SSO options your Contentful plan includes | SSO is a Growth add-on and included in Enterprise; it covers admin login only |
| End-user authentication | Confirm how Contentful handles delivery-side access control for your front end | Handled by the Users and Permissions plugin, separate from admin SSO |
| Audit logs | Confirm audit log retention and export with Contentful | Audit logs are an Enterprise feature under the Strapi Enterprise Edition license |
| Plugin and extension ecosystem | Apps and UI extensions in the hosted web app; confirm current extension model with Contentful | Community plugins plus Enterprise code under ee directories with a separate license |
Who holds the data, runs the database and controls access
Moving from Contentful to Strapi changes who stores the content, who runs the database and asset store, and who decides how administrators and end users sign in. Each card below names one of those decisions, the condition under which it matters, and what to confirm with the vendor or your own team before committing.
Where the content and assets live
A Contentful space is stored on Contentful's hosted platform, so residency and backup terms come from Contentful's contract. Self-hosted Strapi places the database and media storage in your own cloud account or data center, which matters when content includes personal data or regulated records. Confirm with Contentful the regions where your space is stored and how assets are delivered. In your own environment, confirm where the database and upload provider sit, and who can read those backups.
Who operates the database
With Contentful, the vendor runs the database, scaling and patching. With self-hosted Strapi, your team or a partner runs PostgreSQL, MySQL, MariaDB or SQLite, plus Node.js runtime updates and backups. Strapi 5 does not support MongoDB or other NoSQL databases, so that choice is settled before the build starts. Confirm the supported database versions in Strapi's installation requirements and set a tested restore procedure before cutover.
Hosting model options
There are three realistic paths: self-host Strapi Community Edition on your own infrastructure, use Strapi Cloud, or engage a partner to deploy and operate a self-hosted instance. Strapi Cloud is listed at 35 US dollars per month per project for Starter, 90 for Pro and 450 for Business, with a 99.9% uptime SLA on Business. Ask Strapi where Cloud projects are hosted, which sub-processors it uses, and how backups are retained. For self-hosting, a partner quote follows from written scope.
Administrator SSO versus end-user login
Strapi SSO covers only administrator sign-in to the admin panel through an identity provider such as Microsoft Azure Active Directory, and it is an add-on on the Growth plan but included in Enterprise. End-user authentication for the public site runs through the Users and Permissions plugin, which you must configure and harden yourself. Decide early which identity provider governs editors, and whether local login stays enabled as a fallback. Confirm how Strapi handles SSO data and session records under your data handling terms.
Compliance evidence and audit scope
If your organization is preparing for a regulated assessment, the self-hosted stack becomes part of your scope. Your team can produce evidence of access reviews, backup tests, patching records and change logs, but an independent auditor or certification body issues any report or attestation. Contentful will provide its own compliance documentation for the hosted service, and you must map which controls move to your side. Confirm with Strapi and your auditor which records the Enterprise audit log covers before relying on it.
Sub-processors and data processing terms
Contentful, Strapi Cloud, and any partner or hosting provider you choose each process some of your data, and each adds a sub-processor chain. Request the current sub-processor list from each vendor, along with the data processing agreement and breach notification terms. For a self-hosted Strapi, your own cloud, CDN, email and backup providers become the sub-processors that matter. Document these in one register so the residency and access story matches what your assessor will be told.
Which Strapi edition covers the requirements you have
The Community Edition is the free, self-hosted tier and is licensed under the MIT Expat license. It has no user limit, and it includes the REST and GraphQL APIs with unlimited entries and API calls, according to Strapi's self-hosted pricing page. For many teams the core content modeling, media and API delivery work sits here, so the decision is often whether the governance features in the paid tiers are needed. Confirm the following before you rely on this tier:
- Licensing of the core: the MIT license covers the Community code in the repository, which the Strapi LICENSE file documents.
- Enterprise code in the same repository: code under
ee/directories is not MIT and needs a separate agreement, so review your fork before adding it. - No audit logs or review workflows: these are Enterprise features in Strapi's listing, so plan alternative controls if your policy requires them.
- Operations cost: you pay for hosting, database, storage, upgrades and monitoring yourself, even though the license fee is zero.
Confirm with Strapi which features are Community-only before you commit to a design.
The Growth plan is listed at 45 US dollars per month for a self-hosted deployment, including 3 users, with 15 US dollars for each extra user, according to Strapi's self-hosted pricing page. It adds capabilities that matter to editorial teams, including content history and releases, which start at this tier. Single sign-on is an add-on for Growth rather than included, so the total depends on how many editors and administrators you have and whether you need SSO.
- User-based pricing: the listed price covers 3 users, and each additional user is billed at the listed rate, so editor count drives the recurring fee.
- Content history and releases: these begin at Growth, which matters for teams that schedule and roll back content.
- SSO as an add-on: administrator login through an identity provider is priced separately from the base plan.
- Scope of SSO: Strapi's SSO documentation covers administrator login to the admin panel, and end-user authentication is handled by the Users and Permissions plugin.
- Audit logs excluded: these remain an Enterprise feature.
Ask Strapi for a current quote, since list prices can change, and check whether SSO and your user count fit the Growth allowance.
The Enterprise plan is priced on request, and it bundles the governance features that regulated teams often need to show. According to Strapi's self-hosted pricing page, it includes SSO, audit logs and review workflows, along with the REST and GraphQL APIs. Code under the ee/ directories is licensed under the Strapi Enterprise Edition license, so this tier is also the route to using that code legally, unless you hold a signed agreement.
- Custom pricing: there is no published figure, so the cost depends on your scope and terms and must come from a written quote.
- Audit logs and review workflows: these are included, which supports approval trails for regulated content.
- SSO included: you do not pay the Growth add-on, but confirm how identity provider setup is supported.
- Licensing terms: request the contract language covering
ee/code, support and any usage limits. - Support and upgrades: ask what support, upgrade assistance and response commitments are included.
Confirm the governance requirements, such as audit retention and approval steps, with Strapi before you sign.
Strapi Cloud is a separate hosted option rather than a self-hosted edition. Its plans are listed at 35 US dollars per month per project for Starter, 90 for Pro and 450 for Business, according to Strapi's Cloud pricing page, and each plan has API request, storage and bandwidth allowances. The Business plan includes a 99.9% uptime SLA. Choosing Cloud moves hosting and availability to Strapi, which changes who runs the operations work.
- Per-project pricing: each project carries its own plan fee, so several sites multiply the cost.
- Allowances: API requests, storage and bandwidth are capped by plan, so check your traffic against them.
- Uptime commitment: the 99.9% SLA applies to Business, and you should read its terms.
- Data location: confirm where the hosted data resides, which matters for residency rules.
- Exit path: confirm export options if you later move to self-hosting.
If data residency or control of the infrastructure is a requirement, compare Cloud against a self-hosted edition before choosing.
What self-hosting Strapi costs over several years
The software line is the smallest part of the comparison. Strapi's Community Edition costs nothing to license, and the self-hosted pricing page lists Growth at 45 US dollars per month including 3 users, plus 15 dollars per extra user, with Enterprise on custom pricing. Contentful's subscription and usage limits are set by its plan and quote, not by this page, so ask Contentful for the figures that apply to your space, API volume, asset storage and locales. On the Strapi side, the recurring lines you will pay for are the Node.js application host, a PostgreSQL, MySQL, MariaDB or SQLite database (MongoDB is not supported), object storage for assets, a CDN, backups, monitoring and the people who run them. Growth is only needed if you want SSO for the admin panel, content history and releases. Enterprise is needed for audit logs and review workflows. Ask your vendor or integrator to price each of these separately so you can see which line moves when your traffic or team grows.
Most of the recurring cost is staffing and patching, and that cost depends on the upgrade cadence you accept. Strapi v4 reached end of life on April 30, 2026, and Strapi 5 minor releases have shipped roughly weekly, with v5.58.0 published on October 14, 2026 according to the Strapi GitHub releases page. Each upgrade carries a review, a test pass and a deployment, and you must budget for that work every quarter, not once. The one-time costs are the content migration itself and the rebuild of anything Contentful supplies as a service, such as webhooks, roles and editor configuration. A written quote should state who owns the upgrade calendar, what is covered in each retainer, whether the migration covers the v4 to v5 move, and how backups are tested. Ask for the cost of the first year and the recurring cost of years two and three as separate lines.
Several things move the total in either direction. Content volume, asset size, locale count and the number of API calls drive the database, storage and CDN lines. Team size drives Growth seat costs and the admin access model. Compliance requirements, such as retention and audit trails, can push you toward Enterprise or add monitoring and evidence work. The Strapi SSO docs describe SSO as applying only to administrator login, so end-user authentication is a separate cost to plan. Before you sign anything, confirm with Strapi which features need Enterprise terms by reading the Strapi LICENSE file, and ask your integrator for a line-item estimate for hosting, backups, monitoring, upgrades and the one-time migration, with the assumptions behind each figure stated in writing.
What a move from Contentful to Strapi involves
The sequence takes a Contentful space to a self-hosted Strapi project that your team runs, with content, assets and access rebuilt and checked before the old space is retired. Each step has a named output so you can tell when it is finished.
Inventory the Contentful space
Your content owners and an engineer list every content type, field, locale, webhook, editor interface and environment in the space, along with the roles and memberships that govern who edits what. The inventory is the baseline for later checks. It is done when each content type has an owner, each locale is named, and each webhook is tied to the system that consumes it. Ask your Contentful administrator to confirm which environments and aliases are in use before you start.
Export the space with the Contentful CLI
An engineer runs the Contentful CLI space export command to write the published content model, content and assets as JSON, including content types, entries, assets, locales, webhooks and editor interfaces, and to download asset files. The export does not include roles or permissions, so those must be recorded by hand from the inventory. It is done when the export files are stored in a version-controlled or access-restricted location and the asset count matches the Contentful web app.
Stand up the Strapi environment
Your platform team installs Strapi in your own infrastructure with a supported database, such as PostgreSQL, MySQL, MariaDB or SQLite, and a supported Node.js version. Confirm the database and Node.js requirements in Strapi's installation documentation before choosing hosting. If you plan to upgrade an existing Strapi v4 project, that is a separate path: back up the database first, because downgrading is not supported. It is done when the admin panel runs in staging behind your standard access controls.
Map content types to collections and components
A content architect converts each Contentful content type into a Strapi collection type or single type, and each reusable block into a component. Field types, validations, required flags and relations are recorded in a mapping document that the developers and editors both sign off. It is done when every Contentful content type has a Strapi counterpart in the mapping document and the staging schema matches it.
Transform rich text, references and assets
Developers write scripts that read the export JSON, rewrite Contentful rich text and entry links into Strapi's fields and relations, and upload asset files to Strapi's media library or your chosen object store. Assets are re-uploaded and checked for file type, size and alt text. It is done when a sample of entries renders with working links and images in staging, and an asset reconciliation report shows no missing files.
Rebuild webhooks, roles and SSO
Because the export omits roles and permissions, your security or platform engineer recreates administrator and editor roles in Strapi and sets up single sign-on for the admin panel where your plan includes it. Webhooks are recreated to point at your build pipeline or frontend, with secrets stored in your secrets manager. End-user access to the API is handled separately through the Users and Permissions plugin. It is done when test accounts with each role can perform only the actions in your access matrix, and webhooks fire on a test publish.
Run parallel content checks and cut over
Editors publish test changes in both systems for an agreed period, and a QA lead compares entry counts, locales and rendered pages between Contentful and Strapi. Once the frontend reads from Strapi, redirects for changed URLs are tested and the DNS or deployment switch is made. It is done when reconciliation shows no unexplained differences and the production frontend serves content from Strapi with redirects confirmed.
Retire the Contentful space after a defined period
After the agreed read-only period, the team takes a final export, archives it in your records store, removes API tokens and webhooks from Contentful, and confirms with the account owner what the subscription terms require before cancellation. Ask Contentful to confirm its current data retention and export terms in writing. It is done when the final export is verified, the archive is documented and no production system still calls the Contentful API.
Questions buyers ask before switching from Contentful to Strapi
What does a migration from Contentful to Strapi cost in effort, and what drives it up?
The largest cost is the one-time engineering effort to rebuild your content model in Strapi, transform entries and rich text, re-upload assets, and rebuild the frontend's data calls. Effort rises with the number of content types, the depth of references, the volume of rich text and the number of locales and environments. Strapi Community Edition itself carries no license fee, so the recurring costs are hosting, database and asset storage, a CDN, and your team's upkeep. Ask any implementation partner for a quote built from a written scope that lists content types, locales, integrations and environments. Compare that one-time figure with your current Contentful subscription and usage charges over the same number of years.
How long does a Contentful to Strapi migration take?
Duration depends on the scope, not on a standard number of weeks, so treat any general estimate with caution. The main variables are how many content types and references you have, how much rich text needs transformation, how many assets must be re-uploaded, whether roles and webhooks are rebuilt, and how many frontend pages consume the API. Ask for a written timeline from a scoped plan that names each phase, its deliverables and the acceptance tests for content parity. DeployOpen agrees scope, deliverables and timelines in writing before work starts, so that is the document to request from any vendor you evaluate.
Can our own team migrate to Strapi without outside help?
A team can do it in-house if it already has the skills the work requires. Strapi 5 runs on Node.js, uses PostgreSQL, MySQL, MariaDB or SQLite (not MongoDB), and only supports Active or Maintenance LTS Node.js versions, so you need people comfortable with Node.js, a relational database and the Strapi admin and content API. The frontend also needs a build pipeline and CI that deploy content-driven pages. Be honest about capacity: the migration runs alongside normal delivery work. If one of these skills is missing, an implementation partner can cover that gap under a fixed-scope agreement while your team learns the system.
What must our team run after Strapi goes live?
After launch you own the operations that Contentful previously handled. That includes applying Strapi upgrades, which ship frequently (for example, v5.57.0 on October 7, 2026 and v5.58.0 on October 14, 2026), so you need a regular patch cadence and tests that catch breaking changes. You also own database backups and tested restores, uptime monitoring for the admin panel and public API, server and dependency patching, and asset storage with its CDN. Strapi v4 reached end of life on April 30, 2026, so any legacy v4 instance is already unsupported. Budget for on-call coverage, and write a runbook that names who restores data and how long that is allowed to take.
Do we need Strapi Enterprise Edition features, and when?
You need Enterprise Edition only when a requirement depends on a feature that sits there. Per the Strapi self-hosted pricing page, audit logs and review workflows are Enterprise features, while SSO is an add-on for the Growth plan and included in Enterprise, and content history and releases start at Growth. Note that Strapi SSO covers administrator login to the admin panel through an identity provider, while end-user authentication is handled by the Users and Permissions plugin. Code under ee directories falls under the Strapi Enterprise Edition license, so check whether your audit or compliance obligations require those controls. Get current Enterprise pricing from Strapi, since it is quoted as custom.
What does a Contentful export carry over to Strapi, and what must be rebuilt?
The Contentful CLI space export produces JSON for the published content model, content, assets, locales, webhooks and editor interfaces, and can download asset files. Roles and permissions are not included, so you must rebuild access rules in Strapi using its roles and permissions model and the Users and Permissions plugin for end users. Webhook credentials, memberships and any UI extensions also need to be recreated by hand. Plan to review draft and published states, asset URLs and references in the exported JSON before you trust the import. Read the export documentation linked on the migration hub before scoping the work.
Is Strapi Cloud an acceptable middle option?
Strapi Cloud can be a reasonable middle step if you want Strapi's model without running servers. It is priced per project, listed at 35 US dollars per month for Starter, 90 for Pro and 450 for Business, with API request, storage and bandwidth allowances, and Business carries a 99.9% uptime SLA. Those allowances are the key variable: check how your traffic and asset volumes map to them before you commit. Strapi Cloud does not remove the migration effort, and it does not give you hosting control. If data residency or infrastructure ownership is the reason you are leaving, you should self-host and not treat Cloud as the end state.
How DeployOpen helps teams evaluate and move to self-hosted Strapi
DeployOpen is a Chainscore Labs company that plans, implements, hardens, backs up and documents self-hosted open-source platforms inside your own cloud accounts, data centers or air-gapped networks. For Contentful vs Strapi, we help your team test the fit against your content model, roles, workflows and API delivery requirements, then build and hand over the Strapi deployment you decide to run.
How we scope
- Review your Contentful content types, locales, roles and webhooks against Strapi's data model and permissions.
- Confirm which Strapi edition covers your needs, including whether SSO, audit logs and review workflows require Enterprise Edition.
- Agree the written scope, deliverables and timeline before any work starts, since most engagements are fixed-scope.
How we build
- Set up Strapi on PostgreSQL, MySQL or MariaDB in your environment, using a Node.js version Strapi currently supports.
- Model content types, components and API access, and configure caching and CDN delivery for your front ends.
- Test editorial workflows, role permissions and API responses against a sample of real export data before go-live.
How we hand over
- Document the architecture, deployment steps, upgrade path and configuration decisions in a format your team can maintain.
- Set up tested backups of the database and asset storage, and verify restores, since Strapi downgrades are not supported.
- Walk your engineers and editors through day-to-day operation, content modeling changes and incident response.
How we support
- Plan Strapi version upgrades and patching against the project's frequent minor release cadence.
- Run security testing of the CMS and its APIs on a schedule agreed in advance.
- Ongoing support, upgrades and continuous testing are available as a retainer, priced separately from the initial scope.
