Website Load Testing & Stress Test: uptime, speed, SSL and broken links for your own website

Website Load Testing runs a real load test / stress test against your own website from the Apify cloud: up to 50 concurrent users for up to 5 minutes, with p50 / p90 / p99 latency, error rate, status codes and throughput for every URL. In the same run it does a full website health check: uptime, TTFB and timing breakdown (DNS, connect, TLS), SSL certificate expiry, redirect chain, compression, security headers and an optional broken link checker. A summary row gives a clear pass / fail verdict against your thresholds, so you can use it in CI or as a scheduled uptime monitor.

Only test websites you own or are explicitly allowed to test. The Actor asks you to confirm it on every run, refuses well-known third-party websites, and identifies every request with the User-Agent pnda-load-test (+https://apify.com/pnda/website-load-test). It is not a traffic generator: no proxies, no IP rotation, no fake browsers, no fake visits. Load testing someone else's website without permission can be illegal.

What you get

	Website Load Testing (this Actor)	Typical "traffic generator"	Online speed test
Purpose	Measure how your site holds under load	Inflate visit counters	One page, one visitor
Latency percentiles (p50 / p90 / p99)	Yes, per URL	No	No
Error rate, status codes, requests per second	Yes	No	No
TTFB, DNS / connect / TLS timing	Yes	No	Partly
SSL expiry, redirects, broken links	Yes	No	Rarely
Pass / fail verdict for CI and monitoring	Yes	No	No
Proxies, fake user agents	Never	Residential proxies	–

Use cases

• Load testing before a launch, a sale or a TV spot: check that your shop answers fast with 10, 25 or 50 users hitting it at the same time.
• Website stress test after a server or plugin change: compare p90 latency and error rate before and after.
• Uptime monitor: schedule a check-only run every 5, 15 or 60 minutes and get alerted (Apify integrations: Slack, email, webhooks) when the verdict is fail.
• SSL checker: get warned weeks before your SSL certificate expires.
• Broken link checker: find 404 links, images and scripts on your key pages.
• Website speed test from the server side: TTFB and total load time percentiles, with DNS / TCP / TLS breakdown.

How it works

1. Health check of every URL (samplesPerUrl timed requests, each on a fresh connection): status, uptime, redirects (followed up to 10), TTFB and total time percentiles, DNS / connect / TLS handshake time, page size, compression, cache headers, server, HTTP version, security headers, SSL certificate (issuer, validity, days left).
2. Load test (optional): concurrency virtual users send requests one after the other with keep-alive connections, spread over your URLs (round robin), ramped up over rampUpSecs. The test ends at durationSecs or maxRequests. Two safety brakes, measured on the last 100 requests: the test stops as soon as more than stopOnErrorRatePercent of them fail (5xx or no answer), so a site that is going down is not loaded further, and as soon as your firewall or CDN blocks most of them (403 / 429), with stoppedBy: "firewall-block".
3. Broken link check (optional): every link, image, script and stylesheet of each HTML page, checked with HEAD and a GET fallback.
4. Summary: one row with the verdict, the failed checks and the warnings.

Requests are plain HTTP(S) from one Apify server (no browser), so the load test measures your server and CDN, not the browser rendering (Core Web Vitals such as LCP or CLS are not measured).

Safety limits

• Maximum 50 concurrent users, 5 minutes and 20,000 requests per run.
• All URLs of a run must belong to one website (same domain and its subdomains).
• Refused: well-known third-party domains (Google, Facebook, Amazon, Apify, Cloudflare, Microsoft, Apple...), government, military and education domains, IP addresses, private and internal addresses.
• No proxies, no IP rotation, no user-agent spoofing.

Input

{
  "urls": ["https://www.my-shop.com/", "https://www.my-shop.com/products/best-seller"],
  "confirmOwnership": true,
  "samplesPerUrl": 5,
  "checkBrokenLinks": true,
  "maxLinksPerPage": 100,
  "loadTest": true,
  "concurrency": 20,
  "durationSecs": 60,
  "maxRequests": 5000,
  "rampUpSecs": 10,
  "method": "GET",
  "maxP90Ms": 2000,
  "maxErrorRatePercent": 1,
  "maxTtfbMs": 800,
  "minSslDaysLeft": 14
}

For an uptime monitor, keep loadTest off and schedule the Actor: each run costs one URL check per URL.

Output

Every row has a type. Download as JSON, CSV or Excel, or read the SUMMARY record of the key-value store.

check (one per URL):

{
  "type": "check",
  "url": "http://my-shop.com/",
  "finalUrl": "https://www.my-shop.com/",
  "up": true,
  "status": 200,
  "redirects": [{ "url": "http://my-shop.com/", "status": 301, "location": "https://www.my-shop.com/" }],
  "httpsRedirect": true,
  "ttfb": { "count": 5, "p50Ms": 182.4, "p90Ms": 240.1, "p99Ms": 240.1, "minMs": 170.2, "maxMs": 240.1, "meanMs": 195.3 },
  "total": { "count": 5, "p50Ms": 301.7, "p90Ms": 355.0, "p99Ms": 355.0 },
  "dnsMs": 4.1, "connectMs": 12.3, "tlsHandshakeMs": 25.8,
  "pageSizeBytes": 48211, "compression": "br", "httpVersion": "1.1",
  "ssl": { "valid": true, "issuer": "Let's Encrypt / R11", "validTo": "2026-12-30T10:11:12.000Z", "daysLeft": 82, "protocol": "TLSv1.3" },
  "securityHeaders": { "strictTransportSecurity": true, "contentSecurityPolicy": false, "xContentTypeOptions": true, "xFrameOptions": true, "referrerPolicy": true }
}

load-test (one per URL tested):

{
  "type": "load-test",
  "url": "https://www.my-shop.com/",
  "requests": 2410, "successful": 2408, "errors": 2, "errorRatePercent": 0.08,
  "statusCodes": { "200": 2408, "502": 2 },
  "latency": { "p50Ms": 210.5, "p90Ms": 402.3, "p95Ms": 512.0, "p99Ms": 901.7, "maxMs": 1820.4 },
  "ttfb": { "p50Ms": 180.2, "p90Ms": 350.9, "p99Ms": 850.1 },
  "requestsPerSecond": 40.17,
  "bytesReceived": 116209152
}

load-test-timeline: requests, errors, median latency and active users for every second of the test (to chart the ramp-up).

links (one per page): links found and checked, and the list of broken ones with their status.

summary:

{
  "type": "summary",
  "site": "my-shop.com",
  "verdict": "fail",
  "failures": ["load test: p90 latency 2310 ms > 2000 ms"],
  "warnings": ["2 broken link(s) found"],
  "loadTest": { "requests": 4820, "requestsPerSecond": 80.3, "errorRatePercent": 0.1, "p50Ms": 420, "p90Ms": 2310, "p99Ms": 3900, "durationSecs": 60, "concurrency": 20, "stoppedBy": "duration" },
  "sslDaysLeft": 82,
  "brokenLinks": 2,
  "message": "FAIL: 2/2 URL(s) up, load test 4820 requests at 80.3 req/s, p90 2310 ms, 0.1% errors, 2 broken link(s), 1 failed check(s)."
}

Pricing (pay per event, results only)

Event	Price
URL checked (health check: uptime, timings, SSL, redirects)	$0.003 ($3 per 1,000)
Load test, per started minute	$0.05
Link checked (broken link checker)	$0.0005 ($0.50 per 1,000)

Examples: an uptime monitor on 3 URLs every 15 minutes costs about $0.86 per day. A 1-minute load test with 50 users on 2 pages costs $0.056. A 5-minute stress test costs $0.25.

The Actor checks your maximum cost per run before every paid step: the load test is shortened to fit it, and a run that cannot afford a single URL check stops with a budget-too-low row, free.

Works with a free Apify account too. Free-plan accounts can use every feature at the same per-result prices, paid from their monthly Apify credit. The only limits are your credit and your maximum cost per run.

Run status

Runs end SUCCEEDED with an explicit row and no charge when the input is invalid (invalid-input: missing ownership confirmation, third-party domain, two different websites...), when your maximum cost per run is too low (budget-too-low) or when the free limit is reached (free-plan-limit). A failing website is a result (up: false, verdict fail), not a failed run.

FAQ

Is this a traffic generator? No. It sends identified test requests to measure performance. It does not simulate visitors, does not run JavaScript analytics tags and does not use proxies, so it will not (and is not meant to) increase your visitor counts.

Why only 50 concurrent users? The Actor is built to validate a small or medium website safely from one server. For tests with thousands of users from several regions, use a dedicated load testing platform.

My site is behind Cloudflare or a WAF. The test traffic comes from Apify cloud IPs with an honest User-Agent. Many CDNs (Vercel, Cloudflare, Sucuri...) start answering 403 or 429 to a burst of requests from one IP. The Actor detects it, stops the test (stoppedBy: "firewall-block") and says so in the verdict. Allow-list the User-Agent pnda-load-test (or the test path) during the test to measure your server rather than your firewall.

Can I monitor uptime on a schedule? Yes: create a Task with loadTest off, add a Schedule, and an integration (Slack, email, webhook) on runs whose SUMMARY.verdict is fail.

Related actors

• Google Search Results Scraper: check where your pages rank on Google after a speed fix.
• Semrush Keyword & SEO Data: keyword volumes, domain overview and backlinks for your website.