---
title: "Kentico vs Contentful: Architecture, TCO & Migration Guide"
slug: kentico-vs-contentful-architecture-tco-migration-guide
date: 2026-10-12
author: Rishabh Makhar
categories: [Migration Guide, Kentico, Contentful]
excerpt: "Kentico vs Contentful compared on architecture, pricing, TCO, and migration. A technical guide for teams choosing between a .NET DXP and an API-first headless CMS."
tldr: "Kentico is an all-in-one .NET DXP; Contentful is a headless content API. Choose based on your dev stack (.NET vs JS), whether you want bundled tools or composable best-of-breed, and your TCO math."
canonical: https://clonepartner.com/blog/kentico-vs-contentful-architecture-tco-migration-guide
---

# Kentico vs Contentful: Architecture, TCO & Migration Guide


# Kentico vs Contentful: Architecture, TCO & Migration Guide

Kentico and Contentful solve content management in fundamentally different ways. **Kentico** (both Xperience 13 and the newer Xperience by Kentico) is a .NET-based digital experience platform that bundles CMS, marketing automation, and commerce into one monolithic — or hybrid-headless — application backed by SQL Server. **Contentful** is a pure headless, API-first CMS where content is structured into typed entries and delivered via REST or GraphQL, with no rendering layer at all. Choosing between them is really choosing between an integrated DXP that owns the full stack and a composable content layer you wire into your own frontend.

