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 HTTP requests and measuring response times. It reports status codes, response times, content type, server headers, SSL validity, and redirect chains. Feed it a list of URLs and get back structured data about whether each site is up, how fast it responds, and whether its SSL certificate is valid. Run it on a schedule to build a continuous uptime monitoring system with historical data.

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?

• Batch processing -- check hundreds of URLs in a single run instead of pinging them one by one
• Comprehensive response data -- returns status code, response time, content type, server header, and SSL validity in one call
• Redirect tracking -- detects whether a URL redirected and reports the final destination URL and redirect status
• SSL monitoring -- validates SSL certificates so you can catch expirations before they cause browser warnings
• 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, starting at $0.001 per URL

Input parameters

Parameter	Type	Required	Default	Description
urls	array	Yes	--	List of URLs to check uptime for

Provide full URLs including the protocol (e.g., https://example.com). Each URL is checked independently with its own HTTP request and timing measurement.

Input example

{
    "urls": [
        "https://www.google.com",
        "https://www.github.com",
        "https://example.com"
    ]
}

Output example

Each result includes the URL, up/down status, status code, response time, content metadata, SSL validity, and redirect information.

{
    "url": "https://www.google.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,
    "error": null,
    "checkedAt": "2026-03-01T12:00:00.000Z"
}

How much does it cost?

Website Uptime 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 50 URLs: $0.035 + (50 x $0.001) = $0.085
• Checking 100 URLs: $0.035 + (100 x $0.001) = $0.135
• Checking 500 URLs: $0.035 + (500 x $0.001) = $0.535

Using the Apify API

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 the two most common languages.

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)

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

• Schedule frequent checks -- set up an Apify schedule to run every 5-15 minutes for critical sites to catch downtime early.
• Monitor redirect chains -- unexpected redirects (e.g., to a parking page) can indicate domain expiration or DNS hijacking.
• Watch SSL validity -- the sslValid field flags expired or misconfigured certificates before they cause browser warnings for visitors.
• 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).

FAQ

Does this actor follow redirects? Yes. If a URL redirects, the actor follows the chain and reports the final URL in the finalUrl field, along with redirected: true. The status code reflects the final response.

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? A URL is considered "up" if the HTTP request completes successfully and returns a status code in the 2xx or 3xx range. Status codes 4xx and 5xx, timeouts, and connection errors result in isUp: false.

What timeout is used for requests? The actor uses a reasonable default timeout for HTTP requests. If a server does not respond within the timeout window, the URL is marked as down with a timeout error in the error field.

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.