Website Performance Checker

Check website performance for any URL. Measures TTFB (Time to First Byte), page size, compression, response timing breakdown, and resource counts. Returns a performance grade from A+ to F.

What does Website Performance Checker do?

This actor measures server-side performance of any website by making HTTP requests and analyzing response timing, page size, compression, and embedded resources. It provides a performance grade and identifies common issues like slow TTFB, uncompressed responses, and excessive resources. Use it for performance monitoring, competitive benchmarking, or site audits at scale.

What is measured

Metric	Description
TTFB	Time to First Byte -- how long the server takes to respond
Total time	Full request-response cycle including content download
DNS lookup	Domain name resolution time
TCP connect	TCP connection establishment time
TLS handshake	SSL/TLS negotiation time
Content download	Time to download the full response body
Page size	HTML document size (raw and compressed)
Compression	Whether gzip/brotli compression is enabled
Resources	Count of scripts, stylesheets, images, iframes in HTML

Use cases

• DevOps engineers -- monitor TTFB and total response time over time to catch performance regressions early
• SEO specialists -- server performance directly affects Core Web Vitals and search rankings
• Marketing teams -- validate landing page speed before launching campaigns
• Infrastructure architects -- verify that CDN, caching, and compression are working correctly
• QA teams -- run pre-launch performance checks to confirm sites meet speed requirements

Why use Website Performance Checker?

• Batch processing -- check hundreds of URLs in a single run instead of testing them one at a time
• Full timing breakdown -- DNS, TCP, TLS, TTFB, and content download are all measured separately
• Performance grading -- every URL gets a grade from A+ to F for quick prioritization
• Issue detection -- automatically flags slow TTFB, missing compression, and excessive resources
• Structured JSON output -- consistent schema ready for dashboards, spreadsheets, and alerting
• Pay-per-event pricing -- you only pay for the URLs you check, starting at $0.001 per URL

Input parameters

Parameter	Type	Required	Default	Description
urls	array	Yes	--	List of URLs to check performance for. Domain names without protocol are auto-prefixed with https://

Input example

{
    "urls": ["apify.com", "google.com", "github.com"]
}

Output example

{
    "url": "https://apify.com",
    "grade": "A",
    "statusCode": 200,
    "ttfbMs": 145,
    "totalTimeMs": 320,
    "timing": {
        "dnsLookupMs": 12,
        "tcpConnectMs": 25,
        "tlsHandshakeMs": 35,
        "ttfbMs": 145,
        "contentDownloadMs": 103,
        "totalMs": 320
    },
    "pageSize": {
        "htmlBytes": 98304,
        "htmlKb": 96,
        "transferBytes": 24576,
        "transferKb": 24,
        "compressed": true,
        "compressionType": "gzip"
    },
    "resources": {
        "scripts": 12,
        "stylesheets": 3,
        "images": 8,
        "iframes": 0,
        "totalResources": 23
    },
    "headers": {
        "server": "nginx",
        "cacheControl": "public, max-age=3600",
        "contentType": "text/html; charset=utf-8",
        "xPoweredBy": null
    },
    "issues": [],
    "error": null,
    "checkedAt": "2026-03-01T12:00:00.000Z"
}

How much does it cost?

Website Performance Checker 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 checked	$0.001	Per URL checked

Cost examples:

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

Using the Apify API

You can call Website Performance Checker programmatically from any language using the Apify API. The actor slug is automation-lab/website-performance-checker.

Node.js

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('automation-lab/website-performance-checker').call({
    urls: ['apify.com', '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/website-performance-checker').call(run_input={
    'urls': ['apify.com', 'google.com'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Integrations

Website Performance Checker integrates with the major automation and data platforms through the Apify ecosystem. Connect it to Make (formerly Integromat) or Zapier to trigger performance checks on a schedule and route results to alerting tools. Export results to Google Sheets for ongoing TTFB and page size tracking. Send Slack notifications when a site's grade drops below a threshold. Use webhooks to feed results into your own monitoring dashboard, or orchestrate runs from n8n and any platform that supports HTTP requests and the Apify REST API.

Tips and best practices

• Use bare domains -- you can pass apify.com instead of https://apify.com; the actor auto-prefixes the protocol.
• Schedule daily checks -- set up a recurring Apify schedule to build a performance history and catch regressions.
• Focus on TTFB first -- Time to First Byte is the single most important server-side metric; anything above 600ms warrants investigation.
• Check compression -- pages with compressed: false are quick wins; enabling gzip or brotli can reduce transfer size by 60-80%.
• Compare competitors -- run the same batch for your site and competitors to see how your server speed stacks up.

FAQ

Does this actor use a real browser? No. It makes server-side HTTP requests to measure timing and parse the HTML response. This measures pure server performance without browser rendering overhead, which makes it faster and cheaper to run at scale.

What do the grades mean? Grades range from A+ to F based on a composite score of TTFB, page size, compression, and resource count. An A+ indicates excellent server-side performance across all metrics.

Can I check pages behind authentication? No. The actor sends unauthenticated HTTP requests. It is designed for publicly accessible URLs. For authenticated pages, you would need a custom actor that handles login flows.