ClawEngine.ai

By capability · JS rendering API

JavaScript Rendering API to Render and Crawl JavaScript Websites

The short answer

A JavaScript rendering API loads a page in a real browser, waits for the client-side JavaScript to build the content, and only then extracts the result, so you get the fully built page instead of an empty HTML shell. ClawEngine renders and crawls JavaScript websites in one call and returns clean markdown or typed JSON, with no headless browser fleet to run yourself. It renders public, permitted pages only and respects robots.txt.

Clean markdown & JSON · JavaScript rendered · robots.txt respected

Last updated August 2026

Live Extraction
GET
try:

Hit Extract to turn this page into clean, LLM-ready data.

robots.txt respected · public data only

Markdown · JSON · structured fields, from one API call. Crawling, rendering and extracting ...

Many modern sites send almost no content in their initial HTML, the page is built in the browser by JavaScript. A crawler that only reads raw HTML gets an empty shell. ClawEngine is a JavaScript rendering API: it loads each page in a real browser environment, waits for the content to build, and only then extracts clean markdown or structured JSON.

That means single-page apps, infinite-scroll listings and client-rendered content come back complete. You get the rendered result without running or scaling a headless browser yourself. ClawEngine renders only public, permitted pages, respects robots.txt and site Terms of Service, and honors crawl-delay, so crawling JavaScript sites stays compliant.

CRAWL RENDER JS EXTRACT MARKDOWN JSON

Any URL in LLM-ready data out

robots.txt respected public data only

Why it works

What you get with JS rendering API

Real browser rendering

Pages load in a real browser environment and ClawEngine waits for content to build, so client-rendered sites come back complete, not empty.

Dynamic content captured

Single-page apps and scripted listings are fully rendered before extraction, so the data users see is the data you get.

No headless fleet

Rendering runs inside the API, so you skip provisioning, scaling and patching a headless browser cluster just to read modern pages.

What it handles

Any URL in, clean structured data out

Point ClawEngine at a public page and it crawls, renders the JavaScript and extracts clean markdown or typed JSON in one call. Define a schema for structured fields, and respect robots.txt and Terms of Service by default.

  • Loads pages in a real browser environment
  • Waits for JavaScript content to build
  • Scrapes single-page apps completely
  • Returns clean markdown or JSON
  • Removes the need to run a headless fleet
  • Stays on public, permitted pages only
POST /v1/extract extraction result
200 · JSON
{
  "url": "https://example.com/products/atlas",
  "title": "Atlas Field Notebook",
  "markdown": "# Atlas Field Notebook\n\nDurable...",
  "data": {
    "name": "Atlas Field Notebook",
    "price": 24.00,
    "currency": "USD",
    "rating": 4.7
  },
  "links": [ "/products", "/cart" ],
  "metadata": { "rendered": true }
}
JS rendered · boilerplate stripped ✓ robots.txt respected

Why ClawEngine

One API that crawls, renders and extracts

Not a raw HTML dump, not a headless browser fleet to run, and not a brittle parser to maintain. One call crawls a public page, renders its JavaScript and returns clean markdown or typed JSON, built for RAG pipelines and AI agents.

LLM-ready output

Clean markdown or typed JSON with the boilerplate stripped, so the data drops straight into a vector store, a prompt or an agent without a cleanup step.

JavaScript rendered

Each page loads in a real browser environment before extraction, so single-page apps and client-rendered content come back complete, not as an empty shell.

Compliance-first

ClawEngine works on public, permitted data only. It respects robots.txt and site Terms of Service and honors crawl-delay, so responsible scraping is the default.

Code examples

Render one page, then crawl a whole JavaScript site

Rendering is a per-request flag, not a global setting, because most sites are mixed: the docs and blog are server-rendered while the app is not. The pattern that keeps the bill down is to fetch cheap first and fall back to rendering only when the content is genuinely missing.

curl Render a single-page app and get clean markdown
curl https://api.clawengine.ai/v1/extract \
  -H "Authorization: Bearer $CLAWENGINE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://app.example.com/products",
    "render": true,
    "format": "markdown"
  }'
python Fetch first, render only on a miss
import os, requests

API = "https://api.clawengine.ai/v1/extract"
HEADERS = {"Authorization": f"Bearer {os.environ['CLAWENGINE_API_KEY']}"}

def get_page(url, min_chars=400):
    """Try the cheap path first. A near-empty body means the page
    was built client-side, so retry once with rendering on."""
    plain = requests.post(
        API, headers=HEADERS,
        json={"url": url, "render": False, "format": "markdown"},
        timeout=60,
    ).json()

    if len(plain.get("markdown", "").strip()) >= min_chars:
        return plain, False

    rendered = requests.post(
        API, headers=HEADERS,
        json={"url": url, "render": True, "format": "markdown"},
        timeout=120,
    ).json()
    return rendered, True

