Book a call

Migration

Webflow to custom code

Pages are written again as components, CMS content leaves as CSV or through Webflow’s API, and a permanent redirect for each changed URL protects search.

Trusted by teams from pre-seed to the S&P 100

  • Morse Micro
  • Lumos
  • Superpower
  • Managed
  • Keeyu
  • Crimson Education
  • Trusst AI
  • Kaizn
  • Everlab
  • Startmate

What moves, and what gets rebuilt

Each part of the site, what it becomes, and whether it comes across, needs converting or is rebuilt.

On WebflowOn custom code
  1. WebflowCollection items, exported as CSV one Collection at a time or read through the API

    CMS contentNeeds converting

    custom codeMarkdown or JSON files in the repository, or entries in a CMS your editors use

  2. WebflowStatic pages and Collection templates built in the Designer

    Pages and layoutRebuilt

    custom codeComponents and routes written in Next.js, with the code export kept as a reference

  3. WebflowAssets panel files, and CMS images held as Webflow-hosted URLs

    Images and filesNeeds converting

    custom codeFiles downloaded into the project or a media store before Webflow is switched off

  4. WebflowScroll, hover, click and page-load animations set up in the Designer

    InteractionsRebuilt

    custom codeCSS transitions or an animation library, written into each component

  5. WebflowForm blocks that Webflow processes and emails, and the search page at /search

    Forms and site searchRebuilt

    custom codeA form handler that sends entries to email or the CRM; search added as a service, or dropped

  6. WebflowTitles and descriptions per page and template, the sitemap switch and the canonical URL

    Search settingsNeeds converting

    custom codeMetadata written in each route, and sitemap and robots files generated from the code

  7. WebflowStatic page paths, Collection items under their Collection URL, redirects in Site settings

    URLs and redirectsNeeds converting

    custom codeRoutes written to the same paths, the old redirects carried over, a permanent redirect per change

  8. WebflowYour domain, pointed at Webflow’s hosting

    DomainComes across

    custom codeThe same domain, pointed at the new host on launch day

Moving from Webflow to custom code, step by step

What the code export and the CMS export give you, where the content goes, whether Webflow can stay as the CMS, the redirects, the checks, and who should stay.

Why teams move from Webflow to custom code

Custom code here means a site written by developers in a framework such as Next.js or Nuxt, kept in a code repository and deployed to a host the team chooses.

The usual reason for this move is the product. The marketing site has to share components with the app, sit behind the same login, or show data the product holds, such as live pricing, a customer’s account or a directory built from the product’s database. Webflow’s custom code fields can hold a script, but a site that has to import the product’s own components and call its API belongs in the same kind of codebase as the product.

The second reason is that developers already own the site. If every change goes through an engineer anyway, Webflow seats and the Designer add a step, and the team would sooner review changes in pull requests.

Some reasons are not enough. Moving will not lift rankings, and Webflow sites are quick out of the box, so speed is rarely the gain. A design refresh can be done in Webflow. And if marketing publishes every week, the move takes that away from them until a CMS is in place.

Webflow vs custom code

What Webflow lets out, and what Next.js takes in

Webflow has two ways out, and you need both. The first is code export, on paid Workspace plans only; a Site plan alone does not include it. The ZIP holds an HTML file for every page, including the Collection templates, a CSS folder with three stylesheets (your site’s styles, Webflow’s base styles and normalize.css), a JS folder that drives interactions, sliders, tabs and the navbar, and an images folder with everything in the Assets panel.

The export leaves out the CMS: Collection lists show their empty state and template pages have no content. Form processing, reCAPTCHA, site search, password protection, Ecommerce, code components and every locale but the primary one are missing too. Forms on an exported site need a third-party tool to collect entries.

So the markup is a reference. Its class names and CSS show developers the spacing, type and breakpoints, but its structure is Webflow’s, and a Next.js site is built from components. We write the pages again and copy values from the export where they help. Where the product team wants Webflow’s components in React, Webflow’s DevLink exports them as React components, with a small interactions engine. It needs a paid plan and does not carry page or site custom code.

