Skip to content

Lovable, Bolt and v0 SEO: can Google and AI crawlers read your app?

Sites built with Lovable, Bolt or v0 can ship near-empty HTML to crawlers. What each builder documents, how to check your app and which fix fits.

By Crawlito · 7 min read

In short

  • Lovable says apps created from 13 May 2026 use TanStack Start with server-side rendering, while older React and Vite projects get on-request pre-rendering served only to verified crawlers.
  • Bolt hosting publishes single-page apps and Next.js apps, and asks you to build other server-rendering frameworks as static HTML before publishing.
  • v0 documents that new chats start with a Next.js app using shadcn/ui and Tailwind CSS and deploys projects to Vercel.
  • A client-rendered single-page app sends a nearly empty HTML shell, so any crawler that does not run JavaScript sees almost no text.
  • The check is the same for every builder: fetch the page with curl and search the raw HTML for a sentence from the page.
On this page

Apps built with AI app builders are readable by search and AI crawlers only if the HTML the server sends contains the page's text. Many apps from these tools are client-rendered React single-page apps built with Vite, which send a near-empty HTML shell and build the page with JavaScript in the browser. Google can render that, but many AI crawlers do not run JavaScript and see almost nothing. Whether your app has this problem depends on the builder, when the project was created and how it is hosted, so check the raw HTML of your own pages before changing anything.

Below is what Lovable, Bolt and v0 each document at the time of writing, how to test your app, and the fixes in order of effort.

Why AI-built apps often look empty to crawlers

A Vite and React single-page app usually ships HTML like this:

html
<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>Acme</title>
    <script type="module" src="/assets/index-4f2a.js"></script>
  </head>
  <body>
    <div id="root"></div>
  </body>
</html>

Every heading, paragraph and link is created by the script. Google renders JavaScript in a second stage, so it can eventually see the content. Crawlers that read only raw HTML get a title and an empty <div>. Our post on whether AI crawlers run JavaScript covers what each operator documents, and React SPAs and AI crawlers goes deeper into this exact setup.

App builders generate code quickly, and an SPA is the simplest thing to generate and host. That is fine for a logged-in dashboard. It is a problem for marketing pages, pricing, docs and blog posts that you want people to find.

What each builder documents

Product defaults change often, so treat this as a snapshot and confirm against each builder's own docs.

BuilderDefault stack (per its docs)What crawlers get by defaultDocumented SEO support
Lovable, projects from 13 May 2026TanStack Start with server-side renderingFully rendered HTML on each requestSEO and AI search review in the editor
Lovable, older projectsReact and VitePre-rendered HTML for verified crawlers on deployed public URLs; the SPA for everyone elseOptional upgrade to TanStack Start
BoltDepends on the project: SPAs and Next.js publish directlyAn SPA serves its shell; Next.js can render on the serverHosting docs cover publishing, not SEO features
v0Next.js with shadcn/ui and Tailwind CSS, deployed to VercelDepends on how components fetch dataStandard Next.js rendering options

Lovable

Lovable's SEO and AI search documentation says apps created from 13 May 2026 (22 June 2026 on Enterprise plans) use TanStack Start with server-side rendering, so each request returns fully rendered HTML for people and crawlers.

Older React and Vite projects use on-request pre-rendering on deployed public URLs. When a verified crawler arrives, Lovable renders the page and returns the HTML. Lovable names search engines such as Google and Bing and AI search crawlers among the verified crawlers. Unverified bots see the regular single-page app, unless they request a Markdown version of the page, which Lovable serves on both stacks. Lovable also notes that content that loads late may be missing from the pre-rendered version.

Other points from the same page worth knowing:

  • Only publicly published apps can appear in search. Unpublished and restricted projects never do.
  • Lovable creates a robots.txt with every new project, but not always a sitemap, and the starting metadata is generic.
  • An upgrade from React and Vite to TanStack Start is available and optional; Lovable describes it in its upgrade guide.

So the question for an older Lovable app is whether the crawlers you care about are among those Lovable verifies. You cannot see that list from outside, which is one reason to consider the upgrade for public pages.

Bolt

Bolt's hosting documentation says Bolt hosting can publish websites and single-page apps built with React, Vue, Svelte and other frontend frameworks, and Next.js apps, including pages Next.js builds on the server when someone opens them. For other server-rendering frameworks, such as TanStack Start, SvelteKit, Remix or Astro, Bolt asks you to have the project built as static HTML files before publishing. You can also publish to Netlify instead of Bolt hosting.

