Migration
How do you migrate from Kentico Xperience to Sanity?
Short answer
A Kentico Xperience 13 to Sanity migration is a script you write, because Sanity publishes no Kentico importer (Sanity on GitHub, October 2026) and the Kentico Migration Tool targets only Xperience by Kentico (Kentico, October 2026). Export pages, parse Page Builder widget JSON, crawl every URL, and cut over before support ends on 31 December 2026 (Kentico, October 2026).
- Kentico Xperience 13 end of support
- 31 December 2026Security hotfixes only through 2026; from 1 January 2027 no support, including security repairs. The site keeps running.Sources: Kentico (Product Support Lifecycle, End of Support, Not End of the Story)
- Official Sanity importer for Kentico
- None, as of October 2026Sanity's MCP server guides Contentful, WordPress, Strapi and Drupal moves; its migration skill has no Kentico guideSources: Sanity (You'll need a CMS eventually. Let your agent set it up.); Sanity on GitHub (sanity-migration references)
- Where widget content lives
- JSON in CMS_Document.DocumentPageBuilderWidgetsOne database column per page holds every Page Builder widget's configuration, nested in variantsSource: Kentico Docs (Migrate widget data as reusable content)
- Kentico Migration Tool target
- Xperience by Kentico onlyIt reads Kentico Xperience 13, 12 and 11 and writes only to Xperience by Kentico, so it can't export to SanitySource: Kentico on GitHub (Kentico Migration Tool)
Deploi’s call
Move from Kentico Xperience 13 to Sanity when the site is content-led and nobody runs contacts, automation or personalization inside Kentico, and move it in one planned cutover before 31 December 2026 with a script you can rerun. If marketers live in Kentico's marketing tools, upgrade to Xperience by Kentico instead: Sanity replaces the content side only.
MigrateMove from Kentico Xperience 13 to Sanity in one planned cutover when
- Kentico's contacts, automation, email and personalization are unused or already replaced, because Sanity has none of them built in.
- Your import script reruns against live Kentico data until launch, so the content freeze shrinks to the cutover.
- Every live URL is crawled and mapped first, because content tree routing builds URLs from tree position, not from a field you export.
- You can plan one cutover rather than phases, because Kentico stops all support for Kentico Xperience 13 after 31 December 2026 (Kentico, October 2026), so any section left for a later phase runs without security repairs.
StayStay with Kentico, on Xperience by Kentico, while
- Marketers run contacts, automation, email or personalization inside Kentico every week.
- Most pages are Page Builder pages your Kentico developers will keep, so the Kentico Migration Tool can carry them across.
- Page-level permissions are a must and Sanity Enterprise isn't in budget, because custom roles are Enterprise only (Sanity Docs, October 2026).
Should you move from Kentico Xperience 13 to Sanity at all?
Move from Kentico Xperience 13 to Sanity when your site is content-led and nobody runs contacts, automation or personalization inside Kentico. The full decision, including Kentico's own upgrade to Xperience by Kentico, lives in whether to leave Kentico, and for what; the Kentico to Sanity migration plan starts once you've chosen Sanity.
The support date is why the decision can't wait. Kentico Xperience 13 reaches end of support on 31 December 2026, and from 1 January 2027 Kentico stops all support, "including security repairs" (Kentico, Product Support Lifecycle, October 2026). The site keeps running, because Kentico calls it end of support, not end of life (Kentico, End of Support, Not End of the Story, October 2026). So any part of the site still on Kentico Xperience 13 after that date runs without security repairs. On 24 October 2026 that leaves 68 days (Deploi arithmetic from the date above).
The Kentico to Sanity method covers Kentico Xperience 13 only; Kentico 12 and older aren't covered.
Is there an official Kentico importer for Sanity?
No. Sanity publishes no Kentico importer, course, guided path or skill guide as of October 2026. Sanity's MCP (Model Context Protocol) server lists guided migration paths from Contentful, WordPress, Strapi and Drupal only (Sanity blog, October 2026). Sanity Learn's replatforming track has courses for WordPress and Webflow and none for Kentico (Sanity Learn, October 2026). Sanity's migration skill ships source guides for Adobe Experience Manager (AEM), Contentful, Drupal, Markdown, Payload, Strapi, Webflow and WordPress (Sanity on GitHub, references, October 2026).
For a source it doesn't cover, the skill says to adapt the closest pattern: "Monolithic/page-builder systems: start from WordPress, Drupal, Webflow, or AEM" (Sanity on GitHub, sanity-migration skill, October 2026). Sanity calls that skill "agent-scaffolded, not fully automated" (Sanity blog, August releases, October 2026), so you still own the script and the checks; the general content management system (CMS) to Sanity method is the pattern to adapt.
Kentico's own tool doesn't help. The Kentico Migration Tool moves Kentico Xperience 13, 12 and 11 data to Xperience by Kentico and nowhere else (Kentico on GitHub, October 2026). What Sanity's migration tooling does covers the import side you'll use instead.
How do you get content out of Kentico Xperience 13?
You get content out of Kentico Xperience 13 two ways: its built-in REST (Representational State Transfer) service, or the SQL database. The REST service can "read, create, update and delete virtually any object or page within the system" (Kentico Docs, Xperience REST service, October 2026). It's an integration API (application programming interface), not a headless delivery channel; Kentico's own comparison lists "No headless support" for Kentico Xperience 13 (Kentico, Upgrade, October 2026). Read through it and never sync back, because Kentico performs no validation on REST writes (Kentico Docs, Manipulating data using REST, October 2026).
The database holds the Page Builder widgets, which live as JSON in the CMS_Document.DocumentPageBuilderWidgets column (Kentico Docs, Migrate widget data, October 2026). Files hang off GUIDs (globally unique identifiers): most page fields hold the GUID of an attachment object, not the file (Kentico Docs, October 2026).
Build Sanity document IDs from GUIDs, not numeric IDs: Kentico warns that numerical IDs "will not necessarily match" between Kentico Xperience 13 and Xperience by Kentico (Kentico Docs, October 2026), so a GUID is the safer key (Deploi's judgment). Sanity's lesson says reusing a source value keeps the script idempotent, so every rerun updates the same documents (Sanity Learn, Deterministic and consistent IDs, October 2026). Snapshot each extract to disk before you transform it (Sanity's migration skill, October 2026).
How do Kentico page types, the content tree, Page Builder widgets and forms map to Sanity?
Kentico page types map to Sanity document types, and the content tree turns into slugs and references. Kentico Xperience 13 pages are structured pages, Page Builder pages or folders, and it also stores content in module classes, custom tables and media libraries (Kentico Docs, October 2026). Culture versions follow document-level localization.
| Kentico Xperience 13 item | Sanity equivalent | Migration note |
|---|---|---|
| Structured page | A document type per page type | ID from its GUID |
| Page Builder page | page document, page builder array | An object type per widget |
| Folder | A slug prefix | Stores no content |
| Page template, section | Front-end layout code | Not content |
| Widget | Object in the page builder array | Parse the JSON column |
| Form | A form service or API route | Export submissions |
| Media library file | Image or file asset | Keep alt text |
| Page attachment | Asset field on its document | Moves with its page |
| Custom table, module class | A document type | Flat data |
| Category | category document | Pages hold references |
| Culture version | A document per language | Publishes alone |
How do Kentico rich text and Page Builder widgets become Portable Text and page builder blocks?
Kentico rich text becomes Portable Text through htmlToBlocks from @portabletext/block-tools, and each Page Builder widget becomes an object in a Sanity page builder array. htmlToBlocks turns headings, lists and paragraphs into Portable Text blocks by default; images and embeds need custom rules (Sanity Learn, Converting HTML to Portable Text, October 2026). How Portable Text stores rich text explains the target format.
Widgets take parsing. Each widget in the JSON carries a type identifier, such as the sample site's DancingGoat.LandingPage.HeroImage, with its properties nested inside variants (Kentico Docs, Migrate widget data, October 2026). Map each identifier you keep to one Sanity object type, and log every identifier you don't, because each one is a schema decision.
Model meaning, not layout. Kentico's own guide moves the hero widget's text, button text and button target into reusable content and leaves its image and theme in the widget; the guide's finished example also stores the image as a reference (Kentico Docs). A Sanity page builder makes the same choice: objects are easier to query but trapped in their document, while references can be reused and your queries must resolve them (Sanity Docs, page building guide, October 2026). Sanity ships no pre-built blocks, so every widget you keep is a block you define. Building landing pages on Sanity covers the editor side.
What happens to Kentico URLs, alternative URLs and SEO in a move to Sanity?
Kentico URLs survive only if you record them before the content tree goes away, because content tree-based routing builds each URL from the page's position in the tree (Kentico Docs, Content tree-based routing, October 2026). Each ancestor whose page type has the URL feature enabled adds a segment, formed by default from its title, and multilingual sites get a URL for every culture. Kentico Xperience 13 can use custom routing with URL patterns instead; the two schemes are mutually exclusive (Kentico Docs, Implementing routing, October 2026).
Store each page's live path as a slug field in Sanity, since no tree computes it. Alternative URLs make a page available under extra URLs, and Kentico either redirects them to the main URL or serves the page there (Kentico Docs, Implementing routing). Each one becomes a 301 redirect, stored in Sanity and served by your front end or host; any that served content needs a canonical decision first.
Crawl the live site as well as exporting it. Sanity's re-platforming course says the new front end "should not create a new link structure without appropriate redirects" and tells you to crawl every existing page (Sanity Learn, re-platforming course, October 2026). Keeping search engine optimization (SEO) through a move to Sanity covers the redirect map, redirect limits and sitemap dates.
What replaces Kentico's marketing, search, forms and permissions in Sanity?
Sanity covers Kentico's search, permissions and scheduling natively, needs a rebuild for forms and approval steps, and has no marketing suite built in. Contacts, automation, email and personalization stay in other tools, which the leaving-Kentico page treats as the deciding flip. Kentico pages carry workflow and item-level permissions (Kentico Docs, October 2026). GROQ (Graph-Relational Object Queries) match checks a field's tokens for the search terms (Sanity Docs, October 2026), and custom roles are Enterprise only (Sanity Docs, October 2026). What each Sanity role can do and forms on Sanity cover the rebuilds.
| Kentico Xperience 13 feature | In Sanity | Note, as of October 2026 |
|---|---|---|
| Contacts, automation, email | None built in | Keep a marketing platform |
| Personalization, A/B tests | None built in | Front end or a testing tool |
| Site search | GROQ match and score | Or a search service |
| Forms | A form service | Full replacement |
| Item-level permissions | Custom roles | Enterprise only |
| Approval workflow | None finished | Workflows early access; Scheduled drafts on Growth |
| Multi-page launches | Content Releases | Enterprise add-on |
What is the step-by-step plan for a Kentico Xperience 13 to Sanity migration?
A Kentico Xperience 13 to Sanity migration runs in seven steps, and the import script reruns until launch. Because IDs come from Kentico GUIDs (globally unique identifiers), each run updates the same documents, so the content freeze shrinks to the cutover (Sanity Learn, Migrating without downtime, October 2026). Planning cutover and rollback covers launch day.
Migrating Kentico Xperience 13 to Sanity
- Inventory. Count pages by page type and culture, list widget identifiers, crawl live URLs. Owner: developer.
- Model. Define types for what content is; review them with editors. Owner: content lead.
- Extract. Read through REST (Representational State Transfer) or SQL; snapshot each run. Owner: developer.
- Transform. Run
htmlToBlocks, parse widget JSON, log the rest. Owner: developer. - Import. Use
--replace, because an import fails on existing IDs (Sanity Docs, Import data, October 2026). Owner: developer. - Redirect. Map every crawled and alternative URL. Owner: search lead.
- Cut over. Run
sanity documents validate, check old URLs, switch in one move. Owner: developer.
Deploi’s point of view
- Where we disagree
- The usual pitch treats a Kentico exit as a content export. Kentico Xperience 13 keeps its most valuable layout content as widget JSON in one database column and builds its URLs from the content tree, so an export of page fields alone misses both. The other common claim is that a phased move is the safe default. For Kentico Xperience 13 it isn't, because every section you leave for a later phase runs on software with no security repairs after 31 December 2026.
- What we’ve seen
- We load our own content into Sanity with the discipline a Kentico migration needs: fixed document IDs, unpublished drafts first, weak references so import order doesn't matter, and an export to restore from. The first wave of deploi.ca's Shopify data section went in during October 2026 as one package of 406 documents and 159 images, with count checks and a rollback by document ID list. Our view of Kentico rests on its documentation and public sources.
- What we'd tell you to do first
- Before any schema work, get three counts: pages by page type and culture, distinct widget type identifiers in the widget JSON column, and live URLs from a crawl. The first sizes the Sanity plan, the second sizes the page builder, and the third sizes the redirect map. Nothing gets scoped or priced before all three exist.
- Where we would push back
- If someone proposes keeping Kentico Xperience 13 as the editing tool and syncing into Sanity through the REST service, we push back. Kentico performs no validation on REST writes, the software loses security repairs on 1 January 2027, and two systems of record double the editorial work.
When this answer changes
- Sanity adds a Kentico guide to its migration skill or a Kentico path to its MCP server
- Kentico announces extended or paid support for Kentico Xperience 13 after 31 December 2026
- Kentico retires the Kentico Xperience 13 REST service documentation
- Sanity offers custom roles below the Enterprise plan
- Sanity moves Content Releases or Scheduled drafts to a different plan
Sources
Every source opened and checked on 25 October 2026.
- Kentico, Product Support Lifecycle
- Kentico, End of Support, Not End of the Story
- Kentico, Upgrade
- Kentico Docs, Defining website content structure
- Kentico Docs, Page builder development
- Kentico Docs, Migrate widget data as reusable content
- Kentico Docs, Xperience REST service
- Kentico Docs, Manipulating data using REST
- Kentico Docs, Implementing routing
- Kentico Docs, Content tree-based routing
- Kentico Docs, Working with files
- Kentico Docs, Plan your strategy for migrating features
- Kentico on GitHub, Kentico Migration Tool
- Sanity, You'll need a CMS eventually. Let your agent set it up.
- Sanity on GitHub, sanity-migration skill
- Sanity on GitHub, sanity-migration references
- Sanity, What's new in August 2026
- Sanity Learn, Replatforming from a legacy CMS to a Content Operation System
- Sanity Learn, Re-modelling your existing content
- Sanity Learn, Migrating without downtime
- Sanity Learn, Deterministic and consistent IDs
- Sanity Learn, Converting HTML to Portable Text
- Sanity Docs, How to use structured content for page building
- Sanity Docs, Import data
- Sanity Docs, Roles and permissions
- Sanity, Plans that scale with you
- Sanity Docs, Scheduled drafts
- Sanity, Scheduled Drafts: Stop manually publishing content at midnight
- Sanity Docs, Search text content with GROQ
- Sanity Learn, Set up forms, redirects, and sitemap
- Sanity Docs, Localization
- Sanity Docs, How early access works