# Bolt.new SEO: what a Bolt site sends to Google, and how to fix it

> Every live bolt.host site we tested sent an empty React shell and 200 for missing pages. How to check yours with curl and fix rendering, 404s and robots.txt.

Source: https://seofix.ai/blog/bolt-new-seo  
Published: 2026-11-16  
Updated: 2026-11-02  
Author: SEOFix Team  
Category: Use cases  
Tags: Technical SEO, AI agents, Guides  
Length: 1,797 words, 8 min read

Bolt.new SEO problems start with what Bolt builds. Bolt's help center doesn't say which framework it generates, so we checked: every live `bolt.host` site we fetched on 2 November 2026 was a Vite + React single-page app. Crawlers get an empty `<div id="root"></div>`, missing pages answer `200`, and on several sites `/sitemap.xml` returned the app's HTML instead of a sitemap. Google can still render the JavaScript, but anything that doesn't run JavaScript sees a blank page. The fix is to prerender your routes at build time, return real 404s, and ship a real sitemap and robots.txt. This guide shows how to check each with `curl`, plus the prompt to give Bolt.

If you're comparing builders, our [Lovable SEO guide](https://seofix.ai/blog/lovable-seo) covers Lovable, which now renders on the server by default. This post covers Bolt only.

## What Bolt's docs say, and what we found

Bolt's [supported technologies page](https://support.bolt.new/concepts/supported-technologies) lists Node.js for the backend and "any JavaScript framework that runs on the frontend." It doesn't name a default. Nothing in the help center covers rendering, sitemaps or 404 handling, so we tested live sites.

We took `bolt.host` hostnames from public certificate logs and fetched each home page with `curl`. Seven answered with a working site. All seven had the same body:

```html
<body>
  <div id="root"></div>
</body>
```

The only other content was a `<script type="module" src="/assets/index-[hash].js">` tag. That's the default Vite React template. Some sites had good `<title>`, description and Open Graph tags in `index.html`, but those are the same on every route because they live in one static file.

Here's what else we saw on the five sites we probed in more detail:

| Check | Result |
| --- | --- |
| Unknown URL (`/this-page-does-not-exist`) | `200`, same HTML shell, on 5 of 5 |
| `/sitemap.xml` | Real XML on 2; the HTML shell with `200 text/html` on 3 |
| `/robots.txt` on `*.bolt.host` | Cloudflare-managed block that disallows GPTBot, ClaudeBot, Google-Extended, CCBot and others, on 5 of 5 |
| Request with Googlebot's user agent | Same empty shell |

The last row has a caveat: a real Googlebot request comes from Google's IP ranges, so a spoofed user agent doesn't prove what Google receives. Use URL Inspection for that (below). But nothing in Bolt's docs mentions bot-only pre-rendering, and we saw no sign of it.

## Check your own Bolt site in two minutes

Run these against your published URL, custom domain or `bolt.host`.

**Is there content in the HTML?**

```bash
curl -s https://yoursite.com/ | grep -o '<div id="root">[^<]*</div>'
curl -s https://yoursite.com/pricing | grep -o '<title>[^<]*</title>'
```

If the first command prints `<div id="root"></div>`, the server sends no content. If the second prints the same title as your home page, every route shares one title.

**Do missing pages return 404?**

```bash
curl -s -o /dev/null -w '%{http_code}\n' https://yoursite.com/no-such-page-123
```

`200` means every typo, deleted page and old URL looks like a real page to Google.

**Are robots.txt and the sitemap real files?**

```bash
curl -s -D - -o /dev/null https://yoursite.com/sitemap.xml | grep -i content-type
curl -s https://yoursite.com/robots.txt | head -40
```

A sitemap served as `text/html` is your app's `index.html`. Search Console will report it as unreadable.

