# GDACS Disaster Alerts Scraper — GeoJSON & Filters (`muhammadafzal/gdacs-disaster-alerts-scraper`) Actor

Extract official GDACS alerts for earthquakes, floods, cyclones, volcanoes, droughts, and wildfires. Use for crisis monitoring, research, newsrooms, and automation. Not for official warnings. Returns typed alerts with severity, country, dates, coordinates, sources, and report URLs. $0.010 per alert.

- **URL**: https://apify.com/muhammadafzal/gdacs-disaster-alerts-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** News, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 gdacs alert scrapeds

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

## GDACS Disaster Alerts Scraper — GeoJSON & Filters

**GDACS Disaster Alerts Scraper** extracts official global disaster events from the Global Disaster Alert and Coordination System (GDACS) GeoJSON API. It returns normalized alerts for earthquakes, tropical cyclones, floods, volcanoes, droughts, and wildfires, with filters for GDACS alert level, date window, country, current status, and geographic bounding box.

Use the GDACS Disaster Alerts Scraper for crisis-monitoring dashboards, newsroom research, humanitarian data pipelines, travel-risk context, insurance and supply-chain screening, scheduled new-event feeds, and AI-agent workflows. Do not use it as the sole source for evacuation, life-safety, or public-warning decisions: GDACS explicitly states that its automated notifications can contain uncertainty and do not replace alerts from competent local or national authorities.

The Actor calls the public GDACS `geteventlist/SEARCH` API directly. It needs no login, cookies, API key, browser, or proxy. It follows the official 100-record paging limit, normalizes the response into a compact stable schema, and preserves links back to GDACS reports and detailed geometry.

### What data can I extract with GDACS Disaster Alerts Scraper?

Each dataset item represents one GDACS event episode.

| Field group | Included data |
|---|---|
| Identity | `eventKey`, `eventId`, `episodeId` |
| Hazard | `eventType`, `eventTypeName`, `name`, `description` |
| Alert | `alertLevel`, `alertScore`, `isCurrent`, `isTemporary` |
| Severity | `severity`, `severityText`, `severityUnit` |
| Geography | `country`, `iso3`, `affectedCountries`, `longitude`, `latitude` |
| Timeline | `startAt`, `endAt`, `modifiedAt`, `scrapedAt` |
| Provenance | `source`, `reportUrl`, `geometryUrl`, `detailsUrl`, `iconUrl` |

### How much will scraping GDACS cost you?

This Actor uses transparent pay-per-event pricing.

| Event | Price | When it is charged |
|---|---:|---|
| Actor start | $0.00005 | Automatically by Apify when a run starts; the count scales with memory |
| GDACS alert scraped | $0.010 | Once for each schema-valid alert stored in the default dataset |

Typical result charges are:

- 10 alerts: $0.10 plus the synthetic start event
- 50 alerts, the default cap: $0.50 plus the synthetic start event
- 100 alerts: $1.00 plus the synthetic start event
- A valid query with no matching alerts: no per-alert charge

The Actor prints its maximum possible result cost before making the first request and stops cleanly when the run spending limit cannot cover another record. `maxResults` is both a row cap and a cost-control input.

### When should I use this Actor?

Choose this Actor when you need clean source-faithful GDACS event data rather than a proprietary risk score or an LLM-generated incident assessment. Good uses include:

- polling active orange and red disasters every 15 minutes;
- feeding a map with event coordinates and GDACS report links;
- monitoring earthquakes and tropical cyclones near facilities or routes;
- exporting a historical date range to JSON, CSV, Excel, or a database;
- triggering Slack, email, Make, Zapier, n8n, or webhook workflows;
- giving an AI agent a concise tool for official GDACS alert discovery;
- creating separate named watchlists for regions or business units.

Do not choose it for local weather warnings, official evacuation orders, private emergency feeds, or predictive hazard modeling. It returns what the GDACS API publishes and does not claim to independently verify an event.

### Input

The default input returns currently active events of every supported type and alert level from the last seven days, capped at 50 records:

```json
{}
```

For higher-concern earthquakes and tropical cyclones in Japan and the Philippines:

```json
{
  "eventTypes": ["EQ", "TC"],
  "alertLevels": ["orange", "red"],
  "daysBack": 30,
  "countries": ["Japan", "PHL"],
  "onlyCurrent": true,
  "maxResults": 100
}
```

