Migrate Your Squarespace Site to a Static Site

Most Squarespace sites are serving static content — brochure pages, blog posts, portfolios, business information — through a dynamic rendering pipeline. Every time a visitor requests a page, Squarespace’s servers process the request, assemble HTML from templates and a database, inject platform JavaScript, and send the result. This takes 1-2 seconds just for the server to respond, before the browser even begins rendering.

The content is the same for every visitor. There is no personalization, no user login, no dynamic data. Yet Squarespace processes each request as if there were.

A static site eliminates this overhead entirely. The same content gets pre-built into HTML files once, then served directly from CDN edge locations around the world. No server processing. No template assembly. No database queries. The result is a 17x improvement in page load speed — not through optimization tricks, but through a fundamentally different architecture.

This guide covers the technical reasons why static delivery is faster, every practical path from Squarespace to a static site, and the specific situations where static is or is not the right choice.

Why Squarespace is slow (architecturally)

To understand the performance gap, you need to understand what happens when someone visits a Squarespace page.

Squarespace request flow:

Browser sends HTTP request to Squarespace’s servers.
Squarespace’s application server receives the request.
The server queries its database for page content.
The template engine assembles HTML from the template + content data.
Platform JavaScript is injected (analytics, editor hooks, template runtime).
The assembled HTML is sent back to the browser (TTFB: 1-2 seconds).
The browser downloads and executes ~2-5MB of resources (CSS, JavaScript, images, fonts).
The page becomes interactive after the JavaScript executes.

Static site request flow:

Browser sends HTTP request.
The nearest CDN edge server responds with a pre-built HTML file (TTFB: <50ms).
The browser downloads minimal resources (50-200KB).
The page renders.

The HTML content is identical in both cases — the same text, the same images, the same layout. The difference is that the static version was built once during deployment and cached globally. There is no server to wait for, no template to assemble, no database to query.

DebugBear’s independent benchmarks quantify this gap across major website builders:

Platform	Average Mobile Lighthouse Score
Squarespace	31
Wix	53
WordPress	55
Webflow	67
Static sites (Astro, Hugo, etc.)	95-100

Squarespace is not just slow relative to static sites — it is the slowest major website builder tested. The average Largest Contentful Paint of 8.79 seconds on mobile means most Squarespace visitors are staring at an incomplete page for nearly nine seconds on a phone.

The performance metrics that matter

Google’s Core Web Vitals directly influence search rankings. Three metrics matter:

Largest Contentful Paint (LCP): How long until the main content is visible. Google’s threshold: under 2.5 seconds for “good.” Squarespace averages 8.79 seconds — more than 3x over the threshold. Static sites typically deliver under 0.5 seconds.

Interaction to Next Paint (INP): How responsive the page is to user interaction. Static sites with minimal JavaScript score well by default. Squarespace’s heavy JavaScript payload makes pages feel sluggish, especially on mobile devices.

Cumulative Layout Shift (CLS): How much the page layout moves around during loading. Pre-built static HTML has predictable layouts with minimal shift. Squarespace pages can shift as JavaScript loads and rearranges elements.

Moving from Squarespace to static does not just improve user experience — it can directly improve your search engine rankings by moving your Core Web Vitals from “failing” to “good.”

The cost architecture

Squarespace charges monthly for something that could be free. Their pricing has an introductory rate that jumps on renewal:

Plan	Year 1	Years 2+	5-Year Total
Basic	$16/mo	$25/mo	$1,392
Core	$23/mo	$36/mo	$2,004
Plus	$39/mo	$56/mo	$3,156

Static hosting costs on major platforms:

Host	Free Tier Includes	Monthly Cost
Cloudflare Pages	500 builds/mo, unlimited bandwidth	$0
Vercel	100GB bandwidth, auto-deploy from Git	$0
Netlify	100GB bandwidth, 300 build minutes/mo	$0
GitHub Pages	100GB bandwidth, 10 builds/hour	$0

These free tiers handle the traffic volume that 90%+ of Squarespace sites see. You are paying $23-$56/month for dynamic rendering of content that does not change between visitors — rendering that a $0 CDN could serve faster.

What Squarespace gives you on export

Before migrating, understand your export options. Go to Settings → Advanced → Import/Export → Export in Squarespace.

The XML export (WordPress WXR format) includes:

Blog post content, dates, categories, tags
Basic page text
Comments
Image references (URLs to Squarespace’s CDN)

The export does not include:

Design, templates, layouts
Custom CSS or code injection blocks
Downloadable image files (just URLs)
Commerce/product data (separate CSV export needed)
Forms, navigation structure, gallery configurations
Member areas, Acuity Scheduling setup

Critical step before migrating: Copy your custom CSS (Design → Custom CSS) and code injection blocks (Settings → Advanced → Code Injection) to text files. These represent real customization work that the export will miss.

