Webflow migration, done by our team: pick where your site goes, we move it

Webflow holds 4.4 out of 5 from 996 reviews on G2, so most of its users are happy with it. These are its five most-mentioned complaints, with G2's counts, and what each one means when you're deciding whether to move.

1. 01

   Steep learning curve

   102 mentions

   The Designer works in CSS terms: classes, flexbox, the box model. When editors can't publish without a designer, teams move to an editor they already know (WordPress) or a form-based headless CMS behind Next.js or Astro. Designers who find it too technical go to Framer.

2. 02

   Limited features: CMS depth and ecommerce

   94 mentions

   Bigger sites hit ceilings on collections and store features. Content-heavy sites move their content to a headless CMS behind a framework; stores move to Shopify, the #4 destination in our crawl.

3. 03

   Missing capabilities and slow performance on larger projects

   82 mentions

   On large projects the Designer gets slow and some features are out of reach. Next.js, Astro and Nuxt move that ceiling into your own code: server rendering, static pages, and any integration you can write.

4. 04

   Difficult transition from other platforms

   75 mentions

   This one is about moving onto Webflow, and leaving is no easier: the export leaves the CMS and form handling behind, and the interactions only run on Webflow's own scripts (see the developer guide below). That transition is the part we do for you.

5. 05

   Expensive relative to hand-coding

   68 mentions

   Webflow bills a plan per site plus Workspace seats for the team. Next.js, Astro and WordPress cost nothing to license; you pay for hosting and the build instead.

Topic labels and mention counts are G2's, from 996 Webflow reviews read Oct 28, 2026; each count links to the reviews behind it. No review text is reproduced, and the notes are ours.

TechnologyChecker.io's own engineers rebuild your Webflow site on Next.js or Astro. You get the same site, faster, in code your team owns, with every ranking carried across.

1. 1Estimate and fixed quoteRun the estimate at the top of this page. We check it against your site, list what it couldn't see (interactions, locales, ecommerce), and send a fixed quote within one business day. You pay 50% to start.
2. 2Inventory every URLWe collect every URL from your sitemap, Google Search Console and Webflow's redirect export, record each page's title, description, canonical and structured data, and write the redirect map before any code.
3. 3Capture the designEvery template is captured at four screen widths, and your colours, type scale and spacing are pulled from the Webflow styles into design tokens.
4. 4Rebuild the templatesEngineers rebuild each template and symbol as components on a preview URL, with every pull request reviewed. Interactions are rebuilt and forms reconnected. You review each page as it lands.
5. 5Move the contentCollections come across by script through the Webflow API, rich text, images and references included. Images are downloaded off Webflow's hosting, and content freezes on a date we agree.
6. 6Check every pixel and every URLEach page is compared with its Webflow original at every width, each template is measured for Core Web Vitals, and every old URL is crawled against the new site: status codes, redirects, titles and canonicals.
7. 7Launch, then watchWe switch DNS with you and keep Webflow live until the new site is verified, so rolling back is one DNS change. For 30 days we watch Search Console for 404s and dropped pages; if search traffic falls, we fix the cause free. The second 50% is due once you've signed off.

The same move, for developers doing it in-house: Webflow to Next.js or Astro, in the order that protects your rankings. Code export needs a paid Webflow Workspace plan.

1. 01

   Inventory every URL before you write code

   The URL list is the test plan for the whole move. Merge three sources: the sitemap Webflow generates at /sitemap.xml, the Pages report in Google Search Console (it lists URLs Google knows that the sitemap may not), and Webflow's 301 export from step 2. For each URL, record the status code, title, meta description, canonical, Open Graph image and any JSON-LD from custom code. Collection items live at /{collection-slug}/{item-slug}, so one template can stand behind hundreds of rows.