**What Google sees.** In Search Console, run URL Inspection on a page and click **Test live URL**. Google's help says the result shows a [screenshot and the rendered HTML](https://support.google.com/webmasters/answer/9012289) as Google-InspectionTool saw them. If the screenshot shows your content, Google can render the page. That doesn't help ChatGPT, Claude or Perplexity, whose crawlers read the raw HTML (see [do AI crawlers render JavaScript?](https://seofix.ai/blog/do-ai-crawlers-render-javascript)).

## Fix 1: prerender your routes

Google does render JavaScript, but its own docs still say ["server-side or pre-rendering is still a great idea"](https://developers.google.com/search/docs/crawling-indexing/javascript/javascript-seo-basics) because it's faster for users and crawlers and "not all bots can run JavaScript." For a Bolt site, build-time prerendering is the least disruptive change: Bolt hosting still serves static files, but each route's file now contains the page's HTML.

You have two realistic options.

**Option A: keep React, add React Router prerendering.** React Router's framework mode can [pre-render routes at build time](https://reactrouter.com/how-to/pre-rendering) and, with `ssr: false`, outputs plain files for static hosting:

```typescript
// react-router.config.ts
import type { Config } from "@react-router/dev/config";

export default {
  ssr: false,
  // list every public route; add dynamic ones from your data
  prerender: ["/", "/pricing", "/about", "/blog"],
} satisfies Config;
```

Routes you don't list fall back to a client-rendered SPA file, so you can prerender the marketing pages and leave the logged-in app alone. Our React SPA SEO guide walks through moving a Vite app to framework mode one route at a time.

**Option B: build content pages with Astro.** If the site is mostly content (landing pages, a blog, docs), ask Bolt to build it with Astro. Astro's docs say that [by default the whole site is prerendered](https://docs.astro.build/en/guides/on-demand-rendering/) and static HTML is sent to the browser. You can still use React components for interactive parts.

Prompt for Bolt (option A):

```
This is a Vite + React app. Search engines and AI crawlers get an empty
<div id="root"></div>. Migrate routing to React Router framework mode and
prerender these routes at build time with ssr: false: /, /pricing, /about,
/blog and every /blog/:slug. Give each route its own <title>, meta
description and <link rel="canonical"> with the absolute URL, rendered into
the HTML at build time. Keep the design and the logged-in app unchanged.
After building, list the HTML files in the build output.
```

After it publishes, rerun the `curl` checks. Each route should print its own title and real text in the body.

## Fix 2: one title, description and canonical per route

In a plain SPA, `<title>` and the meta tags come from `index.html`, so they're identical everywhere. Client code that sets `document.title` after load fixes the browser tab, not the HTML. Once routes are prerendered, set the head tags per route with the [route module's](https://reactrouter.com/start/framework/route-module) `meta` and `links` exports:

```typescript
// app/routes/pricing.tsx
export function meta() {
  return [
    { title: "Pricing: plans from $9/month | Acme" },
    { name: "description", content: "Compare Acme's three plans..." },
  ];
}

export function links() {
  return [{ rel: "canonical", href: "https://acme.com/pricing" }];
}
```

Use absolute canonical URLs on your custom domain. On the site we checked with a custom domain, the `bolt.host` address still answered `200` with the full app, so the canonical is what tells Google which host to index. Bolt's docs say domain aliases [forward visitors to the primary domain](https://support.bolt.new/bolt-cloud/domains/aliases), "helping with SEO and avoiding duplicate content issues," so connect `www` and any spare domains as aliases rather than as separate sites.

## Fix 3: return real 404s

Every SPA host rewrites unknown paths to `index.html` so client-side routes work on refresh. The side effect is a `200` for every URL, including ones that never existed. Google's HTTP status docs say an empty page or error message answered with `200` is reported as a [soft 404](https://developers.google.com/crawling/docs/troubleshooting/http-status-codes). Bolt's hosting docs don't describe custom status rules, so fix it in the app.

Google's JavaScript guide gives [two options for single-page apps](https://developers.google.com/search/docs/crawling-indexing/javascript/javascript-seo-basics): redirect with JavaScript to a URL the server answers with `404`, or add `<meta name="robots" content="noindex">` to the error view. The second works on any host:

```typescript
// NotFound.tsx, rendered by the catch-all route
export default function NotFound() {
  return (
    <>
      <title>Page not found | Acme</title>
      <meta name="robots" content="noindex" />
      <h1>Page not found</h1>
      <a href="/">Go to the home page</a>
    </>
  );
}
```

React 19 [moves a](https://react.dev/reference/react-dom/components/title) [`<title>`](https://react.dev/reference/react-dom/components/title) [rendered in a component into](https://react.dev/reference/react-dom/components/title) [`<head>`](https://react.dev/reference/react-dom/components/title), and does the same for `<meta>`. With prerendering, you can also emit a static `404.html`; whether Bolt hosting serves it with a `404` status isn't documented, so test with the `curl` command above after publishing. More on the status itself in [soft 404 in Search Console](https://seofix.ai/blog/soft-404-search-console).

## Fix 4: a real sitemap.xml and robots.txt

On three of the five sites, `/sitemap.xml` was the HTML shell. Usually the agent added a `<Route path="/sitemap.xml">` or never created the file. Vite copies anything in `public/` to [the root of the build output as-is](https://vite.dev/guide/assets), so a static file is the reliable fix:

```
public/
  robots.txt
  sitemap.xml
```

```
User-agent: *
Allow: /

Sitemap: https://yoursite.com/sitemap.xml
```

For a site whose pages come from a database, generate `sitemap.xml` in a build script from the same data that feeds the prerender list, so the two never drift apart. Then submit it in Search Console.

### The robots.txt you didn't write

Every `bolt.host` robots.txt we fetched began with a `# BEGIN Cloudflare Managed content` block that disallows a long list of user agents (32 in the copy we counted), among them GPTBot, ClaudeBot, Google-Extended, CCBot, Applebot-Extended, meta-externalagent and Baiduspider, followed by the site's own rules. This is Cloudflare's managed robots.txt, which Cloudflare [prepends to your existing robots.txt](https://developers.cloudflare.com/bots/additional-configurations/managed-robots-txt/). Googlebot and Bingbot are allowed. The one site we checked on its own custom domain had no managed block.

Whether that matters depends on what you want. Many sites block training crawlers on purpose. Blocking Google-Extended doesn't affect Google Search (what Google-Extended controls). If you want the site visible in AI assistants, publish on a custom domain (Bolt says custom domains are [only available for Pro users](https://support.bolt.new/bolt-cloud/hosting)) and check its robots.txt after publishing. Our [GPTBot robots.txt guide](https://seofix.ai/blog/block-gptbot-robots-txt) explains which OpenAI bot does what.

## Fix 5: real links between pages

Agents often build navigation from `<button onClick={() => navigate("/pricing")}>`. Google's link guidance says it can only reliably follow [`<a>`](https://developers.google.com/search/docs/crawling-indexing/links-crawlable) [elements with an](https://developers.google.com/search/docs/crawling-indexing/links-crawlable) [`href`](https://developers.google.com/search/docs/crawling-indexing/links-crawlable). Check the raw HTML of a prerendered page:

```bash
curl -s https://yoursite.com/ | grep -o '<a [^>]*href="[^"]*"' | head -20
```

If your menu items don't show up, ask Bolt to replace click handlers with the router's `Link` component, which renders a normal `<a href>`.

## Publishing settings that affect indexing

Two settings in Bolt decide whether search engines can see the site at all:

- **Public or private.** Bolt's publishing docs say a public site [can be found and listed by search engines](https://support.bolt.new/bolt-cloud/hosting/publish), while a private one can't. Public is the default.
- **Bolt hosting or Netlify.** New projects publish to Bolt hosting by default; you can [switch to Netlify](https://support.bolt.new/integrations/netlify), which Bolt notes can't host a database or backend. Changing host doesn't change what your app renders, so the checks above apply either way.

Pick your final domain before you ask Google to index anything. Moving from `yourapp.bolt.host` to a custom domain later means redirects, a new Search Console property and a wait while Google consolidates signals.

## Where an audit helps

Five `curl` commands cover one page. A Bolt site with a blog or a directory needs the same checks on every URL, grouped by page type. SEOFix audits the raw HTML each URL returns, so on an unrendered Bolt app it will report what non-rendering crawlers get: missing H1s, one shared title, no links. A full audit can also render a sample of pages in headless Chromium and flag content that only exists after JavaScript runs (`JS_DEPENDENT_CONTENT`); [JavaScript rendering checks](https://seofix.ai/help/javascript-rendering) explains the sample. Its AI checks flag a robots.txt that blocks GPTBot, ClaudeBot, PerplexityBot, Google-Extended or CCBot, and they treat an SPA's HTML catch-all at `/llms.txt` as missing ([AI visibility and rendering checks](https://seofix.ai/help/checks-ai-and-rendering)).

## FAQ

### Is Bolt.new good for SEO?

Bolt can produce an SEO-friendly site, but the sites we tested were client-rendered single-page apps with soft 404s. That's workable for Google, weak for every other crawler, and fixable with prerendering. Treat SEO as a requirement in your first prompt, not a later polish step.

### Does Google index Bolt.new sites?

Yes, if the page is public and Google can render it. Google renders JavaScript, so content usually gets indexed. The problems are shared titles, soft 404s and slower discovery of pages linked only through JavaScript. Check individual URLs with URL Inspection.

### Why does my SEO tool say my Bolt pages have no H1 or content?

Most SEO crawlers read the HTML your server returns, and a Bolt SPA returns an empty root `div`. The tool is right about the HTML. Prerender the routes and the warnings go away.

### Should I move my Bolt project to Next.js?

Only if you need per-request server rendering, for example pages built from a database on every visit. For a marketing site or blog, build-time prerendering on Bolt hosting is enough.

Run a full audit of your Bolt site at [seofix.ai](https://seofix.ai/). Your first audit is free (up to 500 pages, no card).
