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 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.

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)

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 to let Claude check website uptime 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

• "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?"

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.

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.

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