Make an Angular app readable to AI crawlers
An Angular app that does not server-render sends crawlers an app-root element and the bundles. The text shows up after the browser runs those bundles. AI crawlers that do not run JavaScript stop at app-root. A project that already prerenders or server-renders those routes is not in that group.
Check what AI crawlers see on one of your URLs. The result is the HTML before JavaScript runs, plus any robots.txt block for GPTBot, ClaudeBot, PerplexityBot and Googlebot.
The empty app-root
The default Angular client build bootstraps in the browser. The HTML document contains the component selector, often app-root, and script tags. Until Angular starts, there is no view. Vercel's crawler study found GPTBot, ClaudeBot and PerplexityBot do not execute JavaScript, so they store that document as-is.
Googlebot can render JavaScript later. That does not help the crawlers that never render. If a paragraph is only in the live DOM, it is not in the copy those bots keep. The crawler check counts the words in the response and marks an app shell when the count is under 60 and the HTML contains a framework marker from the analyzer, including ng-version.
The response GPTBot keeps
<html>
<body>
<app-root></app-root>
<script src="main.js" type="module"></script>
</body>
</html>No words in the body
The page after JavaScript runs
<app-root>
<nav><a href="/products">Products</a></nav>
<main>
<h1>The page title</h1>
<p>The words you want cited.</p>
</main>
</app-root>Only a crawler that runs JavaScript gets this
Build-time prerendering
Angular can prerender routes at build time. The build runs the app, writes an HTML file for each route, and the host serves that file. A crawler gets the text without running Angular. This fits routes you know at build time: docs, marketing, a catalog you can list. It does not fit a route whose content is different for every request unless you prerender a public version.
You still have to list the routes or discover them. A parameterized route that was not prerendered falls through to the client shell. Check a real detail URL, not only the one route you prerendered as a demo.
Angular SSR
Angular SSR renders the page on the server for each request, using the same components. The HTML includes the view. Crawlers that skip JavaScript can read it, and people get a faster first paint. It is the option Google's dynamic rendering doc points at when it says to prefer server-side rendering, static rendering or hydration.
SSR means a server. A pure static host that only has the browser bundles cannot run it. Browser-only APIs in constructors also break the server pass. Those are the usual reasons a team turns SSR off and then wonders why ChatGPT sees an empty app-root.
A prerender service, when the build is not moving
If the app is client-rendered and a move to Angular SSR is a project of its own, a rendering service sits in front of crawler user agents. People still get the Angular app. The crawler gets HTML from a browser that did run it. Pagerender is that service. The free week is there so you can compare the empty app-root with the rendered document on your domain.
It does not replace a noindex tag, and it does not bypass a firewall that answers GPTBot with 429. Run the checker first. If the row says challenge, fix the firewall. If the row says allowed and the word count is tiny, the render is the missing piece.
What to check in the Angular project
Look at the build target before you add a service. A project already on the application builder with prerender routes has HTML for those routes. A project whose output is only the browser bundle does not. The network response for a deep link is the proof. If a refresh of /pricing returns app-root and then the view pops in, that URL is client-rendered.
Transfer state and resolvers matter once you turn SSR on. Data the server already fetched should be in the HTML, not requested again only in the browser. If the server renders a spinner and the list arrives from HttpClient after bootstrap, the crawler that skips JavaScript keeps the spinner.
Parameterized routes are the ones teams forget. Prerendering / and /about, then leaving /items/:id as a client fallback, means the pages you wanted in search are still empty. List the detail routes or discover them from the sitemap at build time. Then run the checker on one detail URL, not on the homepage you already fixed.
Guards that wait on the browser, and resolvers that only run in the client, produce the same spinner. If canActivate sends every visitor through a login check that needs localStorage, the server has nothing true to render and the crawler sees the blank guard. Public routes should render without a browser session. Private routes can stay client-only and noindex.
Compare the three costs honestly. Build-time prerender is cheap to host and stale until the next build. Angular SSR is fresh and needs a server. A prerender service is fresh for the crawlers you route to it, and the app users run does not change. Google's dynamic rendering doc, updated December 10, 2025, still calls that service approach a workaround. Use it when the other two are not this quarter's work, and keep the HTML the service returns close to what a person sees. Google says dynamic rendering is not cloaking when the content matches. A page about one thing for people and another for bots is cloaking.
ng-content and delayed views do not help a crawler that never boots Angular. The view is the render. If the template is only an ng-template that a directive stamps in later, the server HTML of a client build does not include it. Prerender and SSR both run that stamp before the document is saved. A client build does not.
Take one URL from the sitemap, fetch it with a Googlebot user agent and with GPTBot, and read both bodies. They should match, and they should contain the H1 you see in the browser with JavaScript off. If Googlebot gets a rendered page because something in front already prerenders for Google, and GPTBot gets app-root, your bot list is incomplete. Add the AI crawlers to the same path, or point them at a service that already knows the list. The product list Pagerender uses is the bot list in the code, and the checker shows the ones it actually requests. A list that only names Googlebot was enough when Googlebot was the only crawler that mattered. It is not enough for the crawlers Vercel measured, which keep the first HTML and do not come back to render.
Common questions
Is Angular Universal the same as prerendering?
Angular SSR renders on the request. Prerendering renders at build time and saves HTML. Both put text in the document. A client-only build does neither. Pick SSR when the page changes per request, and prerender when the page is the same for everyone until the next build.
Do I need this if Google already indexes the app?
Google indexing the URL does not mean GPTBot or PerplexityBot read the view. Those crawlers were measured not running JavaScript. Check the raw HTML before you decide the app is visible. A URL in the Google index can still be an empty app-root to ChatGPT.