2. 02

   Export the Webflow code, and know what it leaves out

   On a paid Workspace plan, Export code downloads a ZIP: one HTML file per static page, plus css, js and images folders. Interactions, sliders, tabs and navbars keep working in it, because the bundled JavaScript drives them. Use it as the reference for markup and styles, not as the new codebase. Then export what the ZIP leaves out (Webflow's export guide):

   • CMS content. Collection lists come out empty and collection pages as blank templates. Export each collection to CSV from the CMS panel as a backup; each file covers the locale you're viewing (CSV guide). Step 3 pulls the content properly.
   • Ecommerce products and User Accounts. Both export as CSV.
   • 301 redirects. Site settings → Publishing → 301 redirects → Export. Webflow emails the download link (redirect export guide).
   • Never in any export: form handling, site search, password protection, localized content and code components. Steps 3, 6 and 7 rebuild them.
3. 03

   Pull the CMS through the Webflow Data API

   The CSV is fine for a few small collections. For anything with references, locales or hundreds of items, use the Data API v2: every field comes back typed, and every locale on request. Create a site token with CMS read access (Site settings → Apps & integrations → API access), list the collections with GET /v2/sites/{site_id}/collections, read each one's fields with GET /v2/collections/{collection_id}, then page through the published items, 100 per request:

   TypeScript

   const API = "https://api.webflow.com/v2"
   const headers = { Authorization: `Bearer ${process.env.WEBFLOW_TOKEN}` }
   const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
   
   type Item = {
     id: string
     fieldData: { name: string; slug: string; [field: string]: unknown }
   }
   type Page = { items: Item[]; pagination: { total: number } }
   
   // Every published item in a collection, 100 per request,
   // waiting out the rate limit whenever the API answers 429
   export async function listLiveItems(collectionId: string) {
     const items: Item[] = []
     while (true) {
       const query = `limit=100&offset=${items.length}`
       const res = await fetch(
         `${API}/collections/${collectionId}/items/live?${query}`,
         { headers },
       )
       if (res.status === 429) {
         await sleep(Number(res.headers.get("Retry-After") ?? 60) * 1000)
         continue
       }
       if (!res.ok) throw new Error(`Webflow ${res.status}: ${await res.text()}`)
       const page: Page = await res.json()
       items.push(...page.items)
       if (!page.items.length || items.length >= page.pagination.total) return items
     }
   }

   • Rich text arrives as an HTML string. Convert it to Markdown or MDX, or keep it as HTML, and rewrite the image URLs inside it (step 4).
   • Image fields are objects with a url and alt; multi-image fields are arrays of them. Keep the alt text.
   • Reference and multi-reference fields hold item IDs. Load every collection first, then resolve the IDs to the slugs your new routes use.
   • Option fields hold an option ID; the labels are in the collection's field definitions.
   • On a localized site, pass cmsLocaleId (listed in the Sites response) to read each locale's version.

   The API allows 60 or 120 requests a minute depending on the site plan and answers a 429 with a Retry-After header, which the loop above waits out (rate limits). /items/live returns published items only; use /items to include drafts.

4. 04

   Re-host every image and file

   Every image and file URL in the export, the CSV and the API points at Webflow's asset CDN, and those links stop working once the Webflow project is deleted. Download every asset, including the images inside rich text, put them in your repository or your own storage, and rewrite the URLs as you import. Keep the original files and let next/image or Astro's <Image /> generate the responsive sizes, instead of copying the resized versions Webflow made.

5. 05

   Rebuild the templates as components

   Map each static page to a route and each collection template to one dynamic route: app/blog/[slug]/page.tsx with generateStaticParams in Next.js, src/pages/blog/[slug].astro with getStaticPaths in Astro. Webflow components (symbols) become components with props. Bring Webflow's variables (colours, sizes, fonts) across as CSS custom properties or Tailwind theme values and write each component's styles from them, rather than importing the exported stylesheet, which holds the whole site's classes in one file.

   Mind the direction of the cascade. Webflow designs desktop first: the base breakpoint is desktop, and tablet (991px and below), mobile landscape (767px and below) and mobile portrait (479px and below) override it, while the 1280, 1440 and 1920px breakpoints cascade upward (Webflow's breakpoints). Tailwind is mobile first, so flip each override deliberately rather than copying values across.

6. 06

   Rebuild interactions and forms

   Webflow interactions run on Webflow's own JavaScript and the data attributes in its markup, which is why they work in the export but not inside React or Astro components. Rebuild the simple ones with CSS transitions or scroll-driven animations, and timelines and scroll effects with GSAP or Motion. GSAP has been free for commercial use, every plugin included, since version 3.13 in April 2025 (GSAP's announcement). Put every animation behind a prefers-reduced-motion check.

   Forms need a new handler, because Webflow's form processing doesn't leave Webflow: a Server Action or route handler in Next.js, an Astro Action or API endpoint in Astro, sending to your CRM or inbox, with a honeypot field or Cloudflare Turnstile against spam.

7. 07

   Carry the SEO settings over page by page

   Each Webflow page has its own title, meta description, Open Graph fields and custom head code, and collection templates bind those to CMS fields. Reproduce them exactly from the step 1 inventory: generateMetadata in Next.js, the layout's <head> in Astro, bound to the same fields. Then rebuild the site-wide pieces: the sitemap (app/sitemap.ts, or the @astrojs/sitemap integration), robots.txt, canonical tags, any JSON-LD from custom code, and hreflang tags if the site uses Webflow Localization.

   Keep the URL form identical. Webflow serves paths without a trailing slash and 301s /pricing/ to /pricing. Next.js does the same by default; Astro leaves trailing slashes on prerendered pages to the host, so check your host's setting before launch.

8. 08

   Write the 301 redirects in code

   Combine Webflow's redirect export with every path that changes, then collapse the chains: if /a already redirected to /b and /b now moves to /c, send /a straight to /c. Webflow wildcards put (.*) in the old path and %1 in the new one (Webflow's syntax); rewrite them as path parameters, so /old/(.*) → /new/%1 becomes /old/:path* → /new/:path* in Next.js.

   Next.jsAstro

   // next.config.ts
   import type { NextConfig } from "next"
   // [{ "source": "/old-path", "destination": "/new-path" }, ...]
   import redirects from "./redirects.json"
   
   const nextConfig: NextConfig = {
     async redirects() {
       // permanent: true sends a 308, which Google treats as permanent, like a 301
       return redirects.map(redirect => ({ ...redirect, permanent: true }))
     },
   }
   
   export default nextConfig

   // astro.config.mjs
   import { defineConfig } from "astro/config"
   import vercel from "@astrojs/vercel"
   
   export default defineConfig({
     // Without an adapter, a static build writes redirects as
     // meta-refresh pages with no status code
     adapter: vercel(),
     redirects: {
       "/old-path": "/new-path",
       "/old/[...path]": "/new/[...path]",
     },
   })

   Vercel accepts up to 1,024 redirects in the Next.js config; past that, look paths up in middleware (proxy.ts from Next.js 16) or use your host's bulk redirects (Next.js guide). In Astro, redirects only return a real 301 through an adapter or your host's redirect file (Astro docs).