page, did_render = get_page("https://app.example.com/products")
print(f"rendered={did_render} chars={len(page['markdown'])}")
python Crawl a client-rendered site into typed JSON
import os, requests

# On a client-rendered site the navigation itself is built by JavaScript,
# so the crawler has to render each page BEFORE it can discover links.
job = requests.post(
    "https://api.clawengine.ai/v1/crawl",
    headers={"Authorization": f"Bearer {os.environ['CLAWENGINE_API_KEY']}"},
    json={
        "url": "https://app.example.com",
        "render": True,          # render before link discovery
        "max_pages": 500,
        "schema": {
            "title": "string",
            "price": "number|null",
            "in_stock": "boolean",
        },
    },
    timeout=120,
).json()

print(job["id"], job["status"])

People also ask

JavaScript rendering API: the questions buyers ask

What is a JavaScript rendering API?

It is an API that loads a page in a real browser, waits for the client-side JavaScript to build the content, and returns the result. Without it, a request to a single-page app returns the initial HTML, which is usually an empty container and a script tag rather than the content you can see in your own browser.

What do I get back from a JavaScript rendering request?

With ClawEngine you get the fully built page as clean markdown or as typed JSON matching a schema you define, with navigation, ads and scripts already stripped. Most rendering services return rendered HTML instead, which means the cleaning and structuring stage is still yours to build before the data is usable.

How is this different from running my own Puppeteer or Playwright?

Functionally it is the same rendering, and Playwright is excellent. The difference is operational: browsers want roughly a gigabyte of RAM each, they leak, they hang on long-polling pages, and concurrency turns into a scheduling problem with health checks and restarts. A rendering API moves that fleet off your infrastructure. If you render a few hundred pages a month, running it yourself is cheaper.

How many API credits does JavaScript rendering cost?

On every service that offers both, rendering costs meaningfully more than a plain fetch, because a real browser has to boot and execute the page. That is why it pays to fetch first and only fall back to rendering when the content is genuinely missing. Most sites are mixed: the docs and blog are server-rendered while the app is not, so rendering everything overspends by default.

Can I turn JavaScript rendering off?

Yes. Rendering is worth using only when the page needs it, and a large share of the web still ships server-rendered HTML. The practical pattern is to request without rendering, check whether the content you want is present, and retry with rendering only when it is not.

How do I know if a website needs JavaScript rendering?

View the page source rather than the inspector, and search for a sentence you can see on screen. If it is missing from the source but visible in the inspector, the page was built by JavaScript and a plain fetch will not see it. Disabling JavaScript and reloading shows you the same thing: whatever disappears is what your crawler would be missing.

How do I crawl a JavaScript website?

Point a crawler that renders at the start URL and let it render each page before it reads the links. That last part is what breaks naive crawlers: on a client-rendered site the navigation itself is built by JavaScript, so a crawler that only parses raw HTML finds no links to follow and stops after one page. ClawEngine renders every page it crawls, so link discovery and extraction both see the built page.

How do I make JavaScript pages crawlable?

If you own the site, server-side rendering or prerendering is the durable fix, because it puts real content and real anchor tags in the initial HTML. If you are crawling someone else's site, you cannot change how it is built, so the answer is to render it on your side. Make sure links are real href attributes rather than click handlers, since those are what any crawler follows.

Can I crawl a client-side rendered (CSR) website?

Yes, provided each view has its own URL. CSR sites built with React, Vue, Angular or Svelte return an empty container in the initial HTML, so they need rendering. The one case that stays hard is a site where content changes without the URL changing, because there is no address for a crawler to record or return to.

What is the difference between a JavaScript rendering API and a headless browser?

A headless browser like Playwright or Puppeteer is the engine; a rendering API is that engine run as a managed service. The code you write is the difference. With a headless browser you own launch, memory, timeouts, crash recovery and concurrency. With a rendering API you make one HTTP request and the fleet is somebody else's operational problem.

Does Googlebot render JavaScript?

Yes, Google renders JavaScript, but rendering is queued separately from crawling, so indexing client-rendered content can lag. That is a different job from data extraction. Googlebot is building a search index on its own schedule; a rendering API renders on demand, when your pipeline asks, and returns structured data rather than a ranking.

Good questions

Questions about JS rendering API

On many modern sites the initial HTML is nearly empty and the content is assembled by JavaScript in the browser. Without rendering, a scraper sees a shell. ClawEngine renders the page first, so the extracted markdown or JSON reflects the fully built content.
No. Rendering happens inside the ClawEngine API, so there is no headless browser to run or scale on your side. It processes public, permitted pages only and respects robots.txt and Terms of Service.

Explore more

More ways to turn the web into data with ClawEngine

Stop wrangling raw HTML. Get LLM-ready data.

Point ClawEngine at a public page and one call crawls, renders the JavaScript and extracts clean markdown or typed JSON, ready for your RAG pipeline or AI agent. Public, permitted data only.

See pricing

Crawl · render JS · extract markdown & JSON · robots.txt respected, public data only