The second way out is the CMS. Each Collection exports as its own CSV, archived items included, in the locale you are viewing. Rich text comes out as HTML, references as text, multi-references as a comma-separated list, and images and files as Webflow-hosted URLs. Webflow warns that those URLs break if the site is deleted, images inside rich text included, so download every one. The other route is Webflow’s REST API, which a script can page through, 100 published items a request.

Next.js takes whatever the developer writes a loader for. It has no import screen.

How Webflow Collections map to code

Decide first where the content will live. There are three homes: files in the repository (Markdown or JSON), a CMS your editors use, or Webflow itself, read through its API. This site keeps its content the first way: it is Nuxt on Vercel, with the content in the code and no CMS. That suits a team where the people who change the site write code. Then map each Webflow structure:

  • Each Collection becomes a content type: a folder of files, a model in the CMS, or a typed query against the API.
  • Name and Slug become the title and the slug, and the slug decides the URL, so keep it exactly.
  • Rich text arrives as HTML. Keep it as HTML, or convert it to Markdown and check the headings, embeds and links survive.
  • Image and multi-image fields arrive as Webflow URLs. Download the files, store them in the project or a media store, and rewrite the URLs.
  • Reference fields arrive as text naming the other item. Map them to that item’s slug. Multi-references arrive comma-separated, so check any item whose name has a comma in it.
  • Each Collection template becomes one dynamic route, such as app/blog/[slug]/page.tsx in Next.js.
  • Static pages become routes, and the parts they repeat (headers, cards, calls to action) become components.

The API returns published items only, and a full CSV export includes archived ones, so decide which items to keep before you load them.

What a CMS is

Keeping Webflow as the CMS

Webflow can stay as the CMS behind a coded front end. Its Data API lists a Collection’s published items, up to 100 per request, each with its name, slug and fields. For a site that reads content as visitors arrive, Webflow points you to its Content Delivery API instead. Webflow’s webhooks can tell your build when an item changes, so pages can be rebuilt on publish.

The case for it: editors keep the screens they know, the Collections and their content stay put, and the move becomes a front-end rebuild with no content migration. The costs: you keep a Webflow site and a seat for everyone who edits, the Collection limits still apply, the API has a per-minute rate limit set by plan, and the developer has to handle anything Webflow puts in rich text, including components, which the API sends as wf-component markup.

It suits a team that wants the product link now and is happy with its editing workflow. If editors already struggle with Webflow’s CMS, moving to files or another CMS during the rebuild saves doing the work twice.

The order of work

We run the move in this order, and it holds if you are doing it yourself:

  • Inventory. Take every URL from the Webflow sitemap at /sitemap.xml (switch it on in Site settings if it is off), add pages with visits or links from analytics and Search Console, and export the existing redirects as CSV from Site settings.
  • Redirect map. Write the new path beside each old one. In Next.js most can be the same, so the map is mostly a list of routes to recreate.
  • Content model. Choose files, a CMS or Webflow’s API, write the types, and pull one Collection end to end before the rest.
  • Rebuild. Write the components and routes, using the code export as a reference, and list every interaction and form so none is missed.
  • Content. Export or fetch every Collection, download every image and file, and rewrite the URLs to the new copies.
  • Checks. Set metadata, the canonical base, the sitemap and robots files, then test forms, internal links and redirects on a preview deployment.
  • Launch. Point the domain at the new host, deploy with the redirects in place, and submit the new sitemap in Search Console.
  • Watch. Read Search Console’s not found report and the traffic to the old top pages for weeks after launch, and add redirects for anything the map missed. Keep the Webflow site until then.

How we run a website project

Checks before you switch the domain

Go through these on the preview deployment, and the redirect checks again on the live domain:

  • Each Collection has as many items in the new site as published items in Webflow.
  • A search of the code and content for the Webflow asset domain finds nothing: every image and file loads from the new host.
  • Every route from the inventory answers 200 at its old path, or redirects to its new one in one hop.
  • The redirects carried over from Webflow’s Site settings are all in the config, and no rule’s source is a path a new page now uses, since Next.js would redirect it before the page loads.
  • Every page has its own title and description, and the canonical tag uses the live domain with https://.
  • The sitemap lists every page at its final URL and nothing that redirects.
  • robots.txt allows the site, and no preview noindex has reached production.
  • Each form sends a test entry to the inbox or the CRM it should, with spam protection on.
  • Every interaction on the list works, and respects reduced motion where it moves a lot.
  • Analytics and tag scripts are loaded and recording visits.
  • Webflow form submissions are downloaded as CSV from Site settings, Forms, and the code export and CMS CSVs are saved somewhere you control.
  • A rollback to the previous deployment has been tried, so you know it works on launch day.