Also: download your images before canceling your Squarespace subscription. The image URLs in the export point to Squarespace’s CDN and will stop working when you cancel.

Static site generators: choosing the right tool

When building a static site, you use a static site generator (SSG) to transform your content (markdown, data files) into finished HTML. The major options:

Astro

Best for most Squarespace migrations. Ships zero JavaScript by default. Built-in content collections for blogs. Supports React, Vue, Svelte components where you need interactivity. Lighthouse scores of 95-100 are typical.

Hugo

The fastest build times of any SSG — builds thousands of pages in seconds. Excellent for large blogs. Uses Go templates, which have a learning curve but are very powerful. A strong choice if you have 200+ blog posts.

11ty (Eleventy)

The most flexible SSG. Works with multiple template languages. Minimal opinions about project structure. Good for developers who want full control over the build process.

Jekyll

The original SSG. Built into GitHub Pages — you can host a Jekyll site on GitHub with zero configuration. Good for simple blogs. Slower build times than Hugo or 11ty for large sites.

Gatsby

React-based SSG with a rich plugin ecosystem. Heavier than Astro (ships React to the browser). Better suited for sites that already have React developers on the team.

For a typical Squarespace migration (marketing site, blog, portfolio), Astro or Hugo are the strongest choices. Astro if you want component-based development with optional interactivity. Hugo if you want maximum build speed and have a content-heavy site.

Six approaches to migrate

1. AI coding agents (Claude Code, Cursor, Windsurf, Cline)

The most practical option for most sites in 2026. AI coding agents can extract your content, scaffold a static site, and handle the bulk of the migration.

Process:

Export Squarespace content as XML.
Save custom CSS and code injection blocks.
Scaffold a project: npm create astro@latest or hugo new site my-site.
Open the project in Claude Code, Cursor, or Windsurf.
Provide the XML file, your site URL, and custom code.
Prompt: “Parse this Squarespace XML export. Extract all blog posts to markdown. Crawl example.com to capture all pages, navigation, and images. Build a static site that matches the current design.”
Iterate. Refine CSS, fix galleries, adjust layouts. Usually 2-4 rounds.
Build and deploy.

Timeline: 2-8 hours for most sites. Larger sites with extensive blogs may take a full day.

Real-world precedent: Cursor’s website, Prefect.io, and numerous client sites have been built or migrated with AI-assisted workflows. The tooling handles static site generation well because the output is standard HTML, CSS, and markdown.

2. AI app builders (Bolt.new, v0.dev, Lovable, Replit Agent)

For non-developers who want a static site without working in a code editor:

Screenshot your Squarespace pages.
Upload screenshots to Bolt.new or v0.dev with the prompt: “Recreate this page as a static site.”
Download the generated code.
Add your actual content (from the XML export or manually).
Deploy to a static host.

Good for design replication. Content migration still needs to be handled separately.

3. The WordPress bridge

Squarespace exports in WordPress XML format. For large blog archives:

Import XML into a temporary WordPress installation.
Use wordpress-export-to-markdown to convert all posts to markdown.
Use the markdown files in your static site generator of choice.

This extra step leverages WordPress’s mature import tooling, which handles edge cases (embedded media, HTML formatting, categories) better than most direct XML parsers.

4. Hire a developer or agency

Professional migration costs:

Freelancers: $1,000-$5,000 depending on site size.
Agencies: $5,000-$25,000 for complex sites.

When hiring, verify they handle: image migration, URL redirects for SEO continuity, blog content conversion, deployment pipeline setup, and documentation for your team’s ongoing editing workflow.

5. BrowserCat Migrate

BrowserCat Migrate automates the extraction and static site generation, delivering a deployed site and source code in a GitHub repo. One option among the approaches here, starting at $49.

6. Manual DIY

Full hands-on control:

Export XML from Squarespace.
Pick an SSG (Astro, Hugo, 11ty).
Parse the XML to extract blog posts to markdown.
Screenshot pages for design reference.
Build page templates and components.
Download all images from the media library.
Configure redirects for SEO.
Deploy to a free static host.

Timeline: 1-4 weeks depending on experience and site size.

Squarespace-specific migration details

Squarespace 7.0 vs 7.1

Squarespace runs two different template systems. Check yours at Help → Squarespace Version. Version 7.0 uses named templates (Brine, Bedford, Pacific) with template-specific features and limitations. Version 7.1 uses a universal section-based system. The migration approach differs slightly because 7.0 template-specific behaviors (certain gallery layouts, index pages) may need special attention.

Image handling

Squarespace serves images through its CDN with automatic resizing and format conversion. Your exported XML contains URLs like images.squarespace-cdn.com/content/.... These URLs will stop working when you cancel your subscription.

