# Website Uptime Checker (`maged120/website-uptime-checker`) Actor

Checks whether websites are up or down and returns response time, SSL, hosting, domain age and uptime history for each one.

- **URL**: https://apify.com/maged120/website-uptime-checker.md
- **Developed by:** [Maged](https://apify.com/maged120) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

Check whether any list of websites is **up or down** — and get the response time, SSL status, hosting, domain age and running uptime record for each one, in a single run.

### What does Website Uptime Checker do?

Website Uptime Checker takes a list of websites and tells you, for every one of them, whether it is **online right now**, how fast it responded, and what is wrong when it isn't. Each result also carries the context you normally have to chase across three other tools: the SSL certificate and when it expires, the CDN and server behind the site, the IP addresses it resolves to, the registrar, and how long the domain has been registered.

Run it once for a snapshot, or **schedule it** and it builds an uptime record: every result then shows how long the site has been up (or down), the uptime percentage across all checks, and how many checks failed in a row. Results land in a structured dataset you can export as JSON, CSV, Excel or HTML, pull through the Apify API, or wire into Slack, Zapier, Make and Google Sheets.

### Why use Website Uptime Checker?

- **Bulk monitoring** — check hundreds of sites in one run instead of one at a time.
- **Client and portfolio checks** — agencies verifying every client site is live, fast and holding a valid certificate.
- **Certificate expiry alerts** — catch a cert with 9 days left before your visitors do.
- **Lead qualification and audits** — spot prospects on dead sites, expired domains or missing HTTPS.
- **Migration and deploy verification** — confirm redirects resolve and the new host is serving traffic.
- **Domain due diligence** — registration date, age, registrar and expiry for every domain you check.
- **Downtime evidence** — a timestamped, exportable record of when a site went down and when it came back.

### How to use Website Uptime Checker

1. Click **Try for free**.
2. Paste your websites into the **Websites to Check** field, one per line. The `https://` prefix is optional.
3. Leave **Track Uptime History** on so repeat runs build an uptime record.
4. Click **Start** and wait — most lists finish in well under a minute.
5. Open the **Output** tab and switch between the Status Overview, Uptime History, SSL & Domain, and Hosting & Tech views, or export the whole dataset.
6. Optional: hit **Schedule** and run it every hour or every day for continuous monitoring.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `urls` | array | — | Websites to check, up to 1000 per run. Prefix optional, duplicates removed. |
| `includeDomainInfo` | boolean | `true` | Adds registrar, registration date, domain age and expiry. |
| `trackHistory` | boolean | `true` | Remembers previous runs to compute up-since, uptime % and failure streaks. |
| `proxyConfiguration` | object | off | Optional. Checks run direct by default for the most accurate reading. |

```json
{
    "urls": ["https://apify.com", "example.com", "shop.mystore.com"],
    "includeDomainInfo": true,
    "trackHistory": true,
    "proxyConfiguration": { "useApifyProxy": false }
}
```

### Output

One row per website. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
    "url": "https://apify.com",
    "host": "apify.com",
    "checkedAt": "2026-09-04T10:42:28+00:00",
    "isUp": true,
    "statusCode": 200,
    "statusText": "OK",
    "responseTimeMs": 738,
    "finalUrl": "https://apify.com/",
    "redirected": false,
    "redirectCount": 0,
    "errorType": null,
    "error": null,
    "ipAddresses": ["52.84.45.10", "52.84.45.46"],
    "server": null,
    "cdn": "Amazon CloudFront",
    "poweredBy": null,
    "hstsEnabled": true,
    "contentType": "text/html; charset=utf-8",
    "contentLengthBytes": 473582,
    "pageTitle": "Apify: The largest marketplace of trusted tools for AI",
    "sslValid": true,
    "sslIssuer": "Amazon",
    "sslSubject": "*.apify.com",
    "sslIssuedAt": "2026-07-03T00:00:00+00:00",
    "sslExpiresAt": "2027-01-16T23:59:59+00:00",
    "sslDaysRemaining": 134,
    "sslCertAgeDays": 63,
    "domain": "apify.com",
    "registrar": "Amazon Registrar, Inc.",
    "domainCreatedAt": "2009-06-02T17:14:10Z",
    "domainAgeDays": 6302,
    "domainExpiresAt": "2035-06-02T17:14:10Z",
    "upSince": "2026-08-28T09:00:00+00:00",
    "downSince": null,
    "currentStateForHours": 169.7,
    "uptimePercent": 99.41,
    "checksTotal": 170,
    "checksUp": 169,
    "consecutiveFailures": 0,
    "lastStatusChangeAt": "2026-08-28T09:00:00+00:00",
    "lastUpAt": "2026-09-04T10:42:28+00:00",
    "lastDownAt": "2026-08-28T08:00:00+00:00"
}
```

A site that is down looks like this:

```json
{
    "url": "https://this-site-does-not-exist-9x8k.com",
    "isUp": false,
    "statusCode": null,
    "errorType": "dns_failure",
    "error": "The hostname could not be resolved.",
    "downSince": "2026-09-04T10:42:31+00:00",
    "consecutiveFailures": 3,
    "uptimePercent": 0.0
}
```

#### Data fields

| Field | What it tells you |
|---|---|
| `isUp` | `true` when the site responded normally. |
| `statusCode`, `statusText` | The HTTP response, e.g. `200 OK` or `503 Service Unavailable`. |
| `responseTimeMs` | Full round trip, including redirects, in milliseconds. |
| `errorType`, `error` | Why it is down: `dns_failure`, `connection_refused`, `connection_timeout`, `read_timeout`, `ssl_error`, `redirect_loop`, `http_error`. |
| `finalUrl`, `redirected`, `redirectCount` | Where the request actually ended up. |
| `ipAddresses` | Every IPv4/IPv6 address the hostname resolves to. |
| `server`, `poweredBy`, `cdn`, `hstsEnabled` | Hosting stack: Cloudflare, CloudFront, Fastly, Akamai, Vercel, Netlify, Sucuri and more. |
| `pageTitle`, `contentType`, `contentLengthBytes` | Confirms real content was served, not a parked or error page. |
| `sslValid`, `sslIssuer`, `sslExpiresAt`, `sslDaysRemaining` | Certificate health — the expiry warning you actually want. |
| `sslCertAgeDays` | How long the current certificate has been in service. |
| `domain`, `registrar`, `domainCreatedAt`, `domainAgeDays`, `domainExpiresAt` | Domain registration record and age. |
| `upSince` / `downSince` | When the site entered its current state, across all your runs. |
| `currentStateForHours` | How many hours it has held that state. |
| `uptimePercent`, `checksTotal`, `checksUp` | The uptime ratio built from every check this Actor has made. |
| `consecutiveFailures` | Failures in a row — the number to alert on. |
| `lastStatusChangeAt`, `lastUpAt`, `lastDownAt` | Timestamps of the last flip, last success and last failure. |

### Dataset views

- **Status Overview** — up/down, HTTP status, response time, uptime %, problem.
- **Uptime History** — up-since, hours in state, uptime %, failure streaks, status changes.
- **SSL & Domain** — certificate validity, issuer, expiry, domain age and registrar.
- **Hosting & Tech** — IPs, server, CDN, redirects, HSTS, page title and size.

### How much does it cost to check websites?

Billing is per result, and **one website is one result**. Checking 100 sites costs the same as 100 results, whether they are up or down.

| Websites checked | Results | Notes |
|---|---|---|
| 25 | 25 | Typical agency client portfolio |
| 100 | 100 | Finishes in roughly half a minute |
| 1000 | 1000 | The per-run maximum |

Scheduling multiplies this: 50 sites checked hourly is 1200 results a day. For continuous monitoring, an hourly or daily schedule is usually the right balance.

### Tips

- **Schedule it** — the uptime fields (`upSince`, `uptimePercent`, `consecutiveFailures`) only become meaningful once the Actor has several runs behind it. A single run always reports 100% or 0%.
- **Alert on `consecutiveFailures >= 2`**, not on a single failure — one blip is usually the network, not the site. Transient blips are already filtered out before a site is reported down.
- **Watch `sslDaysRemaining`** — filter for anything under 30 and you will never be surprised by an expired certificate.
- **Turn off Domain Info** for the fastest possible runs when you only care about up/down.
- **Leave the proxy off** unless a target blocks datacenter traffic or you specifically need to check from another country — a direct check is the most honest reading of availability.
- **Check the exact URL your users visit**, including the path, if you want to catch a broken page rather than just a live server.

### FAQ

**What counts as "up"?**
It pings each site to see whether it responds like a working site would. If it doesn't answer normally, it's reported as down with the reason, because visitors couldn't use it either.

**Why does the first run show 100% uptime?**
Because it is the first data point. Uptime percentage is built from the checks this Actor has actually made, so it becomes useful after the Actor has been running on a schedule for a while.

**Does it detect why a site is slow?**
It reports the total response time, the CDN, the server and the resolved IPs, which is usually enough to point at the cause. It does not run a full performance audit.

**Can it check non-web ports or APIs?**
It checks anything reachable over HTTP or HTTPS, including API endpoints. Non-HTTP services are out of scope.

**Is this legal?**
Yes. The Actor simply pings each site to see if it's up, the same way any visitor's browser would reach it, and reads only publicly published information.

### Support

Found a problem or want a field added? Open an issue on the **Issues** tab and it will be looked at. Custom monitoring setups and integrations can be arranged on request.

# Actor input Schema

## `urls` (type: `array`):

Websites to check (up to 1000 per run). The https:// prefix is optional and duplicates are removed automatically.

## `includeDomainInfo` (type: `boolean`):

Adds registrar, domain registration date, domain age and expiry date to every result. Turn off for slightly faster runs.

## `trackHistory` (type: `boolean`):

Remembers results between runs so each result shows how long the site has been up (or down), its uptime percentage and consecutive failures. Schedule this Actor to build a real uptime record.

## `proxyConfiguration` (type: `object`):

Optional. Checks run direct by default, which gives the most accurate availability reading. Enable a proxy only if you need to check from a specific country or a target blocks datacenter traffic.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com",
    "https://example.com",
    "https://this-site-does-not-exist-9x8k.com"
  ],
  "includeDomainInfo": true,
  "trackHistory": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://apify.com",
        "https://example.com",
        "https://this-site-does-not-exist-9x8k.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("maged120/website-uptime-checker").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "urls": [
        "https://apify.com",
        "https://example.com",
        "https://this-site-does-not-exist-9x8k.com",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("maged120/website-uptime-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "urls": [
    "https://apify.com",
    "https://example.com",
    "https://this-site-does-not-exist-9x8k.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call maged120/website-uptime-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,maged120/website-uptime-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Jde4QuH9fEqaSzoZp/builds/yAJi7oPeng6r6Snhc/openapi.json