B2B website redesign checklist

When to stay on Webflow

Stay on Webflow if any of these is true:

  • Marketing publishes without a developer and wants to keep doing so. A coded site needs a CMS set up for that, and someone to look after it.
  • No developer will own the site after launch. Webflow hosts and patches it and issues the certificate; on a coded site the application, its dependencies and the framework upgrades are yours.
  • The product needs one app on the site, such as a calculator or a signup flow. Webflow Cloud hosts a Next.js app at a path under the Webflow site’s domain, and the rest of the site stays where it is.
  • The goal is shared components. DevLink can export the site’s Webflow components to React for the product to use, without moving the site.
  • The reason is speed or search. Webflow renders and hosts pages well, and a move puts every URL at risk for a while.
  • The reason is the design. A redesign can be built in Webflow.
  • The launch is weeks away. A coded site takes longer to start.

Move when the site has to share a login, data or a large part of its code with the product, and developers will own it.

Webflow vs custom code

What decides the time and the cost

Every page is written again, so the number of distinct layouts decides most of the time. A site whose pages share a handful of templates builds faster than one where each page was laid out by hand in the Designer. Interactions add to it, because each one is rebuilt by hand in the new components.

The content route comes next. Files in the code are the quickest to set up. A new CMS adds the model, the editing screens and the integration. Webflow kept as the CMS skips the content move and adds API work, a build that reacts to publishing, and handling rich text. Forms, search and any connection to the product or a CRM add their own work.

Our websites start from $15,000, and most take four to eight weeks. A migration is priced as a website project, on the page system, content work, integrations, publishing requirements and migration complexity, and we agree the scope and the price before we start.

If you do the move yourself, the running costs are the host, any CMS, and developer time for the upgrades each framework publishes on its support schedule. Keep the Webflow plan until the watch period ends.

What a B2B website costsPricingFramer to custom code

Vendor details were checked against the documentation published by Webflow, Next.js, Nuxt and Vercel on 15 November 2026. Plans, limits and APIs change, so read theirs before you start.

Moving from Webflow?

Short answers, from the guide above.

  1. Not directly. On a paid Workspace plan Webflow exports a ZIP of HTML, CSS, JavaScript and images. Collection lists in it are empty, and forms and site search stop working. It is useful as a reference for layout and styles, and the pages are then written again as Next.js components. Webflow’s DevLink can turn Webflow components into React components, which helps where the design system is shared.

  2. Yes. Webflow’s REST APIs return a Collection’s published items, up to 100 a request, and its webhooks report changes, so a Next.js site can read the CMS and rebuild pages when content is published. Your editors keep working in Webflow, each with a seat, and the Collections keep their limits. You also keep two systems to look after.

  3. Some movement is likely, and no one can guarantee positions. We inventory valuable URLs, plan redirects and check canonicals, indexability, content and internal links, then monitor after launch. In Next.js the developer can put every page back at its old path, so few redirects are needed. Changed paths get a permanent redirect, which Next.js sends as a 308. A dip in the first weeks is normal.

  4. Most of our website builds take four to eight weeks, and a migration is scoped as a website project. Every page is written again, so the number of distinct layouts and interactions decides most of it. Where the content goes matters next: files in the code are quickest, and a new CMS or Webflow kept as the CMS adds modelling and integration work.

  5. That depends on where the content lives. If it is in the code, a developer changes it and deploys. If it is in a CMS, editors work there and the site reads from it. If Webflow stays as the CMS, editors keep their Webflow seats. Decide this before the build starts, because it shapes the content model and the work.

Planning this move?

Tell us where it is now and where it is going. We’ll say what we’d keep, what we’d rebuild and how long it takes.

Most teams start with a call, then a sprint or an audit.

Book a call
  • Angus
  • James
  • Naiya
  • Lilian
  • Luca
  • Minh
  • Jorge
  • Toffee

The people you’d work with, from the first call to launch