Best JavaScript SEO Tools 2027: Top 5 for Rendering Checks
The best JavaScript SEO tools for 2027, compared. We rendered 174 homepages: 36 % had internal links that only existed after JavaScript ran. Free script inside.
Kazi Khalid Hasan Tamim · BugViso Team
15 min read
The best JavaScript SEO tools for 2027 are Google Search Console's URL Inspection for Google's own view of a page, the Rich Results Test for any public URL, Screaming Frog or Sitebulb for site-wide raw-versus-rendered crawls, and BugViso for JavaScript problems inside a full site audit. Each one answers a different question, so most teams need two.
All of them measure one gap: what is in the HTML your server sends versus what appears only after JavaScript runs. We measured that gap on 174 real homepages. Titles, canonicals and robots tags were almost always in the raw HTML. Links were not: 62 of 174 homepages (35.6 %) had internal links that only existed after JavaScript ran.
You will see which tool fits which job, what each costs today, and how to run the same check yourself with a tested script.
Data used: 420 domains drawn at random (seed
20261003) from ranks 1,001–50,000 of the Tranco list 94GG2, each homepage fetched twice on 2026-11-19 with Playwright 1.52.0 and Chromium: once as raw HTML, once rendered. 174 loaded as real pages in both versions; the rest failed, timed out, returned a non-2xx status or bot challenge, had under 50 words, or redirected with JavaScript. First-pass timeouts were retried once with a longer wait. Tool prices and features come from each vendor's own site, checked the same day. We make BugViso, one of the five tools.
What Is the Difference Between Raw HTML and Rendered HTML?
Raw HTML is the document your server sends before any script runs; rendered HTML is the DOM after the browser has executed the page's JavaScript. A JavaScript SEO tool earns its place by showing the difference between the two, page by page: title, canonical, robots tags, headings, body text and internal links.
Google explains why the gap matters in its JavaScript SEO basics. Googlebot processes JavaScript pages in three phases: crawling, rendering and indexing. A page can sit in the render queue "for a few seconds, but it can take longer than that." Three rules in the same guide decide what a tool must catch:
- Links: "Google can only discover your links if they are
<a>HTML elements with anhrefattribute." A link built from anonclickhandler is invisible to discovery. - Canonicals: don't use JavaScript to change the canonical URL to something other than the one in the original HTML.
- Noindex: when Google sees
noindexin the raw HTML it may skip rendering, so removing it with JavaScript may never take effect.
AI crawlers raise the stakes: as our study of whether AI crawlers render JavaScript found, GPTBot, ClaudeBot and PerplexityBot read the raw HTML only.
What Changed After JavaScript Ran on 174 Homepages
On 174 working homepages, JavaScript rarely changed the head tags but often added links: 1,571 of 19,355 rendered internal links (8.1 %) were missing from the raw HTML.
| Only after JavaScript ran | Homepages | Share of 174 |
|---|---|---|
| At least 1 internal link | 62 | 35.6 % |
| 10 or more internal links | 17 | 9.8 % |
| More than half of all internal links | 9 | 5.2 % |
| Under half the body words in raw HTML | 20 | 11.5 % |
| Under a quarter of the body words in raw HTML | 10 | 5.7 % |
| Title changed | 4 | 2.3 % |
| Meta description added | 2 | 1.1 % |
| JSON-LD added | 2 | 1.1 % |
| H1 added | 1 | 0.6 % |
| Canonical added | 1 | 0.6 % |
| Title added, canonical changed or noindex changed | 0 | 0 % |
Two patterns stand out. Head tags are mostly safe: the title, canonical and robots tags were nearly always in the server response. Links are where JavaScript still hides things. The median homepage with any JavaScript-only links had 3 of them, one had 596, and 3 homepages (1.7 %) had no internal links at all in the raw HTML.
A JavaScript-only <a href> link reaches Googlebot later, after rendering. For a crawler that never renders, it doesn't exist. That is why the onclick-versus-href question matters even when every link works in your browser.
💡 Rule of thumb: A tool that only compares titles and canonicals will tell most sites they are fine. Ask it for the list of internal links that exist only after rendering, then check those pages with one of the internal linking tools to see which ones lose their only path.
The Top 5 JavaScript SEO Tools at a Glance
| Tool | Best for | Raw vs rendered comparison | Scope | Price (checked 2026-11-19) |
|---|---|---|---|---|
| Search Console URL Inspection | Google's own render of your pages | HTML, screenshot, console output | One URL, verified sites only | Free |
| Rich Results Test | Any public URL, including ones you don't own | Rendered source in the code explorer | One URL | Free |
| Screaming Frog SEO Spider | Site-wide raw vs rendered diffs on your desktop | Diff per page plus JavaScript filters | Whole site | JS rendering needs the £199/year licence |
| Sitebulb | Visual Response vs Render report | 6 SEO elements per page | Whole site | Desktop Lite listed at $18/month; 14-day trial |
| BugViso | JavaScript errors and rendering inside a full audit | Server-rendered text share on the audited page | Multi-page crawl | First report free, then $1.49 per report |
| Bonus: the script below | Quick checks from the command line | 8 elements plus internal links | Any list of URLs | Free |
Search Console URL Inspection: Best for Google's Own Render
URL Inspection is the closest you can get to what Googlebot actually rendered, because it is Google's renderer. Run a live test, then open "View tested page" to see the page's HTML, a screenshot of the rendered page, the HTTP headers, the JavaScript console output and the page resources that loaded.
The limits: only URLs in a Search Console property you own, one at a time, with a per-property daily limit on live inspections, per Google's URL Inspection help page. Use it to confirm a fix, not to audit a site.
Rich Results Test: Best for Any Public URL
The Rich Results Test is the free way to see Google's rendered source for a page you don't own, such as a public staging URL or a competitor's template. It accepts a URL or a pasted code snippet, and you can switch between the smartphone and desktop user agents (smartphone is the default).
Its purpose is structured data, so the rendering view is a side benefit: the code explorer that opens on an error or warning uses the rendered source, per Google's Rich Results Test help page. It is the quickest way to check that JSON-LD injected by JavaScript is visible to Google.
Screaming Frog SEO Spider: Best for Site-Wide Raw vs Rendered Diffs
Screaming Frog's SEO Spider renders every crawled page in Chrome and compares it with the raw HTML, which is the most detailed site-wide JavaScript audit on this list. Set Configuration > Spider > Rendering to JavaScript, tick "store HTML" and "store rendered HTML", and the lower pane shows a "Show Differences" diff for any URL.
Its JavaScript tab filters pages by "Contains JavaScript Links" (links found only in the rendered HTML), "Contains JavaScript Content", "Noindex Only in Original HTML" and "Canonical Mismatch". The catch is price. The free version crawls up to 500 URLs but doesn't include JavaScript rendering; the pricing page lists the licence at £199 per licence, per year.
Sitebulb: Best for a Visual Response vs Render Report
Sitebulb's Response vs Render report shows, in six charts, how rendering changed meta robots, canonical, title, meta description, internal links and external links across a crawl. It is only available when the audit uses Sitebulb's Chrome Crawler, which you pick at setup.
Body text gets a separate hint, "Contains JavaScript content". JavaScript crawling is included on every plan. On 2026-11-19 the pricing page listed Desktop Lite (10,000 URLs per audit) at $18 a month and Pro (500,000 URLs per audit) at $42 a month, with Cloud plans from $125 a month and a 14-day free trial.
BugViso: Best for JavaScript Errors Inside a Full Audit
BugViso loads your site in a real Chromium browser with Playwright and reports the JavaScript problems that break pages, alongside the SEO, speed, accessibility and AI search checks. The crawl discovers links from the rendered DOM on every page, so links injected by JavaScript still get crawled and checked.
It also reports how much of the audited page's text arrives in the raw HTML. Where others go further: BugViso doesn't produce a per-page diff of canonicals, meta robots and links across a whole crawl the way Screaming Frog and Sitebulb do. Pick it for rendering, console errors and the rest of the audit in one report; pick a desktop crawler for per-element diffs on thousands of URLs.
How to Choose a JavaScript SEO Tool
Choose by the question you need answered, not by feature count.
| Your question | Start with |
|---|---|
| "Did Google render this page the way I expect?" | Search Console URL Inspection (live test) |
| "What does Google render on a page I don't own?" | Rich Results Test |
| "Which of our 20,000 URLs change canonical or links after JavaScript?" | Screaming Frog or Sitebulb with rendering on |
| "Why does this page break, and what else is wrong with the site?" | BugViso |
| "What changes on these 30 URLs after JavaScript?" | The script below |
Whatever you pick, test with JavaScript on and off, because a tool that only renders hides the AI crawler problem, and retest after every framework upgrade: hydration and routing changes are where server-rendered sites quietly turn into client-rendered ones, and React hydration errors are the usual first symptom.
Run It Yourself: Raw HTML vs Rendered DOM Script
This script fetches a page twice with the same browser, once as raw HTML and once rendered, and reports which SEO elements and internal links exist only after JavaScript. It is the comparison code behind the 174-site table above. It needs Python 3.9+ and Playwright (pip install playwright then playwright install chromium).
#!/usr/bin/env python3
"""Compare a page's raw HTML with its rendered DOM: what exists only after JavaScript runs.
Usage: python js_seo_check.py <url> [more urls ...]
Needs: pip install playwright && playwright install chromium
"""
import asyncio
import json
import re
import sys
from html.parser import HTMLParser
from urllib.parse import urljoin, urldefrag, urlparse
from playwright.async_api import async_playwright
SKIP_TEXT = {"script", "style", "noscript", "template", "svg"}
class Page(HTMLParser):
"""One pass over the HTML: the SEO elements plus visible words and internal links."""
def __init__(self, base):
super().__init__(convert_charrefs=True)
self.base, self.host = base, urlparse(base).hostname.removeprefix("www.")
self.title, self.description, self.canonical, self.robots = "", "", "", ""
self.h1 = self.jsonld = self.words = 0
self.links, self._skip, self._in_title = set(), 0, False
def handle_starttag(self, tag, attrs):
a = {k: (v or "") for k, v in attrs}
if tag in SKIP_TEXT:
self._skip += 1
if tag == "script" and a.get("type", "").lower() == "application/ld+json":
self.jsonld += 1
elif tag == "title" and not self.title:
self._in_title = True
elif tag == "h1":
self.h1 += 1
elif tag == "meta":
name = a.get("name", "").lower()
if name == "description":
self.description = a.get("content", "").strip()
elif name == "robots":
self.robots = a.get("content", "").lower()
elif tag == "link" and "canonical" in a.get("rel", "").lower().split():
self.canonical = urljoin(self.base, a.get("href", "").strip())
elif tag == "a" and a.get("href"):
href = a["href"].strip()
if href.startswith(("#", "mailto:", "tel:", "javascript:")):
return
url = urldefrag(urljoin(self.base, href))[0]
host = (urlparse(url).hostname or "").removeprefix("www.")
if urlparse(url).scheme in ("http", "https") and host == self.host:
self.links.add(url)
def handle_endtag(self, tag):
if tag in SKIP_TEXT and self._skip:
self._skip -= 1
elif tag == "title":
self._in_title = False
def handle_data(self, data):
if self._in_title:
self.title += data.strip()
elif not self._skip:
self.words += len(re.findall(r"\w+", data))
def parse(html, base):
p = Page(base)
p.feed(html)
return p
def compare(raw, ren):
"""The JavaScript-dependent facts for one page."""
only_js = ren.links - raw.links
return {
"rendered_title": ren.title[:80],
"raw_words": raw.words, "rendered_words": ren.words,
"raw_word_share": round(raw.words / ren.words, 2) if ren.words else None,
"title_only_after_js": not raw.title and bool(ren.title),
"title_changed_by_js": bool(raw.title and ren.title and raw.title != ren.title),
"h1_only_after_js": raw.h1 == 0 and ren.h1 > 0,
"description_only_after_js": not raw.description and bool(ren.description),
"canonical_only_after_js": not raw.canonical and bool(ren.canonical),
"canonical_changed_by_js": bool(raw.canonical and ren.canonical and raw.canonical != ren.canonical),
"noindex_changed_by_js": ("noindex" in raw.robots) != ("noindex" in ren.robots),
"jsonld_only_after_js": raw.jsonld == 0 and ren.jsonld > 0,
"raw_internal_links": len(raw.links), "rendered_internal_links": len(ren.links),
"js_only_internal_links": len(only_js),
"js_only_examples": sorted(only_js)[:5],
}
async def check(browser, url, settle_ms=8000):
context = await browser.new_context()
try:
# Same browser, same headers: the only difference between the two copies is JavaScript.
resp = await context.request.get(url, timeout=30000)
raw_html, status, raw_final = await resp.text(), resp.status, resp.url
page = await context.new_page()
await page.goto(url, wait_until="domcontentloaded", timeout=45000)
for state, ms in (("load", 15000), ("networkidle", settle_ms)):
try:
await page.wait_for_load_state(state, timeout=ms)
except Exception:
pass # slow trackers and long-polling never finish; take the DOM as it is
rendered_html, final = await page.content(), page.url
# A JavaScript redirect means the two copies are different pages: report it, don't diff them.
moved = urldefrag(raw_final)[0].rstrip("/") != urldefrag(final)[0].rstrip("/")
return {"url": url, "status": status, "final_url": final, "js_redirect": moved,
**compare(parse(raw_html, raw_final), parse(rendered_html, final))}
except Exception as exc:
return {"url": url, "error": str(exc).splitlines()[0][:200]}
finally:
await context.close()
async def main(urls):
async with async_playwright() as p:
browser = await p.chromium.launch()
for url in urls:
print(json.dumps(await check(browser, url), indent=2))
await browser.close()
if __name__ == "__main__":
if len(sys.argv) < 2:
sys.exit(__doc__)
asyncio.run(main(sys.argv[1:]))A real run against our own homepage (trimmed to the key fields, values unedited):
$ python js_seo_check.py https://bugviso.com/
"js_redirect": false,
"raw_words": 1293,
"rendered_words": 1308,
"raw_word_share": 0.99,
"title_changed_by_js": false,
"canonical_changed_by_js": false,
"raw_internal_links": 26,
"rendered_internal_links": 26,
"js_only_internal_links": 0,Three limits. Google's renderer has its own timing, so confirm borderline results in URL Inspection. A JavaScript redirect is reported as js_redirect: true; don't read that diff. And the two copies are separate requests, so rotating carousels or personalised blocks can add a few JavaScript-only links; check js_only_examples before you act.
How BugViso Catches JavaScript SEO Problems Automatically
BugViso's audit runs in a real browser, so it sees the JavaScript failures a raw-HTML crawler never meets, and its findings land in one ranked fix list and the PDF. Four parts of the audit cover JavaScript SEO:
- Server-rendered text. The audit compares the word count of the raw HTML with the rendered page. Under 25 % on a page of 250+ rendered words raises a "Client-Side Rendering (CSR) Dependency" finding.
- Rendered-link crawl. The multi-page crawl reads links from the rendered DOM on every page, so the JavaScript-only links in the table above still get discovered and checked for 404s.
- Console errors, hydration and failed requests. Uncaught exceptions arrive with stack traces, React and Next.js hydration mismatches are flagged from their error signatures, and failed requests list the scripts and API calls that never loaded.
- Coverage and AI crawler access. Unused JavaScript and CSS bytes, plus a per-crawler check of whether GPTBot, ClaudeBot and other AI bots may fetch your pages.
In the AI Visibility Tracker, the site audit's "What AI crawlers see" tab also lists the paragraphs and headings on a page that only exist after JavaScript runs. The developer code and visual QA feature page covers the console, hydration and request checks in detail.
Frequently Asked Questions
What is the best free JavaScript SEO tool?
Google Search Console's URL Inspection tool is the best free JavaScript SEO tool for pages on a site you own, because it shows Google's own render, a screenshot and the JavaScript console output. For pages you don't own, the free Rich Results Test shows Google's rendered source.
How can I check if Google can render JavaScript on my page?
Run a live test in Search Console's URL Inspection tool and open "View tested page". If your main text, links and structured data appear in the HTML and the screenshot, Google can render the page. If something is missing, read the JavaScript console output and the list of page resources that failed to load.
How do I see rendered HTML vs page source?
Page source (Ctrl+U in Chrome) shows the raw HTML your server sent. The Elements panel in Chrome DevTools shows the rendered DOM after JavaScript ran. To compare them at scale, use a crawler with rendering switched on, such as Screaming Frog or Sitebulb, or the script in this post for a list of URLs.
Is JavaScript rendering free in Screaming Frog?
No. On 2026-11-19 Screaming Frog's pricing page listed JavaScript rendering as a paid-licence feature; the free version crawls up to 500 URLs without it. The licence was listed at £199 per licence, per year.
Can Google see content loaded by JavaScript?
Usually yes: Googlebot renders pages with an evergreen version of Chromium, sometimes after a delay. Most AI crawlers don't render, so they miss that content. Don't change the canonical with JavaScript, and don't rely on JavaScript to remove a noindex, because Google may skip rendering a noindex page.
Is dynamic rendering still recommended for SEO?
No. Google's dynamic rendering documentation calls it "a workaround and not a recommended solution" and recommends server-side rendering, static rendering or hydration instead.
The One Check to Run Before You Pick a Tool
Before you pay for any JavaScript SEO tool, run the script above on your five most important templates and look at one number: internal links that exist only after rendering. If it is zero and most of your text is in the raw HTML, Google's free tools are enough; if it isn't, you need a crawler that renders every page, which is what a BugViso site audit does alongside console errors and AI crawler checks.
Written by
Kazi Khalid Hasan Tamim · BugViso Team
Kazi writes BugViso’s guides on website audits, Core Web Vitals, technical SEO, accessibility and AI search. The data in them comes from audits BugViso runs in a real Chromium browser, including our 219-site study of website health.
Summarise with AI
Open this guide in your assistant.
Follow BugViso
New guides and audit data as we publish them.
AI visibility tracker
Is your brand in AI answers?
See how often AI assistants mention you, cite your site and rank you against your competitors.
- ChatGPT
- Gemini
- Perplexity
- Claude
- AI Overviews
See where your site stands
Run a free BugViso audit for SEO, speed, accessibility and AI search readiness — with fixes you can ship today.