9. 09

   Test every URL and template before DNS moves

   Deploy to a staging URL and replay the step 1 inventory against it. Every old URL should return 200 at the same path, or a single 301 or 308 to a page that returns 200, with the same title and canonical. Screenshot each template next to its Webflow original at 479, 767, 991 and 1440px wide (Playwright does this in a few lines), and run each template through PageSpeed Insights on mobile. Keep staging out of Google with a noindex header, and check the header is gone on production.

10. 10

    Switch DNS, then watch Search Console

    Point the domain at the new host and keep the Webflow site and plan until the new site is verified, so rolling back is one DNS change. The domain stays the same, so Search Console's Change of Address tool doesn't apply: submit the new sitemap, then check the Pages report and each moved page's queries every week for the first month. Only then remove the domain from Webflow and cancel the plan.

We rebuild Webflow sites onto Next.js and Astro. For the other platforms, here is what carries over and what doesn't, so you can plan the move yourself or brief whoever does it.

• 

  

  Webflow to Next.js

  2,604 in 90 days

  The most common move, and the one we price from your sitemap

  The design is rebuilt as React components, CMS collections move by script into a headless CMS with preview, and every Webflow URL keeps its path or gets a 301. Interactions are rebuilt with GSAP or Motion, since Webflow's run on its own scripts and don't carry into React components.

  Webflow to Next.js migration →
• 

  

  Webflow to Astro

  1,337 in 90 days

  A lighter build for content-heavy marketing sites

  Pages ship as static HTML with no JavaScript unless a component needs it, and collections become content files or a headless CMS. We quote Astro rebuilds by hand: run the estimate at the top of this page, then ask for Astro in your quote request.

  Ask for an Astro quote →
• 

  

  Webflow to WordPress

  1,059 in 90 days

  A CMS editors already know, and a plugin for everything

  CMS items move cleanly: export each collection to CSV and bring it in with a CSV import plugin. Download the images first, because the CSV links them to Webflow's hosting. Layouts and interactions don't move; they are rebuilt as a theme or in a page builder. Recreate Webflow's 301 list with a redirect plugin or at the server. We don't take on WordPress builds.

  WordPress vs Webflow →
• 

  

  Webflow to Shopify

  461 in 90 days

  Usually the store moving, not the whole site

  Sites move to Shopify when their ecommerce outgrows Webflow's. Products export from Webflow as CSV and Shopify imports products from CSV, after the columns are mapped. Marketing pages either move into a Shopify theme or stay on a separate site.

  Shopify profile →
• 

  

  Webflow to Framer

  274 in 90 days

  The designers' move: a canvas with motion built in

  Framer has its own CMS with CSV import, so collections can come across. Layouts and animations are rebuilt in Framer's editor.

  Webflow vs Framer →
• 

  

  Webflow to Squarespace

  149 in 90 days

  Fewer controls in exchange for one all-in-one plan

  Pages are rebuilt in Squarespace's templates; expect to give up custom layouts and interactions.

  Squarespace profile →
• 

  

  Webflow to Nuxt.js

  149 in 90 days

  The Vue side of the same move

  Nuxt is to Vue what Next.js is to React, so the rebuild has the same shape: components, a headless CMS for the collections, and a 301 for every changed URL. Teams that already write Vue pick it.

  Nuxt.js profile →
• 

  

  Webflow to Wix

  107 in 90 days

  The same trade as Squarespace, with a freer editor

  Pages are rebuilt in the Wix editor, and Wix's CMS takes CSV imports for collection items.

  Wix vs Webflow →