Skip to content

Render-Blocking Resources Checker

Short answer

Find the scripts and stylesheets that block rendering, plus script habits that slow pages down: missing async/defer, inline event handlers and document.write.

What it does not do: It reads the HTML and flags patterns; it does not load the page or time how long each resource blocks rendering. The page speed test gives measured timings.

Free · No signup · Runs in your browser
100% in your browser — your content never leaves your device.

What It Does

Checks a page's HTML in two parts. Render-blocking resources: scripts in `<head>` without `async` or `defer`, stylesheets that block rendering and CSS `@import` rules. Script hygiene: how many external and inline scripts the page loads, whether external scripts use `async` or `defer`, inline event handlers such as `onclick`, `document.write` calls and whether ES modules are used.

Why It Matters

A browser has to download and run every blocking script and stylesheet in `<head>` before it can paint anything, which delays First Contentful Paint and often Largest Contentful Paint. `document.write` makes this worse — Chrome may refuse to run scripts it injects on slow connections — and inline handlers stand in the way of a strict Content-Security-Policy.

How It Works

  1. Enter a page URL or paste its HTML

  2. We parse the `<head>` and every `<script>` on the page

  3. Flag render-blocking scripts and stylesheets, then check the scripts for async/defer, inline handlers and document.write

  4. Return a result for each part, with the resources we flagged

Sample input + output

INPUT
url: https://rankproof.eu/tools
OUTPUT
Render-blocking resources                    92/100
  Blocking scripts: 0 · Blocking stylesheets: 1 · Resources in head: 7
  Head scripts use async or defer            OK
  No render-blocking stylesheets             WARN
  No @import in CSS                          OK
  Render-blocking resources:
    <link rel="stylesheet" href="DFq8YedA.css">

Script hygiene                               100/100
  Scripts: 13 · External: 5 · Inline: 8
  External scripts use async or defer        OK
  No inline event handlers                   OK
  No document.write                          OK
  Uses ES modules                            OK

1 of 2 areas look good · 96/100

How to read the result

Two parts (1 of 2 areas look good · 96/100)
Render-blocking resources and script hygiene each get their own score, and the overall score is their average. In the sample the script part is clean and the first part has one warning, so the summary counts one of two.
Blocking scripts (0)
Scripts in <head> with a src and no async, defer or type="module". The browser stops building the page while each one downloads and runs, and each costs the part 15 points. Inline scripts and scripts in <body> are not counted here.
Blocking stylesheets (1)
Every <link rel="stylesheet"> in <head> that is not media="print" or disabled. The browser paints nothing until it has these files, so one main stylesheet is normal: one is a warning, two or more fail. The sample's one file is the site's own stylesheet, named after its content. A stylesheet with another media query is still counted, although browsers do not wait for one whose query does not match the screen.
Resources in head (7) and @import
Resources in head counts every script, stylesheet and <style> block in <head>, blocking or not; it gives context and is not scored. An @import inside a <style> block costs 10 points, because the browser finds the imported file only after reading the first. @import rules inside linked .css files are not checked, since those files are not downloaded.
Script hygiene (13 scripts: 5 external, 8 inline)
Counts every script on the page, in <head> and <body>. Inline counts every non-empty <script> block, including JSON-LD structured data, which never runs, so a high number is not a problem in itself. External scripts without async, defer or type="module" cost 8 points each, inline handlers such as onclick 4 each, and any document.write call 15.
Uses ES modules
Passes when at least one script has type="module". Without one it is a warning, not a failure: it is a hint towards the modern way to load code, since modules are deferred by default.

Who Uses This

  • Performance Engineer

    Before a busy season, move every blocking script to async or defer and re-check that nothing new crept into `<head>`.

  • Frontend Developer

    Find the analytics or widget snippet that still loads synchronously and switch it to a deferred load.

  • SEO Specialist

    Check the templates behind your slowest pages and hand the flagged resources to the development team.

Common problems and how to fix them

  1. A blocking script in <head>

    Add defer to scripts that need the page's elements or must run in order, and async to independent ones such as analytics. Scripts with type="module" are already deferred.

    <script src="/js/app.js" defer></script>
    <script src="https://analytics.example/tag.js" async></script>
    <script type="module" src="/js/menu.js"></script>
  2. More than one blocking stylesheet

    Combine your own CSS into one file at build time, give print styles media="print", and inline the few rules the first screen needs so the page can paint before the main file arrives.

    <head>
      <style>/* only the rules the first screen needs */ .hero { min-height: 60vh; }</style>
      <link rel="stylesheet" href="/css/site.css">
      <link rel="stylesheet" href="/css/print.css" media="print">
    </head>
  3. @import in a <style> block

    Replace it with a <link rel="stylesheet">, so the browser can find and download both files at the same time.

    <!-- before -->
    <style>@import url("/css/fonts.css");</style>
    
    <!-- after -->
    <link rel="stylesheet" href="/css/fonts.css">
  4. Inline event handlers

    Move handlers such as onclick into a script file and attach them with addEventListener. Once no inline code is left, a Content-Security-Policy can drop 'unsafe-inline'.

    <!-- before -->
    <button onclick="openMenu()">Menu</button>
    
    <!-- after -->
    <button type="button" id="menu-button">Menu</button>
    <script type="module" src="/js/menu.js"></script>
    
    // /js/menu.js
    document.getElementById('menu-button').addEventListener('click', openMenu);
  5. document.write

    Create the element with DOM methods instead; old ad and widget snippets are the usual source, and most providers now offer an async version. The check matches the text document.write( anywhere in the HTML, so a mention in a comment counts too.

    const s = document.createElement('script');
    s.src = 'https://widget.example/embed.js';
    s.async = true;
    document.head.append(s);

Frequently Asked Questions

How do I un-block a stylesheet?
Inline the few rules the first screen needs in a `<style>` block, keep the rest in one stylesheet and give print styles `media="print"`. The `onload="this.media='all'"` trick also works, but it is an inline handler: this check flags it and a strict Content-Security-Policy blocks it.
Can I just defer all my scripts?
Not always — scripts that must run before first paint, polyfills required for layout and inline scripts cannot always wait. Audit them by impact.
What is wrong with document.write?
It forces the browser to pause parsing, and Chrome may block the scripts it injects on slow connections. Insert elements with DOM methods instead.
Why flag inline event handlers?
Handlers such as `onclick="…"` mix behavior into markup and need `unsafe-inline` in a Content-Security-Policy. Attach listeners from a script file instead.
What about third-party widgets?
Load them with `<script async>` or through a tag manager with deferred loading. Better still, load widgets below the fold only on scroll or interaction.

Sources

The documentation this tool and the explanations on this page are based on.