Replit SEO: get your Replit Agent app on Google

A site built with Replit Agent can show up on Google once it is published on a public deployment, ideally on your own domain. The catch is how most Agent apps are built: a full-stack app with a React front end that renders in the browser, served by a Node server that returns the same HTML shell for every URL. Crawlers get a page with no text and a 200 status even for URLs that don't exist. Fix that first (prerender the public pages and return real 404s), then use Replit's own SEO tools for titles, descriptions, robots.txt and the sitemap. This guide is the Replit-specific follow-up to SEO for AI-built websites.

#What Replit Agent builds and how it's served

Replit's docs say Agent builds a full-stack web app by default and sets up "API routes, a database, and server-side logic" as needed. They don't name the front-end stack. In practice many Agent apps are React + Vite with an Express server (community reports, not a documented default), so open package.json to see yours. How it is served depends on the deployment type:

Every published app gets a your-app.replit.app address. Development URLs on replit.dev are private by default and meant for testing; don't use them for SEO checks. A remixed app may get a different replit.app subdomain, which is one more reason to put the site on your own domain.

#The five-minute diagnosis

1. Curl the published app

   URL=https://your-domain.com/pricing      # or https://your-app.replit.app/pricing
   curl -s $URL | grep -o "<title>[^<]*"
   curl -s $URL | grep -o "<h1[^>]*>[^<]*"
   curl -s -o /dev/null -w "%{http_code}\n" https://your-domain.com/no-such-page

   $ curl -s https://your-app.replit.app/pricing | grep -o "<title>[^<]*"
   <title>My App
   $ curl -s https://your-app.replit.app/pricing | grep -o "<h1[^>]*>[^<]*"
   (no output)
   $ curl -s -o /dev/null -w "%{http_code}" https://your-app.replit.app/no-such-page
   200
   $ curl -s https://your-domain.com/pricing | grep -o "<h1[^>]*>[^<]*"
   <h1>Pricing for tutors
   $ curl -s -o /dev/null -w "%{http_code}" https://your-domain.com/no-such-page
   404
   

2. Check both host names

   curl -sI https://www.your-domain.com/ | grep -iE "^(HTTP|location)"
   curl -sI https://your-app.replit.app/ | grep -iE "^(HTTP|location)"

   Replit connects www and the apex as separate domains, each with its own records, and we found no documented redirect between them or from replit.app. If all of them answer 200 with the same page, you have duplicate hosts. The redirect checker shows the chain.

3. Check robots.txt and the sitemap

   Fetch /robots.txt and /sitemap.xml. If the sitemap URL returns your app's HTML, the server's catch-all route is answering. Use the robots.txt tester, the sitemap validator and the free SEO checker if you'd rather not use a terminal.

4. Read Replit's SEO Rating, with care

   After each publish, Replit runs a Lighthouse audit and shows an SEO Rating for public Autoscale, Reserved VM and Static deployments. Lighthouse loads the page in a browser, so a good score doesn't prove the content is in the server HTML. Trust the curl output for that.

#Fixes, in order of impact

1. Prerender the public pages

The public pages (home, pricing, about, blog) are usually a small part of an Agent app, and their content is known at build time. Render them to HTML during the build and keep the logged-in app as it is. The full prerender code (route list, server entry, script) is in React SEO for Vite apps. A prompt for Agent:

Add a build-time prerender for the public pages (/, /pricing, /about and every /blog post):
render each with renderToString during the build and write its own HTML file with a unique
<title>, meta description and canonical on https://your-domain.com. Write a 404.html with a
noindex tag and a sitemap.xml with the public URLs. The logged-in app under /app stays
client-rendered. Hydrate prerendered pages instead of re-rendering them. Don't change the design.

2. Serve those files, and a real 404

The usual Express setup ends with a catch-all that sends index.html for every path. Replace it so known pages get their own file, the app gets its shell, and everything else gets a 404 status. This works on Express 4 and 5:

import express from "express";
import path from "node:path";
import { pages } from "../src/seo"; // the same route list the prerender uses

