How does this differ from server-side rendering or Next.js SSR?

SSR runs on every request to your origin and adds latency for human users. Pre-rendering runs only when a search bot or AI crawler is detected, on demand, on the edge — humans still get your fast client-rendered app. There's no code change to your site; you just point your domain at Wrenda.

How fresh is the rendered HTML?

Pre-rendered HTML is cached in the edge KV for a configurable TTL (default 1 hour). When the cache expires, the next crawler request triggers a fresh render. You can purge the cache for any path manually from the dashboard.

Will Googlebot detect cloaking?

No. Pre-rendering is an officially supported technique — Google's own dynamic-rendering documentation describes the same pattern. We serve the same content humans would see if their browser executed the JavaScript; we just do the execution upstream so the bot doesn't have to.

What pages should I pre-render?

Any URL that depends on client-side JavaScript to display its main content: SPAs, dashboard-style apps with public content, e-commerce product pages with dynamic loading, blog posts hydrated from a headless CMS. Static HTML pages don't need it — they should pass through.

How do I configure render settings?

Per-domain settings let you set device profile (mobile/desktop), viewport size, network-idle wait, max wait time and JavaScript execution toggles. You can also inject custom JS that runs inside the headless browser before capture — for example to strip a cookie overlay out of the crawler snapshot, expand collapsed sections, or trigger lazy-loaded content. These scripts only shape the snapshot served to crawlers; real visitors still see your site as normal and make their own consent choices.

PRE-RENDERING

Full Browser Rendering at the Edge

Q: When do I need pre-rendering?

If your site uses React, Vue, Angular or any client-rendered framework, search bots and AI crawlers may see a near-empty HTML shell instead of your actual content. Pre-rendering executes the JavaScript on a headless browser and serves the fully-rendered HTML to crawlers. Result: every word, link and schema tag is in the source where Googlebot, Bingbot and AI engines can read it.

SPAs, React apps, and JS-heavy sites become instantly readable by search bots. A real headless browser renders your pages into complete HTML -- automatically cached and served at the edge.

Enable Pre-rendering See all features

Works with

GooglebotBingbotGoogle-InspectionToolYandexDuckDuckBotBaiduspider

Render and control every detail

Full browser rendering with per-domain configuration and custom script injection.

Feature 01

Browser Rendering Engine

Wrenda launches a real headless browser at the edge. Your SPA boots, JavaScript executes, APIs resolve, and the fully rendered DOM is captured as static HTML. Every configurable detail -- device type, viewport, wait strategy -- is tunable per domain.

Real Chromium-based browser at 300+ edge locations
Configurable device: mobile (375x812) or desktop (1920x1080)
Wait strategies: networkidle0, networkidle2, domcontentloaded
Adjustable wait time, timeout, and script stripping
Results cached in KV with configurable TTL

Per-domain configuration

{
  "device": "mobile",
  "viewport_width": 375,
  "viewport_height": 812,
  "wait_until": "networkidle2",
  "wait_time": 3000,
  "timeout": 30000,
  "strip_scripts": true
}

Before vs after rendering

What bots see (no pre-rendering)

<div id="root"></div>
<script src="/bundle.js"></script>
<script src="/vendor.chunk.js"></script>
<script src="/app.chunk.js"></script>

<!-- That's it. No content. -->
<!-- Googlebot sees an empty page -->
<!-- Your rankings suffer silently -->

What bots see (with Wrenda)

<!DOCTYPE html>
<html lang="en">
<head>
  <title>Marathon Shoes | AcmeSport</title>
  <meta name="description" content="...">
</head>
<body>
  <h1>Marathon Running Shoes</h1>
  <nav>Home > Shoes > Marathon</nav>
  <div class="product-grid">
    <article class="product-card">
      <h2>Apex Pro</h2>
      <p>Carbon fiber plate, 6.8oz</p>
      <span class="price">$189.99</span>
    </article>
    <!-- Full rendered DOM -->
  </div>
</body>
</html>

Feature 02

Pre-render Scripts -- Custom JS Injection

Strip consent overlays from the snapshot

// Runs inside the headless browser before capture.
// Affects the crawler snapshot only -- real visitors
// still see your banner and make their own choice.
const overlay = document.querySelector(
  '[class*="cookie"], [id*="consent"]'
);
if (overlay) overlay.remove();

Expand collapsed content

// Expand all accordions and details elements
document.querySelectorAll('details')
  .forEach(d => d.open = true);

document.querySelectorAll('[aria-expanded="false"]')
  .forEach(el => el.click());