Download strategy: Use the Squarespace media library (Assets panel) to download images manually. For large sites, extract all image URLs from the XML and use a download script. You can also use wget or curl to batch-download from the CDN URLs while your subscription is still active.

For your static site, use the SSG’s image optimization features. Astro has a built-in <Image> component that handles format conversion and responsive sizes. Hugo has image processing built into its templating. This replaces the automatic resizing that Squarespace provides.

Commerce data

Squarespace Commerce data is not in the XML export. You need a separate CSV export for products. If e-commerce is central to your business, a pure static site may not be the right target. Consider:

Shopify for the commerce layer, with a static marketing site alongside it.
Snipcart or similar tools that add e-commerce to static sites.
Next.js instead of a pure static SSG (see our Next.js migration guide).

Forms

Squarespace forms do not export. Document your form fields, notification settings, and any automation before migrating. For static sites, form handling options include:

Netlify Forms: Built into Netlify, no backend needed.
Formspree: Works with any host, free tier available.
Getform: Similar to Formspree with more integrations.
Custom: A serverless function on Cloudflare Workers or AWS Lambda.

URL structure and SEO

Squarespace uses URL patterns like /blog/post-title and /page-name. Map these to your static site’s URL structure. Configure 301 redirects for any URLs that change. This is critical — losing inbound links directly hurts search rankings.

Most static hosts support redirect configuration files:

Vercel: vercel.json
Netlify: _redirects file
Cloudflare Pages: _redirects file

Domain transfer

If your domain is registered through Squarespace, transfer it to another registrar (Cloudflare Registrar is popular for its at-cost pricing). Plan for 5-7 days for the transfer to complete. Update DNS to point to your new host.

The CDN edge delivery advantage

The core reason static sites are fast is edge delivery. Major static hosting providers operate CDN networks with hundreds of edge locations worldwide:

Cloudflare: 300+ cities in 100+ countries
Vercel: Edge network via AWS CloudFront
Netlify: CDN via multiple providers

When someone in Tokyo visits your static site, they get the HTML from a server in Tokyo. When someone in London visits, they get it from London. The file is already built and cached at every edge location. Response time is determined by physical distance to the nearest CDN node — typically 10-50 milliseconds.

Squarespace does not offer this. Every request goes to Squarespace’s infrastructure, gets processed, and the response travels back. Even with caching, the TTFB is consistently 1-2 seconds because the platform adds overhead that pure file serving does not have.

When static is NOT the right choice

Be honest about whether a pure static architecture fits your needs:

Active e-commerce with inventory and checkout. Static sites can integrate with third-party commerce (Snipcart, Shopify Buy Button), but if commerce is your core business, a dedicated platform is usually better.
Member areas with authentication. If you use Squarespace’s member areas, you need a solution that handles auth. This is possible with static + serverless, but it adds complexity.
Real-time features. Live chat, real-time data, user dashboards — these need a server component. Static sites can integrate with third-party services, but the architecture is not purely static anymore.
Frequent content updates by non-technical users. Static sites can use headless CMS tools (Decap CMS, Sanity, Contentful) for a visual editing experience, but this is an extra layer to set up. If your team truly needs a visual editor and will not adopt a text-based workflow, factor in the CMS setup as part of the migration.
Tight Acuity Scheduling integration. Squarespace owns Acuity and the integration is seamless. You can embed Acuity on a static site, but it will not be the same experience.

If your Squarespace site is a marketing page, blog, portfolio, restaurant site, professional services site, or any other content site where every visitor sees the same thing — static is the right architecture.

Life after migration: the daily workflow

The biggest adjustment is how you edit content. On Squarespace, you use a visual editor. On a static site, you have several options:

Markdown editing. Blog posts and content pages are markdown files. Edit them in any text editor, commit to Git, and the site auto-deploys. This is the simplest workflow and works well for technical users.

AI agents. Tell Claude Code or Cursor what to change: “Add a new blog post about our holiday hours” or “Update the phone number in the footer.” The agent makes the edit, you review and commit.

Headless CMS. For a visual editing experience similar to Squarespace, add a Git-based CMS like Decap CMS. It provides a web interface for creating and editing content, and commits changes to your repo automatically.

GitHub web editor. For quick text changes, edit files directly on github.com. The deploy triggers automatically.

The tradeoff is real: Squarespace’s visual editor is more intuitive for non-technical users making layout changes. But for content changes (the most common type), markdown editing or AI agents are faster. And the performance, cost, and ownership benefits are permanent.

Getting started

The first step requires no commitment and no risk. Export your Squarespace content: Settings → Advanced → Import/Export → Export. Save the XML file. Copy your custom CSS and code injection blocks. Download your images.

Your Squarespace site continues running normally. You can build the static replacement in parallel, compare the two, and switch over when you are confident in the result. The migration is not a leap of faith — it is a side-by-side comparison where you see the speed difference firsthand before committing.