Page Size Analyzer

Analyze web page size and resource breakdown. Count scripts, stylesheets, images, fonts, and inline code.

What does Page Size Analyzer do?

This actor analyzes web page size and provides a detailed resource breakdown. It measures HTML document size, counts external resources (scripts, stylesheets, images, fonts, iframes, videos), and calculates inline script, style, and comment bytes. Feed it a list of URLs and get back structured data about every page's weight and composition.

Use cases

• Performance engineers -- identify heavy pages with too many resources and prioritize optimization work
• SEO specialists -- large pages load slower and rank lower; measure page weight to guide technical SEO
• Marketing teams -- audit landing pages before campaigns to ensure fast load times on mobile and desktop
• Development leads -- catch inline script and style bloat during code review before merging to production
• Competitive analysts -- compare page sizes across competitor sites to benchmark your own performance
• Accessibility consultants -- bloated pages with excessive resources create barriers for users on slow connections

Why use Page Size Analyzer?

• Batch processing -- analyze hundreds of URLs in a single run instead of checking pages one by one
• Structured JSON output -- every result follows a consistent schema, ready for dashboards and spreadsheets
• Resource-level detail -- goes beyond total size to break down scripts, styles, images, fonts, iframes, and videos
• Inline code measurement -- surfaces hidden bloat from inline scripts, styles, and HTML comments
• API and integration ready -- call it programmatically or connect to Make, Zapier, and other automation platforms
• Pay-per-event pricing -- you only pay for the pages you analyze, starting at $0.001 per URL

Input parameters

Parameter	Type	Required	Default	Description
urls	array	Yes	--	List of web page URLs to analyze for page size and resources

Input example

{
    "urls": [
        "https://www.google.com",
        "https://en.wikipedia.org/wiki/Web_scraping",
        "https://example.com"
    ]
}

Output example

{
    "url": "https://example.com",
    "title": "Example Domain",
    "htmlSizeBytes": 1256,
    "htmlSizeKB": 1.2,
    "resourceCounts": {
        "scripts": 0,
        "stylesheets": 0,
        "images": 0,
        "fonts": 0,
        "iframes": 0,
        "videos": 0,
        "audios": 0
    },
    "estimatedResources": [],
    "totalResourceUrls": 0,
    "inlineStyleBytes": 375,
    "inlineScriptBytes": 0,
    "commentBytes": 0,
    "error": null,
    "checkedAt": "2026-03-01T12:00:00.000Z"
}

How much does it cost?

Page Size Analyzer uses Apify's pay-per-event pricing model. You are only charged for what you use.

Event	Price	Description
Start	$0.035	One-time per run
URL analyzed	$0.001	Per page analyzed

Cost examples:

• Analyzing 10 pages: $0.035 + (10 x $0.001) = $0.045
• Analyzing 100 pages: $0.035 + (100 x $0.001) = $0.135
• Analyzing 1,000 pages: $0.035 + (1,000 x $0.001) = $1.035

Using the Apify API

You can call Page Size Analyzer programmatically from any language using the Apify API. The actor slug is automation-lab/page-size-analyzer.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('automation-lab/page-size-analyzer').call({
    urls: ['https://example.com', 'https://www.google.com'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
run = client.actor('automation-lab/page-size-analyzer').call(run_input={
    'urls': ['https://example.com', 'https://www.google.com'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Integrations

Page Size Analyzer integrates with the major automation and data platforms through the Apify ecosystem:

• Make (formerly Integromat) -- trigger page size checks automatically and route the results to any of Make's 1,000+ app integrations.
• Zapier -- create Zaps that run page size analysis when new URLs are added to a spreadsheet or database.
• Google Sheets -- export results directly for ongoing tracking and trend visualization.
• Slack -- send alerts to a channel when a page exceeds a size threshold or when new bloat is detected.
• Webhooks -- get notified when a run finishes and post-process the data in your own backend systems.
• n8n -- orchestrate runs from n8n workflows or any tool that supports HTTP requests and the Apify REST API.

Tips and best practices

• Start small, then scale -- test with 3-5 URLs first to review the output schema before running large batches.
• Schedule regular runs -- set up a daily or weekly Apify schedule to track page weight trends over time.
• Combine with performance tools -- pair this actor with Website Performance Checker for a full picture of both page weight and server speed.
• Watch inline code -- high inlineScriptBytes or inlineStyleBytes often indicates opportunities to externalize and cache code.
• Filter by resource type -- use the resourceCounts breakdown to focus optimization on the heaviest category (scripts, images, etc.).

FAQ

Can I analyze pages that require login or authentication? No. This actor fetches pages as a public visitor without cookies or session tokens. It is designed for publicly accessible URLs.

Does the actor load JavaScript and render the page? No. It fetches the raw HTML document and parses it statically. Resource counts are based on tags found in the HTML source, not on what a browser would render after JavaScript execution. This approach is faster and more cost-effective for bulk analysis.

What happens if a URL is invalid or unreachable? The actor returns a result for that URL with the error field populated and all size metrics set to zero. Other URLs in the batch are still processed normally.

How accurate are the resource counts? Resource counts reflect what is present in the raw HTML source. Dynamically injected resources (loaded via JavaScript after page load) are not counted. For most server-rendered pages, the counts are accurate. For heavily client-rendered single-page applications, the counts may be lower than what a browser would load.

Can I export results to CSV or Excel? Yes. Apify datasets support export in JSON, CSV, Excel, XML, and other formats. After the run completes, use the dataset export feature in the Apify Console or the API to download results in your preferred format.