const app = express();
const dist = path.resolve("dist");
const known = new Set(pages.map((p) => p.path));

// One host: send www and the replit.app address to your domain.
const OTHER_HOSTS = ["www.your-domain.com", "your-app.replit.app"];
app.use((req, res, next) => {
  if (OTHER_HOSTS.includes(req.hostname)) return res.redirect(301, `https://your-domain.com${req.originalUrl}`);
  next();
});

// ...your API routes here...

app.use(express.static(dist, { index: false, redirect: false })); // JS, CSS, images, robots.txt, sitemap.xml
app.use("/app", (_req, res) => res.sendFile(path.join(dist, "app/index.html"))); // client-only app shell
app.use((req, res) => {
  if (req.method === "GET" && known.has(req.path)) {
    const file = req.path === "/" ? "index.html" : `${req.path.slice(1)}/index.html`;
    return res.sendFile(path.join(dist, file));
  }
  res.status(404).sendFile(path.join(dist, "404.html"));
});

app.listen(Number(process.env.PORT ?? 5000), "0.0.0.0");

3. Put the site on your own domain

Connect a domain from the Domains tool: buy one through Replit or connect one you own. Manual setup means adding the A record and a replit-verify TXT record, which must stay in DNS because Replit uses it to renew SSL. Add www separately with its own records. Replit doesn't support apex CNAMEs or wildcard certificates; on Cloudflare, set the records to DNS only. DNS can take up to 48 hours.

4. Let SEO Agent handle the on-page basics

Replit's SEO Agent, in the Growth pane (paid plans, published apps only), audits robots.txt, the sitemap, links, titles and descriptions, JSON-LD, Open Graph tags, headings and alt text, and turns each finding into a fix you can apply. Replit's SEO guide also suggests telling Agent "optimize my SEO". Its documented checks don't cover rendering, canonical tags or status codes, which is why steps 1 to 3 come first. After it runs, make sure each page's canonical points at your domain and that the sitemap uses the same URLs. Check titles with the SERP preview.

5. Verify the domain in Search Console

Add a Domain property, submit https://your-domain.com/sitemap.xml, and inspect one key URL with the live test to see the HTML Googlebot gets.

#When Static deployment is the better fit

If your site has no backend (a landing page, docs, a blog with build-time content), a Static deployment serves files directly, and Replit's SEO guide calls it the best fit for content-heavy sites. It supports a root 404.html for paths that don't exist, [[deployment.rewrites]] (on the primary domain only), and custom response headers. Scope rewrites to the client-only part of the site so unknown URLs still reach the 404 page. Replit doesn't document redirect rules or the status code of that 404 page for Static deployments, so check it with the not-found curl.

[[deployment.rewrites]]
from = "/app/*"
to = "/app/index.html"

#What you can and can't control

#When to move off Replit, and how

Most apps can stay: with your own server code you control HTML, status codes and redirects. Consider moving if you want build-time rendering in a framework Replit Agent doesn't set up well, a CDN in front of static pages, or a team workflow in your own CI.

1. Sync to GitHub or download a ZIP

   Connect GitHub in the Git pane and turn on auto-sync for two-way syncing, or use Download as zip from the file tree menu. Copies don't include secrets, the database or deployment config, so export those separately.

2. Brief a coding agent in the repo

   This app was built with Replit Agent (React front end, Express server). Before we move
   hosts: make every public route return its H1, title, description and an absolute canonical
   on https://your-domain.com in the server HTML; return 404 for unknown URLs; redirect www to
   the apex with a 301; generate sitemap.xml from the route list. Done when curl against a
   production build shows all of that.

3. Switch DNS last

   Point the domain at the new host only after the checks pass on its preview, then resubmit the sitemap.

In the exported repo, npx serpkin sets up Claude Code, Codex or Cursor, registers the site and runs a first scan. The scan flags pages whose text isn't in the server HTML, and small metadata fixes ship as one "Fix the basics" mission. npx serpkin check <preview-url> compares a preview with production and fails on regressions, which is a useful gate before you switch DNS.