// Wait for animations to complete
await new Promise(r => setTimeout(r, 500));

Pre-render scripts are custom JavaScript snippets that run inside the headless browser instance before the DOM is captured. They let you shape that snapshot exactly the way you need it -- stripping overlays, expanding hidden content, triggering lazy loads, or removing elements you don't want crawlers to see. They run only in the headless render; they never touch what a real visitor sees or the consent choice that visitor makes.

Common use cases

Consent overlay removal -- Strips cookie overlays from the headless render snapshot so crawlers index the page content -- never affecting real visitors’ consent choices
Accordion Expansion -- Open all collapsed sections so content is visible
Lazy Load Triggers -- Scroll or click to force images and content to load
Element Removal -- Strip chat widgets, modals, or interstitials before capture

Scripts run per domain, in order

Script 1: strip-consent-overlay.js (priority: 1)
Script 2: expand-accordions.js     (priority: 2)
Script 3: remove-chat-widget.js    (priority: 3)

# All execute before DOM capture
# Configurable per domain in dashboard

HOW IT WORKS

Four steps, fully automatic

From bot detection to cached HTML -- the entire pipeline runs at the edge.

Step 01

Search bot detected

Incoming requests are fingerprinted by user agent. Googlebot, Bingbot, Google-InspectionTool, and other traditional crawlers are identified instantly -- human visitors are never affected.

Step 02

Headless browser launches at the edge

A headless Chromium instance spins up on the global edge network. Your page loads with the configured viewport, device emulation, and wait strategy -- exactly as a real browser would render it.

Step 03

Page rendered with scripts

JavaScript executes, APIs resolve, SPAs hydrate. Pre-render scripts run inside that headless browser to strip consent overlays from the snapshot, expand accordions, and trigger lazy loads. The full DOM is captured as clean, static HTML.

Step 04

HTML cached and served

The rendered HTML is cached at the edge with your configured TTL. Subsequent requests for the same URL are served instantly from cache -- no browser needed until the cache expires.

USE CASES

Built for JavaScript-heavy sites

If your site relies on client-side rendering, search bots are missing your content.

SPAs & React Apps

Single-page applications built with React, Vue, Angular, or Svelte render empty divs without JavaScript. Wrenda serves fully hydrated HTML to every crawler.

React, Next.js, Vue, Nuxt, Angular, Svelte
Client-side routing fully resolved
Dynamic imports and code splitting handled

Headless-CMS Blogs & Product Listings

Blogs hydrated from Sanity, Contentful or Strapi, and product listings that load via API. Bots see the complete rendered content, not loading spinners.

API-driven content fully resolved
Category and listing pages rendered as HTML
Paginated and filtered views captured

JS-Heavy Marketing Sites

Marketing sites with animations, carousels, lazy-loaded images, and interactive elements. Every piece of content is visible to crawlers.

Lazy images and videos loaded
Scroll-triggered content captured
Third-party widget content included

LIVE EXAMPLE

Verify it instantly

One curl command. Full rendered HTML with confirmation headers.

pre-render-test.sh
# Request as Googlebot
curl -I -H "User-Agent: Googlebot/2.1" \
  https://yoursite.com/products/shoes

# Response headers
HTTP/2 200
content-type: text/html; charset=utf-8
x-pre-rendered: true
x-crawler-action: pre-render
x-render-device: mobile
x-render-viewport: 375x812
cache-control: public, max-age=3600

# Full rendered HTML body follows
# SPAs fully hydrated, JS executed, scripts applied
<!DOCTYPE html>
<html lang="en">
<head><title>Marathon Shoes | AcmeSport</title></head>
<body>
  <h1>Marathon Running Shoes</h1>
  <div class="product-grid">...</div>
</body>
</html>

<3s

Cold render time

<5ms

Cached response time

300+

Edge locations

FAQ

Pre-Rendering FAQs

How JavaScript-heavy sites get rendered for crawlers without impacting human users.

If your site uses React, Vue, Angular or any client-rendered framework, search bots and AI crawlers may see a near-empty HTML shell instead of your actual content. Pre-rendering executes the JavaScript on a headless browser and serves the fully-rendered HTML to crawlers. Result: every word, link and schema tag is in the source where Googlebot, Bingbot and AI engines can read it.

Get Started

Stop losing rankings to blank pages

Enable pre-rendering in minutes. No SSR migration, no infrastructure changes -- just point your domain and go.

Enable Pre-rendering

14-day free trial -- No credit card required