Website Uptime Checker

Check if websites are up and measure response times with status codes.

What does Website Uptime Checker do?

This actor checks website uptime by making lightweight HTTP requests and measuring response times. It reports status codes, response times, content metadata, verified HTTPS handshakes, redirect chains, and structured errors. Feed it public URLs and get one typed result per unique normalized URL. Run it on an Apify schedule and connect webhooks to build an uptime workflow.

Use cases

• Site reliability engineers -- monitor whether critical websites and services are up and responsive on an ongoing basis
• DevOps teams -- verify server headers, SSL certificates, and redirect behavior after deployments or infrastructure changes
• Marketing managers -- check that campaign landing pages are live and responding before launching paid ads
• Freelancers and agencies -- provide clients with uptime reports showing response times, status codes, and SSL status
• SEO professionals -- detect downtime or redirect issues that can hurt search rankings and crawl budgets
• E-commerce operators -- monitor storefront availability during peak traffic periods like sales events

Why use Website Uptime Checker?

• Concurrent batch processing -- check up to 1,000 unique URLs with configurable concurrency
• Comprehensive response data -- returns status code, response time, content type, server header, and TLS diagnostics in one call
• Redirect tracking -- safely follows up to 10 redirects and reports every URL in the chain
• Expected-status rules -- treat only your chosen statuses, such as 200 or 204, as healthy
• Structured JSON output -- consistent schema ready for dashboards, spreadsheets, and alerting pipelines
• API and schedule ready -- automate uptime checks via the Apify API or set up scheduled monitoring at any interval
• Pay-per-event pricing -- you only pay for the URLs you check, with tiered per-URL pricing that decreases at higher Apify plan tiers

Who is it for?

Website Uptime Checker is built for DevOps engineers, site reliability teams, SEO consultants, digital agencies, e-commerce operators, and founders who need lightweight uptime evidence without running a full monitoring stack. It is also useful for automation builders who want a simple Apify API endpoint that turns a list of URLs into structured status, latency, SSL, redirect, and header data.

Input parameters

Parameter	Type	Required	Default	Description
urls	array	Yes	--	Up to 1,000 full public http:// or https:// URLs
timeoutSecs	integer	No	15	Timeout for each HEAD or fallback range GET request (1–120 seconds)
maxConcurrency	integer	No	10	Maximum simultaneous URL checks (1–25)
expectedStatusCodes	integer array	No	--	Exact final statuses considered healthy (100–599)

URLs must include the protocol. The Actor removes fragments, canonicalizes hostnames/default ports, and checks each first-seen normalized URL once. Malformed, unsupported, credential-bearing, loopback, private, and reserved destinations produce diagnostic rows instead of requests. At every redirect hop, DNS results are validated and the HTTP connection is pinned to those validated public addresses.

Input example

{
    "urls": [
        "https://status.apify.com",
        "https://docs.apify.com",
        "https://console.apify.com"
    ],
    "timeoutSecs": 15,
    "maxConcurrency": 10,
    "expectedStatusCodes": [200, 204]
}

Output example

Each result includes the URL, up/down status, actual HTTP status text, response time, content metadata, TLS result, complete redirect chain, expected-status match, response headers, and a stable error category when no response is available.

{
    "url": "https://status.apify.com",
    "isUp": true,
    "statusCode": 200,
    "statusText": "OK",
    "responseTimeMs": 156,
    "contentLength": 14523,
    "contentType": "text/html; charset=UTF-8",
    "server": "gws",
    "sslValid": true,
    "redirected": false,
    "finalUrl": null,
    "redirectCount": 0,
    "redirectChain": ["https://status.apify.com/"],
    "headers": { "content-type": "text/html; charset=UTF-8" },
    "errorType": null,
    "error": null,
    "matchesExpectedStatus": true,
    "checkedAt": "2026-09-19T12:00:00.000Z"
}

How to check website uptime

1. Open Website Uptime Checker on Apify.
2. Enter one or more URLs in the urls field.
3. Click Start and wait for the check to finish.
4. Review status codes, response times, and SSL validity in the Dataset tab.
5. Download results as JSON, CSV, or Excel.
6. Optionally set up a recurring schedule for continuous monitoring.