For a scheduled Asia-Pacific new-alert feed:

```json
{
  "eventTypes": ["EQ", "TC", "FL", "VO"],
  "alertLevels": ["green", "orange", "red"],
  "daysBack": 14,
  "boundingBox": [100, -10, 180, 60],
  "onlyCurrent": true,
  "skipSeen": true,
  "watchlistName": "apac-operations",
  "maxResults": 200
}
```

`dateFrom` and `dateTo` accept `YYYY-MM-DD`. When `dateFrom` is empty, `daysBack` creates a rolling window ending at `dateTo` or today. `countries` performs an exact case-insensitive match against the primary GDACS country, ISO-3 code, or affected-country list. `boundingBox` uses `[west, south, east, north]` and supports rectangles that cross the antimeridian.

When `skipSeen` is enabled, the Actor stores emitted event keys in a named key-value store. Reuse the same `watchlistName` in a schedule to receive only unseen event episodes. Use different names for independent workflows so their history does not overlap.

### Output

Example dataset item:

```json
{
  "eventKey": "EQ-1557413-1724396",
  "eventId": 1557413,
  "episodeId": 1724396,
  "eventType": "EQ",
  "eventTypeName": "Earthquake",
  "name": "Earthquake in United States",
  "description": "Earthquake in United States",
  "country": "United States",
  "iso3": "USA",
  "affectedCountries": ["United States"],
  "alertLevel": "green",
  "alertScore": 1,
  "severity": 4.6,
  "severityText": "Magnitude 4.6M, Depth:36.925km",
  "severityUnit": "M",
  "isCurrent": true,
  "isTemporary": false,
  "startAt": "2026-08-11T08:49:24.000Z",
  "endAt": "2026-08-11T08:49:24.000Z",
  "modifiedAt": "2026-08-11T09:03:01.000Z",
  "longitude": -159.9971,
  "latitude": 54.4899,
  "source": "NEIC",
  "reportUrl": "https://www.gdacs.org/report.aspx?eventid=1557413&episodeid=1724396&eventtype=EQ",
  "geometryUrl": "https://www.gdacs.org/gdacsapi/api/polygons/getgeometry?eventtype=EQ&eventid=1557413&episodeid=1724396",
  "detailsUrl": "https://www.gdacs.org/gdacsapi/api/events/geteventdata?eventtype=EQ&eventid=1557413",
  "iconUrl": "https://www.gdacs.org/images/gdacs_icons/maps/Green/EQ.png",
  "scrapedAt": "2026-08-11T09:10:00.000Z"
}
```

The default key-value store also contains `OUTPUT`, a compact run summary with the normalized query, pages fetched, records stored, skipped-seen count, client-side filter count, request failures, spending-limit state, warnings, and completion time. `STATE` preserves pagination and deduplication state during Apify migrations.