The timing matters. **Kentico Xperience 13 reaches end of support on December 31, 2026** — after that date, Kentico stops delivering security patches, hotfixes, and technical support for the platform. Your site will not immediately shut down, but running an unpatched monolith exposes your organization to compounding security risks. Meanwhile, Contentful was acquired by Salesforce in a deal that closed on September 1, 2026 (announced June 1, 2026, per Salesforce's press release), introducing long-term roadmap uncertainty for teams not already in the Salesforce ecosystem. Both events are forcing platform decisions right now.

## How does Kentico's architecture differ from Contentful's?

The most significant friction point in a Kentico-to-Contentful migration is the impedance mismatch between their architectures. You are moving from a system where content is bound to routing and rendering, to a system where content is purely structured data.

### Kentico: the relational page tree

**Kentico Xperience 13** is a monolithic, server-rendered CMS built on ASP.NET (MVC or Core) and Microsoft SQL Server. Content lives in a highly relational, hierarchical database structure. The core of the system is the `CMS_Tree` table, which dictates the site's routing, language-agnostic node properties, and parent-child page relationships. `CMS_Document` holds culture-specific page data and versioning metadata. Custom fields for each page type live in **coupled data tables** (e.g., `CONTENT_News`, `CONTENT_Article`, or your own custom page type tables). Version history and workflow states sit in `CMS_ObjectVersionHistory`, which must be filtered during extraction to isolate published content from draft records.

Because Kentico was designed to render the frontend, its content model is tied to presentation. A "Page" in Kentico has a URL, a template, and placement within a site navigation tree. Rich text fields often contain Kentico-specific macros (`{% CurrentUser.Name %}`) and inline widgets that rely on the .NET server to evaluate them at runtime. These macros have no equivalent in Contentful and must be explicitly handled — stripped, replaced with static values, or converted to Embedded Entries — before migration. If left in place, they render as broken code on the target frontend.

**Xperience by Kentico** (the current product) is a complete rewrite on ASP.NET Core. It introduces a hybrid-headless model: website channels use a Page Builder for visual editing, while headless channels expose content through auto-generated GraphQL endpoints. It ships via NuGet, follows an evergreen update model with monthly refreshes, and supports SaaS, private cloud, or on-premise deployment. The [upgrade from KX13 to XbyK](https://clonepartner.com/blog/blog/kentico-13-vs-xperience-by-kentico-architecture-tco-migration) is a full rewrite — not a version bump — which means content models, templates, and integrations must all be rebuilt from scratch.

### Contentful: API-first structured content

**Contentful** has no page tree, no server rendering, and no SQL database. Content is modeled as **content types** (schemas) containing typed fields — text, Rich Text, references, media, numbers, dates. Every piece of content is a flat **entry** accessed through three APIs:

- **Content Delivery API (CDA):** Read-only, CDN-cached, rate-limited to 55 uncached requests per second (default tier; enterprise limits differ)
- **Content Management API (CMA):** Read-write, rate-limited to 7–10 requests per second on default plans — this is what migration scripts hit. Enterprise plans negotiate higher limits; confirm your tier before designing retry logic.
- **Content Preview API (CPA):** Draft content access, rate-limited to 14 requests per second

If you want to create a hierarchical relationship (like a category containing articles), you must use Reference fields to link entries together, building a graph of content rather than a tree.

Rich text in Contentful is not HTML. It is a **proprietary JSON AST** (Abstract Syntax Tree) — a document node tree where paragraphs, headings, links, and embedded entries are all structured as typed nodes with children. Any content going *into* Contentful must be converted into this AST. Any content coming *out* must be rendered from it. This is the single biggest migration friction point in either direction.

| Dimension | Kentico (KX13 / XbyK) | Contentful |
|---|---|---|
| **Architecture** | Monolithic (KX13) / hybrid-headless (XbyK) | Pure headless, API-first |
| **Database** | SQL Server (self-managed) | Managed SaaS (no direct DB access) |
| **Content model** | Hierarchical page tree with coupled tables | Flat entries with typed content types |
| **Rich text** | Raw HTML | Proprietary JSON AST |
| **Rendering** | Server-rendered (.NET) or headless GraphQL (XbyK) | None — bring your own frontend |
| **Deployment** | Self-hosted, private cloud, or SaaS (XbyK) | SaaS only |
| **Primary language** | C# / .NET | Language-agnostic (REST + GraphQL) |

## Kentico-to-Contentful content model mapping

Before any data moves, content teams must resolve the structural mismatch between Kentico's page-tree model and Contentful's flat entry graph. This mapping work — identifying which Kentico constructs translate cleanly, which require restructuring, and which have no direct equivalent — is typically the first deliverable in a [migration scoping engagement](https://clonepartner.com/blog/cms-migration/kentico).

| Kentico construct | Contentful equivalent | Migration notes |
|---|---|---|
| **Page type** (e.g., `ArticleType`) | Content type | 1:1 in most cases; field types must be remapped |
| **Page (CMS_Tree node)** | Entry | URL slug becomes a plain-text field; routing moves to frontend |
| **Coupled table field** | Content type field | Data types map directly except for macro-evaluated fields |
| **Page alias / URL alias** | No native equivalent | Implement as a text array field or in a routing table external to Contentful |
| **Category tree** | Reference field → Category content type | Flat or hierarchical; rebuild as linked entries |
| **Attachment (CMS_Attachment)** | Asset | Requires the 6-step upload/process/publish sequence (see below) |
| **Relationship** (structured data link) | Reference field | Many-to-many requires a junction content type in Contentful |
| **Web part / widget** | Embedded Entry in Rich Text AST | Must be modeled as a content type and embedded in the AST node |
| **Kentico macro** (`{% %}`) | No equivalent | Must be stripped, hardcoded, or converted to Embedded Entry |
| **Language version (CMS_Document)** | Localization (locale field on entry) | Contentful localizes at the field level, not the entry level |
| **Workflow state / draft** | Draft / published entry status | Draft entries exist in Contentful but workflow stages are not native; use third-party tools (e.g., Workflows app) or tags |
| **Page template** | No equivalent | Templates live in the frontend; Contentful has no rendering layer |

The most structurally disruptive mappings are page aliases (no native Contentful concept), many-to-many relationships (require a junction content type), and workflow stages beyond draft/published (require external tooling). Teams that treat this mapping as a simple field rename exercise consistently underestimate migration scope.

## What does Kentico cost vs Contentful?

Direct price comparison is deceptive because these platforms include different scopes. Kentico bundles CMS, marketing, and commerce. Contentful is content infrastructure only — you pay separately for personalization, analytics, A/B testing, and commerce.

### Kentico pricing

Kentico Xperience 13 was priced on perpetual or subscription licenses. Third-party pricing trackers report the **Business plan starting near $12,500/year** and **Enterprise starting near $22,300/year**. Xperience by Kentico (the current product) starts at approximately **$990/month self-managed (~$11,880/year)** or **$1,990/month for SaaS (~$23,880/year)**. Kentico does not publish exact enterprise quotes on its website — pricing depends on channels, tier, and AI packages.

The hidden cost with Kentico is .NET development. You need .NET developers for customization, and the move from KX13 to XbyK is a full rewrite, not a version upgrade — the admin UI is new, the framework shifts from .NET Framework to .NET Core, and content models must be rebuilt. These version-to-version upgrades are effectively mini-migrations.

A standard enterprise deployment also requires infrastructure you manage: Azure App Services (or equivalent VMs), Azure SQL Database, Redis for caching, and Azure Cognitive Search. High-availability setups duplicate these costs across regions.

### Contentful pricing

Contentful has three platform tiers: **Free** ($0), **Lite** ($300/month), and **Enterprise** (custom). The Lite plan includes 20 users, 1 million API calls per month, and 100 GB CDN bandwidth. A Lite Space add-on costs an extra $850/month for 50 content types, 50K records, and 2 million additional API calls.

The real-world numbers are higher. According to Vendr's benchmarking dataset, SMB contracts average approximately **$33,000/year**, and enterprise contracts average approximately **$148,000/year**.

API overages are the most common budget breaker. If your frontend makes inefficient calls to the CDA without a caching layer (Redis or a CDN), your monthly bill will spike. Building the frontend presentation layer (typically in Next.js or Nuxt) also requires a dedicated engineering team, shifting costs from backend .NET developers to frontend JavaScript developers.

For a deeper dive into Contentful's pricing dynamics and alternatives, see our guide on [Contentful Alternatives 2026](https://clonepartner.com/blog/blog/contentful-alternatives-2026-features-migration-tco).

### Three-year TCO sketch

| Cost driver | Kentico (XbyK SaaS) | Contentful (Enterprise) |
|---|---|---|
| **Platform license (Year 1)** | ~$24K–$100K+ | ~$33K–$148K+ |
| **Frontend development** | Included (ASP.NET Core) | Separate — React/Next.js build |
| **Marketing tools** | Included (email, personalization, forms) | Separate vendors (Braze, LaunchDarkly, etc.) |
| **Commerce** | Included (native) | Separate (Shopify, commercetools, etc.) |
| **Developer profile** | .NET specialists | JavaScript/TypeScript generalists |
| **Hosting** | Included in SaaS; self-managed otherwise | Included (SaaS) — frontend hosting separate |

Teams often underestimate Contentful's **total stack cost**. The platform fee is just the content layer. Personalization (Contentful's Ninetailed add-on), A/B testing, forms, email marketing, and commerce all require separate tools and contracts. Kentico bundles most of these — but that bundle means you also absorb Kentico's .NET ecosystem lock-in.

> [!NOTE]
> Pricing figures are sourced from vendor documentation, public pricing pages, and third-party benchmarking data (Vendr). All figures verified mid-2026. Treat as directional starting points — request quotes for exact numbers.

## Decision matrix: Kentico vs Contentful

Rather than restating architecture differences as vague preferences, the table below weights the factors that most commonly determine platform fit. Score each factor 1–3 for your organization (1 = low importance or does not apply, 3 = critical), then compare totals per column.

| Decision factor | Points toward Kentico | Points toward Contentful |
|---|---|---|
| **Primary dev language** | .NET / C# team | JavaScript / TypeScript team |
| **Content channels** | Web only or web + email | Web + mobile + IoT + API consumers |
| **Vendor consolidation preference** | Single vendor for CMS + marketing + commerce | Best-of-breed stack, multiple vendors acceptable |
| **Marketer self-service need** | High — marketers need visual page building without dev tickets | Low — editors work in structured forms; dev controls layout |
| **Frontend framework** | ASP.NET Core MVC (server-rendered or Razor) | React, Next.js, Nuxt, Svelte, or any JS framework |
| **Marketing tool budget** | Bundled tools acceptable | Separate tools (Braze, LaunchDarkly, Segment) already budgeted |
| **Commerce requirement** | Native commerce needed | Headless commerce (Shopify, commercetools) already planned |
| **Salesforce ecosystem** | Not in Salesforce ecosystem | Already invested in Salesforce CRM / Marketing Cloud |
| **Infrastructure ownership** | Comfortable managing Azure SQL, Redis, App Services | Prefer fully managed SaaS, no infra ownership |
| **Content model complexity** | Hierarchical, template-driven content | Structured, reusable content blocks shared across channels |

If the majority of high-weight factors point to Kentico, the case for staying in the .NET ecosystem — whether on XbyK or exploring Umbraco/Optimizely — is strong. If the majority point to Contentful, factor in the Salesforce acquisition risk and the full stack cost before committing.

## What does migrating from Kentico to Contentful involve?

There is no off-the-shelf connector that maps a Kentico SQL database to Contentful's API. [Migrating to Contentful](https://clonepartner.com/blog/cms-migration/contentful) requires a **custom ETL pipeline**: extract from Kentico's SQL database, transform content and HTML into Contentful's Rich Text JSON AST, and load entries through the CMA while respecting rate limits and dependency ordering.

### 1. Extract data from Kentico's SQL Server

While Kentico offers a REST API, extracting bulk data via API is often too slow and misses critical metadata. Direct SQL extraction is the reliable path for any dataset above a few hundred records.

To reconstruct a piece of content, you must write queries that join multiple tables: the node structure (`CMS_Tree`), the document properties (`CMS_Document`), and the custom fields from the relevant coupled table. You must also account for version history and workflow states. If you only want published content, your extraction logic must filter out draft versions sitting in `CMS_ObjectVersionHistory` — failing to do so results in unpublished, in-progress, or superseded content appearing in Contentful.

### 2. Transform HTML to Contentful's Rich Text AST

This is the most technically demanding phase — and the one with the highest manual remediation rate. Kentico stores rich text as raw HTML strings. Contentful's Rich Text field rejects raw HTML — it requires a specific JSON AST structure.

A simple bolded paragraph in Kentico:

```html
<p>This is <strong>important</strong> text.</p>
```

Must be parsed and transformed into this exact JSON structure before Contentful will accept it:

```json
{
  "nodeType": "document",
  "data": {},
  "content": [
    {
      "nodeType": "paragraph",
      "content": [
        {
          "nodeType": "text",
          "value": "This is ",
          "marks": [],
          "data": {}
        },
        {
          "nodeType": "text",
          "value": "important",
          "marks": [{"type": "bold"}],
          "data": {}
        },
        {
          "nodeType": "text",
          "value": " text.",
          "marks": [],
          "data": {}
        }
      ],
      "data": {}
    }
  ]
}
```

If a single node type is wrong, or a required `data` object is missing, the CMA throws a validation error and rejects the entire entry. Beyond simple formatting, the AST must also handle hyperlinks (as `hyperlink` nodes with `uri` in the `data` object), inline images (as `embedded-asset-block` nodes referencing the Contentful Asset ID), and embedded content entries (as `embedded-entry-block` or `embedded-entry-inline` nodes). Each node type has a distinct schema requirement.

**Common HTML constructs that require special handling or fail AST conversion entirely:**

| HTML construct | Handling required | Failure mode if ignored |
|---|---|---|
| `<table>` with merged cells (`colspan`/`rowspan`) | Manual restructuring; Contentful's Rich Text does not support merged cells | Entry rejected by CMA validation |
| Inline `style` attributes (e.g., `style="color:red"`) | Strip or convert; Contentful AST has no inline style node | Silently dropped; visual formatting lost |
| `<iframe>` embeds | Convert to Embedded Entry (e.g., a Video content type) | Entry rejected |
| Kentico macros (`{% %}`) | Strip, hardcode, or convert to Embedded Entry | Renders as broken code on frontend |
| Kentico widget markup | Convert to Embedded Entry content type | Entry rejected or widget renders as raw text |
| `<script>` tags | Strip entirely | Entry rejected |
| Nested lists beyond 6 levels | Flatten; Contentful enforces a maximum nesting depth | CMA validation error |
| Non-standard HTML entities | Normalize to Unicode | Entry rejected or character corruption |

The remediation rate for legacy Kentico content depends heavily on editorial practices. Sites that enforced clean HTML through a structured WYSIWYG editor see lower failure rates. Sites where authors pasted directly from Word, used heavily customized widgets, or relied on inline macros for personalization consistently require manual intervention on 15–40% of rich text fields before automated conversion succeeds.

Kentico macros are a distinct problem category. A macro like `{% CurrentUser.Name %}` or `{% Document.DocumentName %}` references runtime context that does not exist in Contentful's model. Each macro type requires a deliberate decision: strip it, replace it with a static default value, or model it as an Embedded Entry that your frontend resolves at render time. There is no automated path — this is a content strategy decision that must be made before the migration pipeline runs.

### 3. Migrate assets and resolve links

Images and attachments in Kentico are stored in the `CMS_Attachment` table (with binaries on the file system or Azure Blob Storage). In Contentful, assets are first-class entities with a strict creation sequence:

1. Download the binary file from Kentico's storage location.
2. Upload the file to Contentful via the CMA to create an Asset record.
3. Call the Asset processing endpoint (triggers CDN ingestion and image transformation setup).
4. Poll for processing completion — this is asynchronous and variable in duration.
5. Publish the Asset.
6. Capture the new Contentful Asset ID.
7. Update any Rich Text ASTs or reference fields in content entries to replace Kentico attachment URLs with the new Contentful Asset ID.

Steps 4 and 7 are where migrations most commonly break. Skipping the processing poll and proceeding to publish before Contentful has finished ingesting the binary results in entries that reference an asset in a broken state. Failing to update Rich Text ASTs after asset IDs are assigned results in content that renders with dead image links. Referential integrity validation — confirming that every Contentful Asset ID referenced in an entry actually exists and is published — must run as a post-migration check before the cutover.

### 4. Load data via the Content Management API

Contentful's CMA enforces strict rate limits — 7–10 requests per second on default plans, with higher limits available on enterprise tiers. If you have 50,000 records in Kentico, and each record requires a create call, a publish call, and several asset processing calls, you will hit HTTP 429 (Too Many Requests) errors quickly without proper throttling. Your ETL pipeline must implement exponential backoff with jitter and intelligent retry logic that differentiates between rate-limit errors (retriable) and validation errors (not retriable without content changes).

**Dependency ordering is non-negotiable.** Contentful will reject an entry that references a content type, asset, or linked entry that does not yet exist. The load sequence must be:
1. Content type schemas (create all types before any entries)
2. Assets (upload, process, publish all before entries reference them)
3. Entries without outbound references
4. Entries with references to already-loaded entries
5. Circular references (require a two-pass approach: create stubs, then patch with references)

For a detailed technical walkthrough of this specific migration path, see our [Kentico to Contentful migration guide](https://clonepartner.com/blog/blog/kentico-to-contentful-migration-a-technical-guide).

## How long does a Kentico to Contentful migration take?

You must keep two clocks entirely separate: the replatforming clock and the data migration clock.

> [!WARNING]
> **Two clocks.** The timelines below describe the data migration effort — extracting, transforming, and loading content. They do not describe the broader replatform effort (rebuilding frontend templates, integrations, editorial workflows, testing), which is a separate project typically measured in months.

**The replatforming clock (months):** Building a new frontend, integrating third-party tools, and configuring Contentful's content models is an engineering project your team or an agency must manage. A full replatform — new frontend framework, content model design, integration wiring, UAT — is, by our estimate rather than any published vendor figure, a matter of 6 to 12 months for a mid-size site.

**The data migration clock (days):** This tracks content extraction, transformation, and loading only. Using automated AST parsers and direct SQL extraction, timelines break down as follows:

- **Small datasets (under 10,000 records):** Under 24 hours for clean content. Add 1–3 days if significant macro or widget remediation is required.
- **Medium datasets (10,000–50,000 records):** Typically 3–5 business days, often scheduled over a weekend to minimize disruption. CMA rate limits are the primary constraint.
- **Enterprise datasets (50,000+ records):** 7–13+ business days. These engagements use an initial bulk migration followed by continuous delta syncs to keep content current until cutover. Contentful's CMA rate limit is the binding constraint — enterprise plan rate limits must be confirmed with Contentful before scoping.

**What extends timelines beyond these ranges:**
- High proportion of macro-dependent rich text requiring manual review decisions
- Many-to-many relationships requiring junction content types not present in the original Kentico model
- Assets stored on legacy file systems rather than Azure Blob Storage (retrieval is slower and less reliable)
- Circular entry references requiring multi-pass loading
- Content requiring legal or editorial review before publication in the new system

Plan to begin scoping at least 3–4 months before your internal deadline or the December 2026 end-of-support date.

## What does the Salesforce acquisition mean for Contentful?

Salesforce signed a definitive agreement to acquire Contentful on June 1, 2026, and completed the acquisition on September 1, 2026, per Salesforce's official press release. The acquisition is reported in the range of $1–1.5 billion based on coverage by TechCrunch and Bloomberg at the time of announcement. Contentful now operates as a Salesforce business unit.

As of late 2026, Contentful's published plans and pricing are unchanged, and it still sells as a standalone platform. The strategic intent is clear: Salesforce plans to integrate Contentful natively across Customer 360 and use it as the content layer for Agentforce, its AI agent platform.

What this means practically:

- **For Salesforce shops:** Tighter CRM-to-content integration is coming. Contentful becomes a natural complement to existing Marketing Cloud and Commerce Cloud investments. Integration surface between Salesforce data objects and Contentful content types will likely expand.
- **For non-Salesforce shops:** The independent product roadmap is now Salesforce's roadmap. Historical precedent from Salesforce acquisitions (ExactTarget → Marketing Cloud, Mulesoft, Tableau) suggests that acquired products gradually shift pricing, packaging, and feature priorities toward parent ecosystem use cases. Teams outside the Salesforce ecosystem should treat this as a 3–5 year risk factor, not an immediate problem.
- **For Kentico teams evaluating Contentful:** The acquisition does not change Contentful's technical capabilities today, but it changes the risk profile of a long-term platform commitment. Teams choosing Contentful primarily for its independence from major cloud ecosystems should weigh this carefully.

## How does Kentico Xperience 13 end of support affect this decision?

Kentico Xperience 13 support ends on December 31, 2026. After that date, Kentico stops providing security patches, hotfixes, and technical support. Your site will not stop working — this is end of *support*, not end of *life* — but every unpatched vulnerability from January 1, 2027 onward becomes your responsibility. The practical risk compounds over time: a vulnerability disclosed in Q1 2027 will have no patch available, and your exposure window has no defined close date.

This creates a forcing function. If you are on KX13, you have three options:

1. **Upgrade to Xperience by Kentico** — stay in the ecosystem, but accept a [full rewrite (not a version bump)](https://clonepartner.com/blog/blog/kentico-13-vs-xperience-by-kentico-architecture-tco-migration). The ASP.NET Core rewrite means templates, content types, and integrations must all be rebuilt. See our [KX13 end-of-support breakdown](https://clonepartner.com/blog/blog/kentico-xperience-13-end-of-support-2026-what-actually-changes).
2. **Migrate to Contentful** (or another headless CMS) — leave the .NET monolith entirely and adopt a composable stack.
3. **Migrate to another DXP** — [Optimizely](https://clonepartner.com/blog/blog/kentico-vs-optimizely-architecture-tco-migration-guide), Sitecore, Umbraco, or others. See our [Kentico alternatives guide](https://clonepartner.com/blog/blog/top-kentico-alternatives-2026-features-migration-tco).

Option 2 is what teams choose when they want to decouple content from rendering and invest in a JavaScript-first frontend. Option 1 is what teams choose when they want vendor continuity and already have .NET expertise. Both options require scoping and execution work that cannot be compressed into the final weeks before December 2026.

## Making the call

Kentico and Contentful are not competing for the same job. Kentico is a DXP that gives you everything in one box at the cost of ecosystem lock-in. Contentful is a content API that gives you maximum flexibility at the cost of assembling the rest of the stack yourself — and now, with Salesforce ownership, a different kind of ecosystem gravity.

The highest technical risk in this transition is the data migration. Specifically:

- **HTML-to-AST conversion failure rate** scales with content quality. Legacy sites with macro-heavy, widget-embedded, or Word-pasted rich text require 15–40% manual remediation before automated conversion succeeds.
- **Referential integrity** — ensuring every asset ID, linked entry, and content type reference resolves correctly after migration — requires explicit post-migration validation, not assumptions.
- **Dependency ordering** during CMA loading is non-negotiable. Attempting to load entries before their referenced assets and content types exist results in validation errors that cascade across the dataset.

If you are deciding between them, start with the decision matrix above. The two highest-weight factors are: (1) your team's primary development language (.NET vs. JavaScript) and (2) whether you want one vendor for CMS + marketing + commerce or a composable stack. Those two questions resolve the majority of cases. The remaining complexity is migration risk, TCO math across the full tool stack, and the long-term implications of the Salesforce acquisition — all of which depend on your specific content volume, editorial workflows, and existing technology investments.

> Migrating from Kentico to Contentful, moving in the other direction, or evaluating alternatives — book a free 30-minute scoping call. We will map out the content model mapping, migration path, timeline, and fixed-price proposal for your specific situation.
>
> [Talk to us](https://clonepartner.com/talk-to-us?duration=30&utm_source=blog&utm_medium=button&utm_campaign=demo_bookings&utm_content=cta_click&utm_term=demo_button_click)

## Frequently asked questions

### What is the main difference between Kentico and Contentful?

Kentico is a full .NET-based digital experience platform that bundles CMS, marketing, and commerce with server-rendered or hybrid-headless delivery. Contentful is a pure headless, API-first CMS that provides structured content through REST and GraphQL APIs with no built-in rendering layer — you bring your own frontend.

### Can you migrate from Kentico to Contentful directly?

There is no off-the-shelf connector. You need a custom ETL pipeline that extracts from Kentico's SQL database, transforms HTML into Contentful's proprietary Rich Text JSON AST format, and loads entries via the CMA while respecting its 7–10 request-per-second rate limit. The Rich Text conversion is the hardest part.

### How long does a Kentico to Contentful data migration take?

The data migration itself typically takes 1–5 business days, depending on volume and API rate limits. Rebuilding your frontend application to work with Contentful is a separate project that usually takes 6–12 months.

### How much does Kentico cost compared to Contentful?

Xperience by Kentico starts at ~$990/month self-managed or ~$1,990/month SaaS. Contentful's Lite plan is $300/month, but real-world enterprise contracts average ~$33K–$148K/year according to Vendr benchmarks. Kentico bundles marketing and commerce; Contentful requires separate tools for those, increasing total stack cost.

### Does the Salesforce acquisition of Contentful affect this decision?

Salesforce completed its acquisition of Contentful on September 1, 2026. As of October 2026, pricing and APIs have not changed. But teams outside the Salesforce ecosystem should consider that the platform's roadmap and priorities will likely tilt toward Salesforce's stack over time.