How much does it cost to check website uptime?

Website Uptime Checker uses Apify's pay-per-event pricing model. You are only charged for what you use.

The one-time start charge is $0.035 per run. Each checked URL uses the tiered rate for your Apify plan:

Apify plan tier	Price per URL checked
Free	$0.00030445
Bronze	$0.00026474
Silver	$0.00020650
Gold	$0.00015884
Platinum	$0.00010590
Diamond	$0.000074127

The total Actor charge is number of runs × $0.035 + URLs checked × your tier rate. Check the live Pricing tab on Apify for the authoritative rate for your plan.

API usage

You can call Website Uptime Checker programmatically from any language using the Apify API. The actor slug is automation-lab/website-uptime-checker. Below are examples for common API clients.

Using the Apify API

The examples below show how to start a run, pass URLs, and fetch the output dataset after the run completes.

Node.js

import { ApifyClient } from 'apify-client';

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

cURL

curl -X POST "https://api.apify.com/v2/acts/automation-lab~website-uptime-checker/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["https://www.google.com", "https://www.github.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.

Setup for Claude Code

$claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/website-uptime-checker"

Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/website-uptime-checker"
        }
    }
}

Example prompts

• "Is this website currently up: https://example.com?"
• "Check uptime status for these 20 domains"
• "Which of these sites are down right now and what error codes are they returning?"

Learn more in the Apify MCP documentation.

Integrations

Website Uptime Checker integrates with the major automation and data platforms through the Apify ecosystem:

• Make (formerly Integromat) -- trigger uptime checks on a schedule and send alerts when a site goes down.
• Zapier -- create Zaps that notify you via email, SMS, or PagerDuty when any monitored URL becomes unreachable.
• Google Sheets -- push results to a spreadsheet for historical uptime tracking and SLA reporting.
• Slack -- send notifications to a channel when isUp returns false so your team can respond immediately.
• Webhooks -- feed results into your own monitoring dashboard or incident management system.
• n8n -- orchestrate runs from n8n workflows or any platform that supports HTTP requests and the Apify REST API.

Tips and best practices

• Choose schedule frequency deliberately -- every run has a start charge, so balance detection speed against cost.
• Monitor redirect chains -- redirectChain lists every followed URL; unexpected destinations can indicate configuration or domain problems.
• Interpret TLS correctly -- sslValid: true means an HTTPS handshake succeeded, false means a confirmed certificate error, and null means TLS was not established or was not applicable.
• Track response times -- export results to a spreadsheet over time to spot performance degradation trends and seasonal patterns.
• Pair with alerting -- combine with Slack or email webhooks to get instant notifications when any monitored URL goes down.
• Group URLs by priority -- run critical production URLs on a tight schedule (every 5 minutes) and less important pages on a longer cycle (hourly or daily).

How do I set up free website uptime monitoring?

Many uptime monitoring services use monthly subscriptions. Website Uptime Checker instead charges per run and per URL checked:

1. Create an Apify account and review the credits included with your plan
2. Open Website Uptime Checker and enter your URLs
3. Set up a schedule — choose a frequency that balances detection speed and the per-run start charge
4. Add a webhook — send alerts to Slack, Discord, email, or PagerDuty when a URL returns isUp: false

Example Actor charge: checking 10 URLs once per day for 30 days costs about $1.14 on the Free tier: 30 starts × $0.035 plus 300 URL checks × $0.00030445. Checking every 15 minutes would trigger 2,880 start charges per 30-day month, so review the live Pricing tab before choosing a high-frequency schedule.

What is the difference between uptime monitoring and health checking?

Uptime monitoring answers a simple question: "Is this URL responding as expected?" It checks HTTP status codes, response times, redirects, and TLS handshakes. Runtime depends on the target and configured timeout; concurrent checks keep batches efficient.

Health checking goes deeper: it audits security headers, meta tags, DNS configuration, and page performance with a weighted scoring system. It takes 2-5 seconds per URL and is designed for periodic comprehensive audits.

Use Website Uptime Checker for continuous monitoring (every 5-15 minutes) to catch outages quickly. Use Website Health Report for weekly or monthly deep audits to track security and SEO health over time. Both tools complement each other.

