# Service Alerts Scraper — News Alerts & Disruption Monitor (`scrapepilot/public-transport-alerts-scraper-real-time-transit-data`) Actor

Scrape service alerts and news alerts from any website — transit portals, energy exchanges, government sites, and news pages. Get severity, status, dates, and direct links. Filter by keyword, severity, and date. $8 per 1,000 results. Pay per result.

- **URL**: https://apify.com/scrapepilot/public-transport-alerts-scraper-real-time-transit-data.md
- **Developed by:** [Scrape Pilot](https://apify.com/scrapepilot) (community)
- **Categories:** News, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 scraped alert results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## 🚨 Service Alerts Scraper — News Alerts & Disruption Monitor

> **The most versatile Service Alerts Scraper on Apify.** Extract service alerts, disruption notices, and news alerts from any website — transit portals, energy exchanges, government sites, public transport authorities, and news portals. Get alert title, body, severity, status, dates, source, and direct link for every notice found. Filter by keyword, severity, and date. Pay only for results.

---

### 📌 Table of Contents

- [What Is This Actor?](#what-is-this-actor)
- [Why Use This Service Alerts Scraper?](#why-use-this-service-alerts-scraper)
- [Supported Website Types](#supported-website-types)
- [Use Cases](#use-cases)
- [Input Parameters](#input-parameters)
- [Output Fields](#output-fields)
- [Example Input & Output](#example-input--output)
- [Filters](#filters)
- [Pricing](#pricing)
- [Performance & Limits](#performance--limits)
- [FAQ](#faq)
- [Changelog](#changelog)
- [Legal & Terms of Use](#legal--terms-of-use)

---

### 🔍 What Is This Actor?

**Service Alerts Scraper** is a production-ready Apify actor that extracts structured alert and notice data from any publicly accessible website — transit portals, energy market exchanges, government announcement pages, public transport authority sites, and general **news alerts** pages.

Provide one or many target URLs — from sites like TfL, MTA, EPEX SPOT, Deutsche Bahn, National Rail, or any custom portal — and receive back a clean, structured record for every alert found: title, body text, severity classification (High / Moderate / Low), status (Active / Planned / Resolved), date or date range, direct link, and source domain.

Apply optional filters for keyword, severity level, and date range to narrow results to exactly the alerts you need. This **service alerts scraper** automatically detects alert severity from content keywords and extracts dates from free-text, making it the most intelligent and flexible alerts monitoring tool available on Apify.

---

### 🚀 Why Use This Service Alerts Scraper?

| Feature | This Actor | Manual Monitoring | RSS Feeds | Other Scrapers |
|---|---|---|---|---|
| **Service alerts from any website** | ✅ | ❌ Slow | ⚠️ If available | ⚠️ |
| **News alerts — any portal** | ✅ | ❌ | ⚠️ | ⚠️ |
| **Auto severity detection** | ✅ High/Moderate/Low | ❌ | ❌ | ❌ |
| **Auto status detection** | ✅ Active/Planned/Resolved | ❌ | ❌ | ❌ |
| **Date extraction from free text** | ✅ | ❌ | ⚠️ | ❌ |
| **Keyword filter** | ✅ Built-in | ❌ | ⚠️ | ❌ |
| **Severity filter** | ✅ Built-in | ❌ | ❌ | ❌ |
| **Date range filter** | ✅ Built-in | ❌ | ❌ | ❌ |
| **Multi-URL batch** | ✅ | ❌ | ⚠️ | ⚠️ |
| **No login or API key** | ✅ | ✅ | ✅ | ✅ |

> **Bottom line:** This **service alerts scraper** is the only actor that automatically classifies severity, detects alert status, and extracts dates from free-text — across any website type — with built-in keyword, severity, and date filtering in a single run.

---

### 🌐 Supported Website Types

This **news alerts scraper** works on any publicly accessible page with structured or semi-structured content:

#### 🚇 Public Transit & Transport
- Transport for London (TfL)
- MTA New York City Transit
- Deutsche Bahn
- SNCF Rail France
- National Rail UK
- BART
- Any local transit authority portal

#### ⚡ Energy Markets & Exchanges
- EPEX SPOT
- EEX Energy Exchange
- Any national grid or energy market announcement page

#### 🏛️ Government & Regulatory Sites
- Public notices and announcement portals
- Regulatory body alert pages
- Emergency services bulletins

#### 📰 News & Media Portals
- Any news site or portal with article card layouts
- Industry-specific news feeds
- Press release pages

> **Any website not listed?** If the page is publicly accessible and contains structured or semi-structured alert/news content, this actor can scrape it. The parser tries JSON-LD structured data first, then CSS card selectors, then a link-scan fallback — covering the vast majority of modern web layouts.

---

### 🎯 Use Cases

#### 🚇 Transit & Transport Monitoring
- Monitor public transport disruptions, cancellations, and service changes across multiple authorities
- Build automated alerts pipelines that notify operations teams when high-severity transit disruptions are detected
- Track planned engineering works and route diversions across a city's entire transit network

#### ⚡ Energy Market Intelligence
- Scrape **service alerts** from energy exchanges for force majeure notices, market interruptions, and trading halts
- Monitor capacity reduction announcements and emergency maintenance notices from grid operators
- Build automated feeds of energy market news alerts for trading desks or risk management teams

#### 🏛️ Government & Regulatory Compliance
- Monitor government portals for regulatory announcements, public notices, and policy changes
- Track emergency alerts and public safety notices from official government sites
- Collect regulatory update alerts for compliance monitoring across multiple jurisdictions

#### 📊 Operations & Incident Management
- Feed **service alerts** into operations dashboards or incident management platforms
- Detect high-severity disruptions early by running scheduled scraper runs on critical infrastructure portals
- Aggregate alerts from multiple sources into a single structured feed for NOC or operations center use

#### 🤖 Automation & Integration
- Schedule regular scraper runs to continuously monitor any set of service alert URLs
- Feed structured alert data into Slack, Teams, PagerDuty, or any notification system via Apify integrations
- Build a custom **news alerts** aggregator that monitors multiple portals and routes alerts by severity

#### 🎓 Research & Analysis
- Collect historical disruption data for transport reliability studies
- Analyze energy market alert patterns and frequency for risk modeling
- Build datasets of public sector announcements for policy research

---

### ⚙️ Input Parameters

```json
{
  "target_urls": [
    "https://tfl.gov.uk/tube/status",
    "https://www.epexspot.com/en/news",
    "https://www.mta.info/alerts"
  ],
  "target_url":      "",
  "keyword":         "cancellation",
  "severity_filter": "High",
  "date_from":       "2024-03-01",
  "max_results":     50,
  "proxyConfiguration": {
    "useApifyProxy":    true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `target_urls` | array or string | `[]` | Website URLs to scrape — comma or newline-separated string also accepted |
| `target_url` | string | `""` | Single URL shortcut — merged into `target_urls` automatically |
| `keyword` | string | `""` | Filter alerts by keyword in title or body — e.g. `"delay"`, `"cancellation"`, `"EPEX"` |
| `severity_filter` | string | `""` | Filter by severity level — `"High"`, `"Moderate"`, or `"Low"`. Leave blank for all |
| `date_from` | string | `""` | Filter alerts dated on or after this date — ISO format `"YYYY-MM-DD"` |
| `max_results` | integer | `50` | Maximum alerts to return across all URLs |
| `proxyConfiguration` | object | Optional | Apify proxy config — residential proxy recommended for government and transit sites |

***

### 📋 Output Fields

Every record from this **service alerts scraper** includes:

| Field | Type | Description | Example |
|---|---|---|---|
| `route` | string | Route, line, service, or source name auto-detected | `"Northern Line"`, `"EPEX SPOT Market"` |
| `service_alert` | string | Alert or notice headline (max 300 chars) | `"Northern Line: Severe delays due to signal failure"` |
| `alert_body` | string | Alert body or description text (max 500 chars) | `"Trains are running with severe delays between..."` |
| `dates` | string | Date or date range extracted from the alert | `"2024-03-15"`, `"2024-03-15 to 2024-03-17"` |
| `link` | string | Direct URL to the full alert or article | `"https://tfl.gov.uk/tube/status/..."` |
| `severity` | string | Auto-detected severity level | `"High"`, `"Moderate"`, `"Low"` |
| `status` | string | Auto-detected alert status | `"Active"`, `"Planned"`, `"Resolved"` |
| `source` | string | Source domain | `"tfl.gov.uk"`, `"epexspot.com"` |
| `processed_at` | string | Extraction timestamp (ISO 8601 UTC) | `"2024-03-15T10:30:00Z"` |

#### 🔴 Severity Classification

| Severity | Keywords That Trigger It |
|---|---|
| `High` | emergency, critical, cancelled, suspended, shutdown, failure, disruption, force majeure, outage, evacuation, flood, fire, closure, major, severe |
| `Moderate` | delay, maintenance, repair, diversion, detour, modification, amendment, update, change, reduction, partial, limited, restricted, congestion |
| `Low` | advisory, information, notice, reminder, planned, scheduled, minor, improvement, enhancement, announcement |

#### 🟢 Status Classification

| Status | Keywords That Trigger It |
|---|---|
| `Resolved` | completed, resolved, restored, ended, finished |
| `Planned` | planned, upcoming, future, scheduled for |
| `Active` | Default — all other alerts |

***

### 📦 Example Input & Output

**Input:**

```json
{
  "target_urls":     ["https://tfl.gov.uk/tube/status"],
  "keyword":         "delay",
  "severity_filter": "High",
  "max_results":     5
}
```

**Output (one record):**

```json
{
  "route":         "Northern Line",
  "service_alert": "Northern Line: Severe delays due to signal failure at Camden Town",
  "alert_body":    "Trains are running with severe delays between Euston and Morden. Use alternative routes where possible.",
  "dates":         "2024-03-15",
  "link":          "https://tfl.gov.uk/tube/status/northern-line",
  "severity":      "High",
  "status":        "Active",
  "source":        "tfl.gov.uk",
  "processed_at":  "2024-03-15T10:30:00Z"
}
```

***

### 🔽 Filters

#### Keyword Filter

```json
{ "keyword": "cancellation" }
```

Returns only alerts where the keyword appears anywhere in the title or body text. Case-insensitive. Works across all URLs in the batch.

#### Severity Filter

```json
{ "severity_filter": "High" }
```

Returns only alerts classified at the specified severity level. Options: `"High"`, `"Moderate"`, `"Low"`. Leave blank to return all severities.

#### Date From Filter

```json
{ "date_from": "2024-03-01" }
```

Returns only alerts dated on or after the specified date. Useful for getting only recent alerts when running scheduled monitoring runs.

> All three filters can be combined in the same run for highly targeted alert extraction.

***

### 💰 Pricing

This actor uses **pay-per-event** pricing — you only pay for alerts actually extracted and pushed to the dataset.

| Event | Price |
|---|---|
| **Actor start fee** | $0.02 per run |
| **Per alert extracted** | $0.008 per result ($8.00 per 1,000 alerts) |

#### How billing works:

- ✅ The $0.02 start fee applies once per run regardless of results
- ✅ Each alert record pushed to the dataset is charged at $0.008
- ✅ Alerts filtered out by keyword, severity, or date filters are **not charged**
- ✅ The actor stops automatically when your Apify account charge limit is reached
- ✅ **No free trial** — pay only for what you extract, starting from your first result

> **Example:** Extract 500 alerts = $0.02 (start) + $4.00 (500 × $0.008) = **$4.02 total**

***

### ⚡ Performance & Limits

| URLs | Alerts Per URL | Estimated Time |
|---|---|---|
| 1 URL | up to 50 | ~30–90 seconds |
| 5 URLs | up to 50 each | ~3–6 minutes |
| 20 URLs | up to 50 each | ~12–25 minutes |

- Results pushed to the Apify dataset immediately after each alert is processed
- Automatic delay between URLs to prevent rate limiting
- Residential proxy recommended for transit authority and government sites that restrict access
- The parser tries JSON-LD structured data first, then CSS card selectors, then link-scan — ensuring maximum coverage across all website types

***

### ❓ FAQ

**Q: Which websites does this actor work with?**
A: Any publicly accessible website with alert, notice, or news content — transit portals (TfL, MTA, Deutsche Bahn, SNCF), energy exchanges (EPEX SPOT, EEX), government announcement pages, and general news portals. If the page is publicly viewable and contains structured content, this **service alerts scraper** can extract it.

**Q: How is severity detected?**
A: Severity is automatically classified from keywords in the alert title and body. Words like "emergency", "cancelled", "suspended", or "failure" trigger High severity. Words like "delay", "maintenance", or "diversion" trigger Moderate. "Advisory", "scheduled", and "planned" trigger Low. See the Severity Classification table above for the full keyword lists.

**Q: How are dates extracted?**
A: The actor looks for `<time>` HTML elements, `datetime` attributes, and applies regex patterns to extract dates in multiple formats — DD/MM/YYYY, YYYY-MM-DD, and natural language formats like "15 March 2024". Date ranges (e.g. "15 March to 17 March") are also detected and returned as a single date range string.

**Q: What happens when my charge limit is reached?**
A: The actor stops processing new alerts immediately and logs a clear message. Already-extracted alerts are safely saved to your dataset. On your next run with increased budget, the actor starts fresh.

**Q: Can I filter for only active (non-resolved) alerts?**
A: Currently the `severity_filter` and `keyword` filters are available. Status-based filtering (e.g. Active only) can be applied after export using your dataset's filter tools or any spreadsheet application.

**Q: Can I schedule this to run automatically?**
A: Yes. Set up an Apify scheduled task with your target URLs and filters to automatically collect fresh alerts on any interval — hourly, daily, or weekly.

**Q: Can I export results to Excel or CSV?**
A: Yes. All results are pushed to the Apify dataset, which can be exported to JSON, CSV, Excel, and more directly from the Apify Console after each run.

***

### 📜 Changelog

#### v1.0.0 (Current)

- ✅ Scrapes service alerts and news alerts from any publicly accessible website
- ✅ JSON-LD structured data extraction (primary method)
- ✅ CSS card selector parsing with 12+ selectors tried in priority order
- ✅ Link-scan fallback for non-standard page layouts
- ✅ Auto-severity detection from 40+ keywords across 3 severity levels
- ✅ Auto-status detection (Active / Planned / Resolved)
- ✅ Date and date range extraction from free text and HTML time elements
- ✅ Route/line/service name auto-detection
- ✅ Keyword, severity, and date-from filters
- ✅ Pay-per-event billing — charged per alert extracted
- ✅ Spending limit respect — stops automatically when user charge limit reached
- ✅ Real-time dataset push as each alert is extracted

***

### 🏷️ Tags

`service alerts scraper` `news alerts scraper` `transit alerts scraper` `disruption monitor` `service disruption scraper` `transit scraper` `energy alerts scraper` `government notices scraper` `alert monitoring` `service status scraper` `public transport alerts` `incident alerts scraper`

***

### ⚖️ Legal & Terms of Use

This actor accesses publicly visible alert and news content from websites in the same way a regular user browses those pages.

**Please note:**

- Use extracted alert data only for **lawful purposes** — operations monitoring, research, compliance, and journalism are common legitimate uses
- Respect each website's Terms of Service — do not use this tool at volumes designed to overload or disrupt any platform
- Alert content belongs to the respective organizations that publish it — do not republish scraped content without appropriate attribution
- The actor developer is not responsible for how extracted alert data is used or acted upon

***

### 🤝 Support & Feedback

- **Bug report?** Contact us via the Apify actor page
- **Feature request?** Post in the Apify Community forum
- **Loving it?** Please leave a ⭐ review — it helps other users find this actor!

***

<p align="center">
  <strong>Built with ❤️ on Apify</strong><br/>
  <em>The most complete Service Alerts Scraper — any website, auto severity, keyword & date filters</em><br/><br/>
  <strong>💰 $0.02 per run + $8.00 per 1,000 alerts · Pay only for results</strong>
</p>

# Actor input Schema

## `target_urls` (type: `string`):

URLs to scrape for alerts/notices. One per line or as JSON array.

Examples:
https://www.epexspot.com/en/news
https://tfl.gov.uk/tube/status/
https://www.mta.info/alerts
https://www.eex.com/en/market-data/trading-signals/customer-information

## `target_url` (type: `string`):

Single URL to scrape

## `keyword` (type: `string`):

Only return alerts containing this keyword. E.g: 'delay', 'suspension', 'maintenance', 'gas', 'power'

## `severity_filter` (type: `string`):

Filter by severity level

## `date_from` (type: `string`):

Only return alerts from this date onwards

## `max_results` (type: `integer`):

Maximum alerts to return

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

RESIDENTIAL proxy recommended to avoid IP blocks on portal sites.

## Actor input object example

```json
{
  "target_urls": "https://www.epexspot.com/en/news",
  "severity_filter": "",
  "max_results": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "target_urls": "https://www.epexspot.com/en/news",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/public-transport-alerts-scraper-real-time-transit-data").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 = {
    "target_urls": "https://www.epexspot.com/en/news",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/public-transport-alerts-scraper-real-time-transit-data").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 '{
  "target_urls": "https://www.epexspot.com/en/news",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapepilot/public-transport-alerts-scraper-real-time-transit-data --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapepilot/public-transport-alerts-scraper-real-time-transit-data",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Service Alerts Scraper — News Alerts & Disruption Monitor",
        "description": "Scrape service alerts and news alerts from any website — transit portals, energy exchanges, government sites, and news pages. Get severity, status, dates, and direct links. Filter by keyword, severity, and date. $8 per 1,000 results. Pay per result.",
        "version": "0.0",
        "x-build-id": "HMfSWrlWI9qu8lChX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~public-transport-alerts-scraper-real-time-transit-data/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-public-transport-alerts-scraper-real-time-transit-data",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapepilot~public-transport-alerts-scraper-real-time-transit-data/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-public-transport-alerts-scraper-real-time-transit-data",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapepilot~public-transport-alerts-scraper-real-time-transit-data/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-public-transport-alerts-scraper-real-time-transit-data",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "target_urls": {
                        "title": "Target URLs",
                        "type": "string",
                        "description": "URLs to scrape for alerts/notices. One per line or as JSON array.\n\nExamples:\nhttps://www.epexspot.com/en/news\nhttps://tfl.gov.uk/tube/status/\nhttps://www.mta.info/alerts\nhttps://www.eex.com/en/market-data/trading-signals/customer-information"
                    },
                    "target_url": {
                        "title": "Single URL",
                        "type": "string",
                        "description": "Single URL to scrape"
                    },
                    "keyword": {
                        "title": "Keyword Filter",
                        "type": "string",
                        "description": "Only return alerts containing this keyword. E.g: 'delay', 'suspension', 'maintenance', 'gas', 'power'"
                    },
                    "severity_filter": {
                        "title": "Severity Filter",
                        "enum": [
                            "",
                            "High",
                            "Moderate",
                            "Low"
                        ],
                        "type": "string",
                        "description": "Filter by severity level",
                        "default": ""
                    },
                    "date_from": {
                        "title": "Date From (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only return alerts from this date onwards"
                    },
                    "max_results": {
                        "title": "Max Results",
                        "type": "integer",
                        "description": "Maximum alerts to return",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (RESIDENTIAL Recommended)",
                        "type": "object",
                        "description": "RESIDENTIAL proxy recommended to avoid IP blocks on portal sites."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```