Bolt's docs also describe a common SPA symptom: pages other than the home page showing "Page not found" after publishing, fixed with a redirect rule to index.html. That fixes visitors, but a crawler then gets the same empty shell for every URL. The guide to SPA routing and 404 status codes explains why that also hides real errors from search engines.

We did not find an SEO-specific rendering feature in Bolt's current help center, so for a Bolt SPA, assume crawlers get the shell unless your raw HTML shows otherwise.

v0

v0's documentation says new chats start with a Next.js app that uses shadcn/ui and Tailwind CSS, and that v0 deploys projects to Vercel. Next.js can render on the server or at build time, which is good for crawlers. It does not do that automatically for every component: a page whose main content is a client component that loads data in the browser still ships little text. The Next.js AI search readiness guide shows how to tell server and client rendering apart in an App Router project.

How to check your app in two minutes

Use a published URL, not the editor preview.

  1. Fetch the raw HTML and count the words a crawler gets:

    bash
    curl -s https://www.example.com/pricing \
      | sed -e 's/<script[^>]*>.*<\/script>//g' -e 's/<[^>]*>/ /g' | wc -w

    A result in the low dozens for a page with hundreds of visible words means the content is built in the browser.

  2. Search for a sentence you can see on the page:

    bash
    curl -s https://www.example.com/pricing | grep -c "Cancel any time"
  3. Repeat with a crawler user-agent, because Lovable's pre-rendering and some hosts treat crawlers differently:

    bash
    curl -s -A "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)" \
      https://www.example.com/pricing | grep -c "Cancel any time"

    A copied user-agent from your own machine is not a verified crawler, so a pre-rendering service that verifies by IP may still send you the SPA. If step 2 fails and step 3 also fails, you cannot tell from here whether verified crawlers get rendered HTML. Server logs showing the real crawler's response size help.

  4. Check titles and canonicals per page. An SPA often has one <title> and one description for every route in the raw HTML.

The general method is in see your page as an AI crawler with curl.

Your options, from least to most work

1. Use the builder's server rendering

If your builder offers a server-rendered stack, that is usually the cleanest route. For Lovable, that means a project on TanStack Start, either new or upgraded. For v0, it means keeping page content in server components or static generation in Next.js.

2. Prerender the public pages

Prerendering generates HTML for each public route, either at build time or on request for crawlers. Build-time prerendering of marketing pages works for any visitor. On-request prerendering served only to bots works too, but depends on correct bot detection and on the snapshot matching what visitors see. The prerendering and dynamic rendering guide explains the trade-offs, and Google describes dynamic rendering as a workaround rather than a long-term solution.

3. Split the marketing site from the app

Keep the generated app for logged-in features, and build the pages people search for, such as home, pricing, features, docs and blog, with a static site generator or a server-rendered framework. The app can live on a subdomain or under a path.

4. Rebuild on a server-rendering framework

If the whole product is public content, such as a directory or a content site, moving to Next.js, Astro or another framework with server or static rendering removes the problem at the source.

Whichever you choose, also fix the basics an SPA tends to miss: a unique <title> and meta description per route in the server HTML, a canonical tag per route, an XML sitemap, real <a href> links between pages and correct 404 status codes.

Frequently asked questions

Is a Lovable site bad for SEO?

Not by default any more. Lovable says new projects use server-side rendering, and older ones get pre-rendered HTML for verified crawlers. Check your own published pages, because the outcome depends on when the project was created and what crawlers you care about.

Does Bolt.new support server-side rendering?

Bolt hosting supports Next.js, including pages rendered on the server. For other server-rendering frameworks, Bolt's docs say to build the project as static HTML before publishing, and plain SPAs are served as SPAs.

Are v0 sites readable by AI crawlers?

v0 starts projects on Next.js, which can send complete HTML. Pages whose content loads in the browser through client components still send little text, so test the raw HTML of each important page.

Can Google index a client-rendered React app?

Usually yes, because Google renders JavaScript, although rendering can be delayed. Many AI crawlers do not render, so for AI search the raw HTML matters more.

Check one page of your app

Run the free check on your most important public page, often the home or pricing page. It shows how much of the page's text reaches an AI crawler in the raw HTML, with no account needed.

Filed under Platform guides. Topics: javascript, rendering, ssr, react, ai-crawlers