How do I monitor SSL certificate expiration?

SSL certificate expiration is one of the most common causes of website downtime. When a certificate expires, browsers show security warnings that block visitors.

Website Uptime Checker reports sslValid: true after a successful verified HTTPS handshake and false only for a confirmed certificate error. It reports null for plain HTTP and failures where no certificate conclusion is possible. Set up a scheduled run and monitor this field together with errorType.

For proactive monitoring before expiration, pair this with Website Health Report which reports the exact SSL expiry date and warns you when certificates are within 30 days of expiration.

Data handling, limitations, and support

The Actor makes deterministic HTTP requests and does not use an AI provider. It sends each accepted public URL to that website, stores response metadata in the run's default Apify dataset, and logs the normalized URL plus operational status. It does not store response bodies, cookies, credentials, or data in an external cache. Dataset, key-value-store, and log retention follow your Apify account settings; delete them with Apify's storage controls.

Results reflect the network path from Apify's cloud. A website can block data-center traffic, require JavaScript, or vary by geography. A timeout applies separately to the HEAD request and, when a server returns an error status, the fallback one-byte range GET. The Actor verifies certificate validity during the connection but does not report certificate expiry dates in advance.

For product support, use the Issues tab on the Actor's Apify Store page. This product is an independent HTTP utility and is not affiliated with the websites checked by its users.

Legality

Is it legal to check website uptime?

Yes. Website Uptime Checker sends standard HTTP requests to publicly accessible URLs — the same type of request any web browser makes. No authentication is bypassed, no private data is accessed, and no terms of service are violated.

Uptime monitoring is a standard practice used by millions of website operators, DevOps teams, and service providers. Commercial monitoring services like Pingdom, UptimeRobot, and StatusCake have operated in this space for years.

Key points:

• Only publicly accessible URLs are checked
• The tool sends standard HTTP requests, just like a browser
• No login credentials or private APIs are used
• Request frequency is configurable to avoid excessive load

For more details, see the Apify guide on ethical web scraping.

FAQ

Does this actor follow redirects? Yes. The Actor safely follows up to 10 hops, reports every visited URL in redirectChain, and provides redirectCount, finalUrl, and the final response status. Every redirect destination is checked against private-network access before it is requested.

Can I monitor internal or private URLs? No. The actor runs on Apify's cloud infrastructure and can only reach publicly accessible URLs. For internal monitoring, you would need to deploy the actor on a self-hosted Apify instance with network access.

How is isUp determined? Without expectedStatusCodes, a final 2xx or 3xx response is up. When expected statuses are provided, isUp is true only when the final status is in that list, and matchesExpectedStatus reports the same decision. Without the option, matchesExpectedStatus is null. Timeouts, validation failures, and network errors are down.

What timeout is used for requests? The default is 15 seconds per HEAD or fallback range GET request. Set timeoutSecs from 1 to 120. A timed-out URL is emitted with isUp: false, errorType: "timeout", and details in error; it does not fail the full batch.

Can I export results to CSV or Google Sheets? Yes. Apify datasets support export in JSON, CSV, Excel, XML, and other formats. You can download results from the Apify Console or use the API. For Google Sheets, use the built-in Apify integration or connect via Make or Zapier.

A site shows isUp: false but I can access it in my browser. Why? The actor runs from Apify's cloud infrastructure. The site may be blocking requests from data center IP ranges, applying geographic restrictions, or requiring a browser (JavaScript challenge, CAPTCHA). Some sites also return 403 status codes to non-browser user agents. The error and statusCode fields will help identify the specific cause.

The response time seems very slow compared to my own experience. What is happening? Response time depends on the network path between Apify's servers and the target website. Geographic distance, CDN configuration, and server load all affect timing. The measurement reflects server response time from Apify's data center, not from your local network. For consistent monitoring, schedule regular runs and track trends rather than comparing to browser-based measurements.

Related actors

Other developer tools on Apify

• WHOIS Lookup -- look up domain registration data for any domain
• Website Health Report -- comprehensive website health audit with scoring
• Website Performance Checker -- measure TTFB, page size, and compression
• Website Change Monitor -- track web page content changes automatically