# Website Status Checker - Uptime URL Monitor (`benthepythondev/website-status-checker`) Actor

Check website status, final URL, response time, redirects, content type, page title and basic availability for lists of URLs.

- **URL**: https://apify.com/benthepythondev/website-status-checker.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Automation, SEO tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 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/platform/actors/running/actors-in-store#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

## Website Status Checker - Uptime URL Monitor

Check website availability for a list of URLs and export status codes, response times, final URLs, redirect counts, content types, page titles and server hints. This actor is built for lightweight uptime checks, SEO QA, migration monitoring and domain portfolio audits.

### What is the Website Status Checker?

When a website changes, the first question is simple: does the URL still work? This actor answers that question in a structured way. It fetches each URL, follows redirects, measures response time and records the final status in an Apify dataset.

Unlike a full crawler, this actor checks only the URLs you provide. That makes it fast, predictable and cheap to run. It is useful when you already have a known list of important pages from a sitemap, CRM, ad campaign, backlink export, ecommerce feed or manual audit.

### Common use cases

Use this actor to monitor landing pages, verify client websites, check URLs after a migration, audit backlink targets, test ecommerce category pages, monitor API documentation pages, validate campaign links or watch a list of important domains.

SEO teams can catch 404s, redirect changes and slow pages. Marketing teams can verify ad and email campaign destinations. Agencies can run recurring checks for client reporting. Developers can add it to a release QA workflow.

### Input

Provide one or more URLs or domains.

```json
{
  "urls": [
    "https://apify.com",
    "https://example.com"
  ]
}
```

### Output

Each dataset item represents one checked URL.

```json
{
  "input": "https://apify.com",
  "url": "https://apify.com",
  "final_url": "https://apify.com/",
  "domain": "apify.com",
  "status_code": 200,
  "ok": true,
  "response_time_ms": 420,
  "redirect_count": 0,
  "content_type": "text/html; charset=utf-8",
  "content_length": 12345,
  "title": "Apify: Full-stack web scraping and data extraction platform",
  "server": "cloudflare",
  "error": null
}
```

### Output fields

- `input` - original input value.
- `url` - normalized URL.
- `final_url` - final destination after redirects.
- `domain` - final URL domain.
- `status_code` - HTTP status code.
- `ok` - true for 2xx and 3xx responses.
- `response_time_ms` - measured response time.
- `redirect_count` - number of redirects followed.
- `content_type` and `content_length` - response metadata.
- `title` - extracted page title when available.
- `server` - server header when exposed.
- `error` - connection or timeout error.

### Why use this actor?

A simple URL status dataset is useful in many workflows. It can feed dashboards, trigger alerts, support SEO reports, validate campaign links or enrich a larger crawl. Apify gives you scheduling, webhooks, exports and API access without maintaining a separate monitoring script.

### Example workflows

Extract URLs from a sitemap, run this actor against them, and filter for non-200 results. Export backlink URLs from an SEO tool and check which targets are now broken. Run it every hour for high-value landing pages and notify a Slack channel when `ok` changes from true to false.

For paid campaigns, check every destination URL before launch and again after major website releases. For content teams, monitor important evergreen pages and update reports when a page redirects or disappears. For agencies, schedule recurring checks across client websites and include the export in monthly technical summaries.

### Integration ideas

Use Apify webhooks to trigger notifications when a run completes. Send rows with `ok = false` into Slack, email, Google Sheets, Airtable, Make, Zapier or n8n. Store historical results in a database if you want trend lines for response time or a record of when a page started redirecting.

The actor works well after URL discovery. Collect URLs from XML sitemaps, RSS feeds, exported ad campaigns, backlink tools or website crawls, then pass that focused list into this checker. This keeps the run small and the output actionable.

### Best practices

Use focused URL lists. For whole-site discovery, collect URLs first with a sitemap or crawler, then pass the important URLs here. Watch both `status_code` and `final_url`; a page can return 200 but redirect to the wrong destination. For alerting, compare results against a previous run instead of treating every temporary timeout as an incident.

Check a mix of templates, not only the homepage. Product pages, blog posts, documentation pages and checkout routes can fail independently. For migration QA, save a baseline before launch and compare final URLs after launch. For monitoring, choose realistic alert thresholds so one temporary network issue does not create noise.

### Data quality notes

The actor reads server-returned HTML and extracts the `<title>` tag when available. It does not execute JavaScript. Response time is measured from the Apify runtime and is best used for relative monitoring, not as a global user-performance metric. Some protected sites may return different responses to automated checks; the `error` and `status_code` fields make those cases visible.

### FAQ

Is this a full uptime monitoring platform?

No. It is a simple Apify actor for structured URL checks, exports and automations.

Does it follow redirects?

Yes. It follows redirects and reports the final URL and redirect count.

Can it check many URLs?

Yes. Add the URLs in the input list and export the combined dataset.

Does it render JavaScript?

No. It performs direct HTTP checks for speed and reliability.

### You might also like

- HTTP Headers Checker - inspect response headers.
- Sitemap URL Extractor - collect URLs from XML sitemaps.
- URL Shortener Expander - inspect redirect chains.

### Keywords

website status checker, uptime checker, URL monitor, HTTP status checker, broken link checker, SEO URL audit, page status API, Apify uptime checker.

### Support and feedback

If this Actor saves time in your workflow, please leave a short Apify Store review. Reviews help other users evaluate the tool and help prioritize maintenance. If a source changes or a field stops populating, open an Actor issue with the run ID, public input, and expected field. Never include passwords, private cookies, or confidential data.

# Actor input Schema

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

Websites or URLs to check.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com",
    "https://example.com"
  ]
}
```

# Actor output Schema

## `results` (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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/website-status-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",
    ] }

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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"
  ]
}' |
apify call benthepythondev/website-status-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=benthepythondev/website-status-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/F4E7qudU81DUx9pGs/builds/sKaP5oKkblzDjyi9X/openapi.json