# Website EOL Risk Scanner (`vladkuz/website-eol-risk-scanner`) Actor

Find websites running end-of-life PHP, WordPress, Joomla, Drupal, jQuery, Bootstrap and more. Each site gets a 0-100 risk score and a plain-language summary. A ready-made sales signal for web agencies. Failed sites are free.

- **URL**: https://apify.com/vladkuz/website-eol-risk-scanner.md
- **Developed by:** [Vladimír Kuzněcov](https://apify.com/vladkuz) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 website scanneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Website EOL Risk Scanner: find outdated websites in bulk

Website EOL Risk Scanner is an **outdated website checker** for whole lists of sites. Give it websites or bare domains. It tells you which ones run software that no longer gets security fixes (end-of-life PHP, WordPress, Joomla, Drupal, jQuery, Bootstrap and more) and scores each website from 0 to 100.

Think of it as a bulk **PHP version checker**, **WordPress version checker** and **end-of-life software scanner** in one, with a plain-language summary for every site.

Built for web agencies and freelancers who sell upgrades, migrations and maintenance: an outdated stack is a concrete, checkable reason to get in touch.

### Use cases

- **Find clients for website maintenance.** Scan the websites of companies in your region or industry and contact the ones running unsupported software. Get the list from any source: a CRM export, a directory, or a Google Maps scraper on Apify Store.
- **Audit your own portfolio.** Agencies and IT teams that look after dozens of websites can schedule a weekly scan and see which ones need an upgrade before a client asks.
- **Back up an upgrade proposal.** The summary sentence ("WordPress 4.9.8 reached end of life on 2022-12-01") goes straight into an email or an offer.
- **Enrich leads.** Add an "outdated website" signal to every company row in Clay, n8n, Make or your own pipeline.
- **First look before a security review.** See the visible stack of many websites in minutes, before deeper testing.

### What you get for each website

- **Risk score and level**: `none`, `low`, `medium`, `high` or `critical`.
- **A summary you can paste into an email**: "PHP 7.4.33 reached end of life on 2022-11-28 (3 years ago)."
- **Every detected technology** with its version, end-of-life date, the latest available version, and the evidence it was detected from.
- **Early warnings**: technologies that reach end of life soon, and ones that only get security fixes any more.

End-of-life dates come from [endoflife.date](https://endoflife.date) and are loaded fresh on every run.

### What it detects

| Kind | Technologies |
| --- | --- |
| Language | PHP |
| CMS and e-commerce | WordPress, Joomla, Drupal, TYPO3, Magento |
| Framework | Laravel, Yii (presence only) |
| Web server | nginx, Apache HTTP Server, OpenSSL |
| JavaScript libraries | jQuery, Bootstrap, AngularJS |

Detection reads what the website itself publishes: response headers, the generator tag, the addresses of scripts and stylesheets and, with deep scan, the version banners inside self-hosted library files. That last step matters: frameworks such as Yii and Laravel serve jQuery and Bootstrap from hashed folders where the address shows no version.

### Input

| Field | Default | What it does |
| --- | --- | --- |
| `urls` | required | Websites to scan. Bare domains such as `example.com` work; HTTPS is tried first, then HTTP. |
| `deepScan` | `true` | When versions are hidden, reads them from public files: the WordPress feed or Joomla manifest, and the licence banner of up to two self-hosted libraries. Up to three extra requests per website. |
| `onlyAtRisk` | `false` | Saves only websites with a risk score above 0. Failed websites are always saved. |
| `eolWarningDays` | `180` | Technologies reaching end of life within this many days are reported as `eol-soon`. |
| `maxConcurrency` | `10` | Websites scanned in parallel. |
| `requestTimeoutSecs` | `30` | How long to wait for a website. |
| `respectRobotsTxt` | `true` | Skips websites whose robots.txt disallows the page. |

```json
{
    "urls": ["example.com", "https://another-example.org"],
    "onlyAtRisk": true
}
```

### Output

One dataset item per website:

```json
{
    "url": "example.com",
    "finalUrl": "https://www.example.com/",
    "status": "ok",
    "httpStatus": 200,
    "riskScore": 100,
    "riskLevel": "critical",
    "eolCount": 2,
    "eolSoonCount": 0,
    "securityOnlyCount": 0,
    "eolTechnologies": "PHP 5.6.40, WordPress 4.9.8",
    "summary": "WordPress 4.9.8 reached end of life on 2022-12-01 (3 years ago). PHP 5.6.40 reached end of life on 2018-12-31 (7 years ago).",
    "technologies": [
        {
            "name": "PHP",
            "slug": "php",
            "category": "language",
            "version": "5.6.40",
            "status": "eol",
            "eolDate": "2018-12-31",
            "daysPastEol": 2878,
            "daysUntilEol": null,
            "supportEndDate": null,
            "daysPastSupport": null,
            "latestVersion": "8.5.12",
            "note": null,
            "evidence": "X-Powered-By: PHP/5.6.40"
        }
    ],
    "errorMessage": null,
    "scannedAt": "2026-11-17T08:00:00.000Z"
}
```

`status` is `ok`, `failed` (the website did not respond or the URL is invalid) or `skipped` (disallowed by robots.txt). Each technology has one of these statuses:

| Status | Meaning |
| --- | --- |
| `eol` | End of life: no fixes of any kind. |
| `eol-soon` | End of life comes within the warning window. |
| `security-only` | Active support is over; only security fixes are still released. |
| `supported` | Fully supported. |
| `unknown` | Detected, but the version is hidden or not tracked. |

### Pricing

You pay per website that was scanned successfully. Websites that fail to load, invalid URLs and websites skipped because of robots.txt are free. Set **Maximum cost per run** in the run options to cap a run: the Actor stops cleanly when the limit is reached.

### Use it from AI agents, Clay, n8n or the API

**AI agents (MCP).** Add `https://mcp.apify.com/?tools=vladkuz/website-eol-risk-scanner` to Claude, Cursor, VS Code or any MCP client. Then ask in plain words, for example: "Which of these 20 websites run end-of-life PHP?"

**API.** Run it and get the results in one request:

```bash
curl -X POST "https://api.apify.com/v2/acts/vladkuz~website-eol-risk-scanner/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["example.com", "example.org"], "onlyAtRisk": true}'
```

**Clay, n8n, Make, Zapier.** Use the Apify integration in your tool, pick this Actor and map the website column to `urls`. Use `riskLevel`, `riskScore` and `summary` from the output to filter and personalise outreach.

**Schedules.** In Apify Console, create a task with your list and a schedule (for example every Monday) to monitor your own websites.

### How the score works

Each end-of-life technology adds points by how exposed it is: a CMS adds 40, a language or framework 35, a web server 20, a JavaScript library 10. The longer past end of life, the more it adds, up to one and a half times after four years. A technology reaching end of life soon counts for a quarter. A technology on security fixes only counts for a quarter too, growing to three quarters once active support has been over for four years. The total is capped at 100.

| Score | Level |
| --- | --- |
| 0 | none |
| 1 to 24 | low |
| 25 to 49 | medium |
| 50 to 74 | high |
| 75 to 100 | critical |

### Limits

- A score of 0 means nothing outdated is **visible**, not that the website is up to date. Many websites hide their versions; those technologies are reported as `unknown`.
- Some Linux distributions keep patching old versions themselves (for example PHP on RHEL or Ubuntu LTS). The scanner cannot see that, so treat a finding as a reason to ask, not as proof of a vulnerability.
- Only the given page is fetched (plus up to three small requests with deep scan). The scanner does not crawl the website, log in, or test for vulnerabilities.

### FAQ

**Is it legal to scan websites with this?** The scanner reads only what every visitor's browser receives: the homepage, its headers and a few public files. It respects robots.txt by default, does not log in and does not test for vulnerabilities. You are still responsible for how you use the results.

**Do I need proxies?** No. Each website gets one page request plus up to three small ones.

**Why is a technology "unknown"?** The website shows that it uses it but hides the version, or the product has no published end-of-life dates.

**Does a score of 0 mean the website is safe?** No. It means nothing outdated is visible from the outside. See Limits below.

**How fresh are the end-of-life dates?** They are loaded from endoflife.date at the start of every run.

**A technology is missing.** Open an issue on the Issues tab and say which one; popular requests get added.

### Related tools

- [endoflife.date](https://endoflife.date): the open database of release cycles this Actor uses.
- [Apify Store](https://apify.com/store): find Actors that build the list of websites to scan, such as Google Maps or business directory scrapers.

### Run it locally

```bash
npm install
apify run
npm test
```

Put the input in `storage/key_value_stores/default/INPUT.json`. Set the `EOL_API_BASE_URL` environment variable to load end-of-life data from another endoflife.date-compatible source.

# Actor input Schema

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

Website URLs or bare domains, one per line. Entries without http:// or https:// are scanned over HTTPS, with a fallback to HTTP.

## `deepScan` (type: `boolean`):

When versions are hidden on the homepage, read them from public files: the WordPress feed or the Joomla manifest, and the licence banner of up to two self-hosted libraries (jQuery, Bootstrap, AngularJS). Finds noticeably more outdated websites at the cost of up to three extra requests per website.

## `onlyAtRisk` (type: `boolean`):

Leave out websites where no end-of-life technology was found. Websites that failed to load are always saved.

## `eolWarningDays` (type: `integer`):

A technology whose end of life comes within this many days is reported as "eol-soon" and adds to the risk score.

## `maxConcurrency` (type: `integer`):

How many websites are scanned in parallel.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for a website to respond before giving up.

## `respectRobotsTxt` (type: `boolean`):

Skip websites whose robots.txt disallows fetching the given page. Skipped websites are saved with the status "skipped".

## Actor input object example

```json
{
  "urls": [
    "https://wordpress.org",
    "php.net"
  ],
  "deepScan": true,
  "onlyAtRisk": false,
  "eolWarningDays": 180,
  "maxConcurrency": 10,
  "requestTimeoutSecs": 30,
  "respectRobotsTxt": true
}
```

# 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://wordpress.org",
        "php.net"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vladkuz/website-eol-risk-scanner").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://wordpress.org",
        "php.net",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("vladkuz/website-eol-risk-scanner").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://wordpress.org",
    "php.net"
  ]
}' |
apify call vladkuz/website-eol-risk-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vladkuz/website-eol-risk-scanner"
        }
    }
}
```

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/hMxGX6IqxxNtXdeMQ/builds/3ChArPrWJ52ivuwqv/openapi.json