### How to use GDACS Disaster Alerts Scraper

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('YOUR_USERNAME/gdacs-disaster-alerts-scraper').call({
  eventTypes: ['EQ', 'TC', 'FL'],
  alertLevels: ['orange', 'red'],
  daysBack: 30,
  maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('YOUR_USERNAME/gdacs-disaster-alerts-scraper').call(run_input={
    'eventTypes': ['EQ', 'TC', 'FL'],
    'alertLevels': ['orange', 'red'],
    'daysBack': 30,
    'maxResults': 100,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/YOUR_USERNAME~gdacs-disaster-alerts-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"eventTypes":["EQ","TC"],"alertLevels":["orange","red"],"daysBack":30,"maxResults":50}'
```

#### Apify MCP

The regular Actor is available through the hosted Apify MCP server without running a separate Standby server. Configure the tool URL as:

```text
https://mcp.apify.com/?tools=YOUR_USERNAME/gdacs-disaster-alerts-scraper
```

The declared schemas expose bounded inputs, semantic output fields, and predictable costs to agents.

### Reliability and limits

GDACS states that popular feeds are updated approximately every six minutes. Its API currently returns no more than 100 records per request, so this Actor paginates until `maxResults`, source exhaustion, or a safety limit of 100 upstream pages. It retries timeouts, HTTP 429 responses, and server errors with exponential backoff. A complete API outage fails honestly; a valid empty query exits successfully with a warning status.

GDACS may change data, experience temporary downtime, or omit fields. The Actor validates every normalized record, uses explicit nulls, stores partial successes immediately, and writes warnings to `OUTPUT`. If GDACS changes its schema, malformed features are skipped instead of crashing the whole batch.

### More public-data Actors

- [WAQI Air Quality Scraper](https://apify.com/muhammadafzal/waqi-air-quality-scraper)
- [USA Data.gov Datasets Scraper](https://apify.com/muhammadafzal/usa-data-gov-datasets-scraper)
- [US Census Bureau Scraper](https://apify.com/muhammadafzal/us-census-bureau-scraper)
- [FBI Crime Data Scraper](https://apify.com/muhammadafzal/fbi-crime-data-scraper)
- [Google Scholar Scraper](https://apify.com/muhammadafzal/google-scholar-scraper)
- [Sunbiz Florida Business Scraper](https://apify.com/muhammadafzal/sunbiz-florida-business-scraper)
- [Yellow Pages US Scraper](https://apify.com/muhammadafzal/yellow-pages-us-scraper)
- [SEC Form D Scraper](https://apify.com/muhammadafzal/sec-form-d-scraper)

### FAQ

#### How many results can I scrape with GDACS Disaster Alerts Scraper?

One run can return 1 to 5,000 alerts. GDACS exposes at most 100 events per API page, and the Actor requests additional pages automatically. Narrow date and geographic filters for faster runs and predictable datasets.

#### Can I integrate GDACS Disaster Alerts Scraper with other apps?

Yes. Use Apify schedules, webhooks, Zapier, Make, n8n, Slack, email, cloud storage, or the JavaScript and Python API clients. `skipSeen` plus a stable `watchlistName` is designed for recurring notification workflows.

#### Can I use GDACS Disaster Alerts Scraper with the Apify API?

Yes. Run it asynchronously, synchronously, or from an Apify Task. Results are available from the run's default dataset, while `OUTPUT` contains operational metadata for downstream branching.

#### Can I use GDACS Disaster Alerts Scraper through an MCP Server?

Yes. Add `YOUR_USERNAME/gdacs-disaster-alerts-scraper` to the hosted Apify MCP server. AI agents receive the Actor's input contract, typed output schema, pricing signal, and dataset pagination path.

#### Do I need proxies to scrape GDACS?

No. The Actor calls GDACS's public API directly and does not launch a browser. Polite sequential pagination and retry backoff reduce unnecessary load.

#### Is it legal to scrape GDACS data?

GDACS's API quick start says its data is free and requests attribution to the “Global Disaster Alert and Coordination System, GDACS.” This Actor preserves that attribution and links to original reports. You remain responsible for your use, applicable law, and the current [GDACS terms and disclaimer](https://www.gdacs.org/About/termofuse.aspx). GDACS information is provided without warranty, may contain automated estimates, and must not replace authoritative local warnings or expert validation.

#### Where does the data come from?

The source is the official [GDACS GeoJSON API](https://www.gdacs.org/gdacsapi/swagger/index.html), operated within the GDACS cooperation framework involving United Nations and European Commission stakeholders. Individual records also name upstream scientific providers such as NEIC when GDACS supplies that field.

#### Your feedback

If a GDACS field changes or a filter behaves unexpectedly, open an Actor issue with the run ID, input, and one affected `eventKey`. Do not include your Apify token or other credentials.

# Actor input Schema

## `eventTypes` (type: `array`):

Use this when you need specific GDACS hazard types. Pass one or more codes such as \['EQ', 'FL'] for earthquakes and floods. Defaults to all six supported types. This is not a free-text keyword search.

## `alertLevels` (type: `array`):

Use this when you need a GDACS impact-alert severity band. Pass values such as \['orange', 'red'] for higher-concern events. Defaults to green, orange, and red. This is not an earthquake-magnitude filter.

## `daysBack` (type: `integer`):

Use this when dateFrom is empty and you want a rolling time window. Enter an integer such as 7 for the previous seven days ending at dateTo or today. Defaults to 7 and allows 1 to 3650. This does not override an explicit dateFrom.

## `dateFrom` (type: `string`):

Use this when you need an exact inclusive start date. Enter YYYY-MM-DD, for example '2026-08-01'. Defaults to empty, which derives the date from daysBack. This is not an ISO date-time with hours or a timezone.

## `dateTo` (type: `string`):

Use this when you need an exact inclusive end date. Enter YYYY-MM-DD, for example '2026-08-11'. Defaults to empty, which uses the current UTC date. This is not a relative duration; use daysBack for rolling windows.

## `countries` (type: `array`):

Use this when alerts must match named or affected countries. Enter one value per line, such as Japan or PHL, using full GDACS country names or ISO-3 codes. Defaults to an empty worldwide list. This is not a fuzzy place-name or city search.

## `boundingBox` (type: `array`):

Use this when alerts must fall inside a geographic rectangle. Pass \[west, south, east, north], for example \[100, -10, 160, 30]; antimeridian-crossing boxes are supported. Defaults to \[] for no spatial filter. This is not a polygon or radius search.

## `onlyCurrent` (type: `boolean`):

Use this when you only want events GDACS currently marks active. Set true to exclude concluded events, for example in a scheduled monitoring workflow. Defaults to true. This does not mean the alert has been independently confirmed by local authorities.

## `maxResults` (type: `integer`):

Use this to cap dataset rows and predictable result charges. Enter an integer such as 50; GDACS pages are fetched until the cap or source exhaustion. Defaults to 50 and allows 1 to 5000. This is not the upstream API page size.

## `skipSeen` (type: `boolean`):

Use this for scheduled monitoring that should emit only unseen GDACS event episodes. Set true to persist emitted event keys in a named watchlist, for example a daily automation. Defaults to false. This is not within-run deduplication, which is always enabled.

## `watchlistName` (type: `string`):

Use this to isolate cross-run history when skipSeen is enabled. Enter a stable label such as 'apac-crisis-monitor'; letters, numbers, and hyphens are normalized. Defaults to 'default'. This is not an Apify dataset or key-value store ID.

## Actor input object example

```json
{
  "eventTypes": [
    "EQ",
    "TC",
    "FL",
    "VO",
    "DR",
    "WF"
  ],
  "alertLevels": [
    "green",
    "orange",
    "red"
  ],
  "daysBack": 7,
  "dateFrom": "",
  "dateTo": "",
  "countries": [],
  "boundingBox": [],
  "onlyCurrent": true,
  "maxResults": 50,
  "skipSeen": false,
  "watchlistName": "default"
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset items with hazard type, GDACS alert level, severity, country, dates, coordinates, source attribution, and official report links.

## `runSummary` (type: `string`):

OUTPUT JSON with the normalized query, request counts, skipped records, cost-limit state, and warnings.

# 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 = {
    "eventTypes": [
        "EQ",
        "TC",
        "FL",
        "VO",
        "DR",
        "WF"
    ],
    "alertLevels": [
        "green",
        "orange",
        "red"
    ],
    "daysBack": 7,
    "dateFrom": "",
    "dateTo": "",
    "countries": [],
    "boundingBox": [],
    "onlyCurrent": true,
    "maxResults": 50,
    "skipSeen": false,
    "watchlistName": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/gdacs-disaster-alerts-scraper").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 = {
    "eventTypes": [
        "EQ",
        "TC",
        "FL",
        "VO",
        "DR",
        "WF",
    ],
    "alertLevels": [
        "green",
        "orange",
        "red",
    ],
    "daysBack": 7,
    "dateFrom": "",
    "dateTo": "",
    "countries": [],
    "boundingBox": [],
    "onlyCurrent": True,
    "maxResults": 50,
    "skipSeen": False,
    "watchlistName": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/gdacs-disaster-alerts-scraper").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 '{
  "eventTypes": [
    "EQ",
    "TC",
    "FL",
    "VO",
    "DR",
    "WF"
  ],
  "alertLevels": [
    "green",
    "orange",
    "red"
  ],
  "daysBack": 7,
  "dateFrom": "",
  "dateTo": "",
  "countries": [],
  "boundingBox": [],
  "onlyCurrent": true,
  "maxResults": 50,
  "skipSeen": false,
  "watchlistName": "default"
}' |
apify call muhammadafzal/gdacs-disaster-alerts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammadafzal/gdacs-disaster-alerts-scraper"
        }
    }
}

```

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/vqanRTjcHGKWvt6Pu/builds/9MttSHDimRhDxe6vj/openapi.json