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 to check website performance

1. Open Website Performance Checker on Apify.
2. Enter one or more URLs in the urls field (bare domains like apify.com work too).
3. Click Start and wait for the check to finish.
4. Review TTFB, page size, compression, grades, and issues in the Dataset tab.
5. Download results as JSON, CSV, or Excel.

How much does it cost to check website performance?

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)

cURL

curl -X POST "https://api.apify.com/v2/acts/automation-lab~website-performance-checker/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["apify.com", "google.com"]
  }'

Use with Claude AI (MCP)

This actor is available as a tool in Claude AI through the Model Context Protocol (MCP). Add it to Claude Desktop, Cursor, Windsurf, or any MCP-compatible client to let Claude check website performance directly in your conversation.

Setup

Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-apify"],
      "env": {
        "APIFY_TOKEN": "your-apify-api-token"
      }
    }
  }
}

Claude Code CLI:

$claude mcp add apify -- npx -y @anthropic-ai/mcp-apify

Example prompts

• "How fast does this website load: apify.com?"
• "Check page speed for our top landing pages"
• "Compare TTFB and page size between our site and our top 3 competitors"

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.

Legality

This tool analyzes publicly accessible web content. Automated analysis of public web resources is standard practice in SEO and web development. Always respect robots.txt directives and rate limits when analyzing third-party websites. For personal data processing, ensure compliance with applicable privacy regulations.

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.

The TTFB is much higher than what I see in Chrome DevTools. Why? The actor runs from Apify's cloud infrastructure, which may be geographically distant from your server. Chrome DevTools measures from your local machine. TTFB varies significantly with network distance, so the actor's measurements reflect the experience of users accessing your site from Apify's data center location, not from your own network.

The grade seems low but my site loads fast in a browser. What is going on? The actor measures server-side performance (TTFB, compression, resource counts) via HTTP requests without rendering. A low grade often points to missing compression, large HTML size, or excessive inline resources -- issues that affect server efficiency even if the perceived browser experience feels fast due to CDN caching or client-side optimizations.

Other SEO and website tools on Apify

• Website Carbon Calculator -- estimate the carbon footprint of any web page
• Website Health Report -- comprehensive website health audit with scoring
• Website Uptime Checker -- check if websites are up and measure response times
• Word Counter -- count words, sentences, and paragraphs on web pages
• Webpage Text Extractor -- extract clean text content from web pages