GDACS Disaster Alerts

Monitor and track natural disasters worldwide using the Global Disaster Alert and Coordination System (GDACS). This Apify actor retrieves structured data on earthquakes, floods, tropical cyclones, volcanoes, droughts, and wildfires directly from the official GDACS API maintained by the United Nations Office for the Coordination of Humanitarian Affairs (OCHA) and the European Commission.

GDACS is the primary global early warning framework used by humanitarian organizations, government agencies, and emergency responders to coordinate disaster response. The actor connects to the free public GDACS REST API, fetches disaster event records in GeoJSON format, and transforms them into clean, structured JSON output. Each record includes the disaster type, color-coded alert severity (Red, Orange, Green), geographic coordinates, affected countries, quantitative severity measurements, event timeline, and a direct link to the full GDACS report page.

No API key is needed -- GDACS is a free, open data source. Build automated disaster monitoring pipelines, feed real-time dashboards, trigger alert notifications via Slack or email, compile historical disaster datasets for research, or power humanitarian response workflows -- all without writing any API integration code yourself.

---

Why use GDACS Disaster Alerts?

• No API key required -- the GDACS API is completely free and public. This actor handles all request construction, response parsing, and data normalization automatically.
• Scheduled monitoring -- set up recurring runs on Apify to check for new disasters every 30 minutes, hourly, or on any custom schedule you need.
• Webhook and integration support -- connect output to Slack, email, Google Sheets, Zapier, Make, or any webhook endpoint for instant disaster notifications.
• Persistent dataset storage -- every run stores results in an Apify dataset you can query, export as JSON/CSV/Excel, or compare across time for trend analysis.
• Reliable client-side filtering -- the actor applies its own filters on top of the GDACS API response to guarantee accurate results, since GDACS server-side filtering can occasionally return mismatched records.
• Ultra-low cost -- runs complete in seconds on 256 MB memory, costing fractions of a cent per execution.

---

Key features

• Six disaster types -- earthquakes, floods, tropical cyclones, volcanoes, droughts, and wildfires from every region worldwide.
• Three alert severity levels -- filter by Red (highest severity, likely requiring international humanitarian response), Orange (medium, significant regional impact), or Green (lower severity) alerts.
• Custom date range filtering -- search historical disasters going back years or limit results to a specific time window using YYYY-MM-DD date formats.
• Geographic coordinates -- every event includes precise latitude and longitude for mapping and proximity calculations.
• Affected countries list -- each disaster record identifies all countries and territories impacted, with human-readable country names.
• Quantitative severity metrics -- numeric severity data with descriptive text and measurement unit (e.g., Richter magnitude for earthquakes, wind speed in km/h for tropical cyclones).
• Direct GDACS report links -- each result includes a URL to the full GDACS event report with maps, satellite imagery, and impact analysis.
• Active vs. historical event flag -- a boolean isCurrent field indicates whether each disaster is still ongoing or has concluded.
• Configurable result limits -- retrieve anywhere from 1 to 500 disaster events per run.
• Source attribution -- each event identifies its originating data source (e.g., USGS for earthquakes, NOAA for cyclones, JRC for floods).

---

How to use

Using the Apify Console

1. Navigate to the GDACS Disaster Alerts actor page on the Apify Store.
2. Click Try for free to open the actor in the Apify Console.
3. Configure your input parameters -- select an event type, alert level, date range, and result limit, or leave defaults for a broad search.
4. Click Start to run the actor.
5. When the run finishes (typically 5--15 seconds), view results in the Dataset tab. Export as JSON, CSV, or Excel.

For automated disaster monitoring, create a Schedule in the Apify Console to run at regular intervals, and attach a Webhook to push new alerts to Slack, email, or any HTTP endpoint.

Using the Apify API

JavaScript:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('ryanclinton/gdacs-disaster-alerts').call({
    eventType: 'EQ',
    alertLevel: 'Red',
    maxResults: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Found ${items.length} red-level earthquakes`);

Python:

from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')
run = client.actor('ryanclinton/gdacs-disaster-alerts').call(run_input={
    'eventType': 'TC',
    'alertLevel': 'Orange',
    'maxResults': 30,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
for item in items:
    print(f"{item['title']} -- {item['alertLevel']} -- {item['country']}")

---

Input parameters

Parameter	Type	Default	Description
eventType	Select	ALL	Type of disaster event. Options: ALL (all types), EQ (Earthquake), FL (Flood), TC (Tropical Cyclone), VO (Volcano), DR (Drought), WF (Wildfire).
alertLevel	Select	ALL	Severity level filter. Options: ALL (all levels), Red (highest severity), Orange (medium severity), Green (low severity).
dateFrom	Text	(empty)	Start date in YYYY-MM-DD format. Leave empty to retrieve the most recent events.
dateTo	Text	(empty)	End date in YYYY-MM-DD format. Leave empty for the latest available data.
maxResults	Number	50	Maximum number of disaster events to return. Range: 1--500.

Example input JSON:

{
    "eventType": "EQ",
    "alertLevel": "Red",
    "dateFrom": "2025-01-01",
    "dateTo": "2025-06-30",
    "maxResults": 100
}

Tips:

• Use ALL for both event type and alert level to get a broad view of global disaster activity.
• Filter by Red alert level to see only the most critical events requiring international humanitarian response.
• Set date ranges in YYYY-MM-DD format for historical research. Without dates, the API returns the most recent events.
• Start with the default 50 results and increase to 500 only when building comprehensive datasets.

---

Output

Each disaster event is returned as a structured JSON object. Example:

{
    "eventId": 1427893,
    "eventType": "Earthquake",
    "alertLevel": "Orange",
    "title": "M 6.4 - Vanuatu region",
    "description": "Magnitude 6.4, Depth: 35km, 2025-01-14 08:22:17 UTC",
    "country": "Vanuatu",
    "latitude": -16.4532,
    "longitude": 167.8921,
    "severity": "Magnitude 6.4M, Depth 35km",
    "severityValue": 6.4,
    "severityUnit": "M",
    "affectedCountries": ["Vanuatu", "New Caledonia"],
    "isCurrent": true,
    "source": "USGS",
    "dateStart": "2025-01-14T08:22:17",
    "dateEnd": "2025-01-21T08:22:17",
    "dateModified": "2025-01-14T09:15:00",
    "gdacsUrl": "https://www.gdacs.org/report.aspx?eventid=1427893&eventtype=EQ",
    "extractedAt": "2025-01-15T12:00:00.000Z"
}

Output fields reference:

Field	Type	Description
eventId	Number	Unique GDACS event identifier.
eventType	String	Human-readable disaster category (Earthquake, Flood, Tropical Cyclone, Volcano, Drought, Wildfire).
alertLevel	String	Color-coded severity: Red, Orange, or Green.
title	String	Short event title with magnitude/location summary.
description	String	Detailed event description with technical parameters.
country	String	Primary affected country or comma-separated list.
latitude	Number	Event latitude coordinate.
longitude	Number	Event longitude coordinate.
severity	String	Human-readable severity text (e.g., "Magnitude 6.4M, Depth 35km").
severityValue	Number	Numeric severity measurement.
severityUnit	String	Unit of measurement (e.g., M for magnitude, km/h for wind speed).
affectedCountries	Array	List of all affected country names.
isCurrent	Boolean	true if the event is still ongoing, false if concluded.
source	String	Originating data agency (e.g., USGS, NOAA, JRC).
dateStart	String	Event start timestamp.
dateEnd	String	Event end timestamp.
dateModified	String	Last modification timestamp.
gdacsUrl	String	Direct link to the full GDACS report page.
extractedAt	String	ISO 8601 timestamp of when the data was extracted.

---

Use cases

• Humanitarian early warning systems -- trigger automated alerts for aid organizations when Red-level disasters strike, enabling faster mobilization of emergency response resources.
• Insurance and risk assessment -- monitor global disaster activity to update catastrophe models, assess portfolio exposure, and validate claims against confirmed events.
• Supply chain disruption monitoring -- track earthquakes, floods, and cyclones near critical manufacturing hubs, ports, or logistics corridors to preemptively reroute shipments.
• Academic disaster research -- build comprehensive historical datasets of natural disasters for statistical analysis, climate studies, or disaster science publications.
• News and media monitoring -- auto-detect breaking disaster events and generate alerts for newsroom editorial teams covering global emergencies.
• Travel safety alerts -- integrate disaster data into travel platforms to warn travelers about active earthquakes, cyclones, or volcanic eruptions near their destinations.
• Government situational awareness -- provide defense and emergency management agencies with real-time feeds of global disaster activity for national security briefings.
• Corporate business continuity -- alert corporate risk teams when natural disasters threaten offices, data centers, or employee locations worldwide.
• NGO donor reporting -- compile structured disaster data for grant applications and impact reports that demonstrate the scope and frequency of humanitarian crises.
• Real-time dashboard visualization -- feed latitude/longitude coordinates into mapping tools like Tableau, Power BI, or Leaflet to create live disaster situation maps.

---

API and integration

cURL

curl "https://api.apify.com/v2/acts/pmweI2ngI1bo4l6KD/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "eventType": "FL",
    "alertLevel": "Red",
    "maxResults": 25
  }'

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('pmweI2ngI1bo4l6KD').call({
    eventType: 'TC',
    alertLevel: 'ALL',
    dateFrom: '2025-01-01',
    maxResults: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => {
    console.log(`[${item.alertLevel}] ${item.eventType}: ${item.title} (${item.country})`);
});

Python

from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')
run = client.actor('pmweI2ngI1bo4l6KD').call(run_input={
    'eventType': 'EQ',
    'alertLevel': 'Orange',
    'dateFrom': '2025-01-01',
    'dateTo': '2025-06-30',
    'maxResults': 100,
})

dataset = client.dataset(run['defaultDatasetId'])
for item in dataset.iterate_items():
    print(f"[{item['alertLevel']}] {item['title']} -- {item['country']}")
    print(f"  Severity: {item['severity']}")
    print(f"  Coordinates: {item['latitude']}, {item['longitude']}")
    print(f"  Report: {item['gdacsUrl']}")

Integrations

• Slack / Microsoft Teams -- attach Apify webhooks to push new disaster alerts to team channels automatically.
• Google Sheets -- export disaster data to a live spreadsheet for collaborative analysis.
• Zapier / Make -- connect to thousands of apps for custom disaster response workflows.
• Power BI / Tableau -- feed structured disaster data into dashboards for real-time visualization.
• PagerDuty / Opsgenie -- trigger incident alerts when Red-level disasters affect your regions of interest.

---

How it works

1. Input validation -- the actor reads your filter parameters (event type, alert level, date range, max results) and constructs the GDACS API request URL.
2. API request -- a single HTTP GET request is sent to the GDACS REST API at gdacs.org/gdacsapi/api/events/geteventlist/SEARCH. The actor requests 3x your maxResults limit to compensate for GDACS server-side filtering inconsistencies.
3. GeoJSON parsing -- the raw response is a GeoJSON FeatureCollection. The actor parses each Feature, extracting properties and geometry coordinates.
4. Client-side filtering -- since GDACS server-side filters can be unreliable, the actor applies its own event type and alert level filters to guarantee result accuracy.
5. Data transformation -- each GeoJSON feature is transformed into a clean, flat JSON object with human-readable field names, including converting event type codes (EQ, FL, TC, VO, DR, WF) to full labels and extracting lat/lng from GeoJSON coordinates.
6. Result limiting -- the filtered results are trimmed to your requested maxResults count (1--500).
7. Dataset push -- each transformed disaster record is pushed to the Apify dataset for export and API access.
8. Summary logging -- the actor logs a summary of results by event type, alert level, active vs. past events, and affected countries.

Input Parameters
       |
       v
+------+-------+
| Build GDACS  |
| API URL      |
| (request 3x) |
+--------------+
       |
       v
+--------------+
| HTTP GET     |
| GeoJSON      |
| Response     |
+--------------+
       |
       v
+--------------+
| Client-side  |
| Filter by    |
| type & level |
+--------------+
       |
       v
+--------------+
| Transform    |
| GeoJSON -->  |
| flat JSON    |
+--------------+
       |
       v
+--------------+
| Limit to     |
| maxResults   |
+--------------+
       |
       v
+--------------+
| Push to      |
| Apify Dataset|
+--------------+
       |
       v
  Summary Log

---

Performance and cost

The actor runs on 256 MB of memory and completes in 5--15 seconds. The GDACS API is free with no usage limits or API key requirements.

Scenario	Run Time	Estimated Cost
Single run, 50 results	~5 seconds	< $0.001
Single run, 500 results	~10 seconds	< $0.002
Hourly monitoring (24 runs/day)	~5 sec each	~$0.50/month
Every-30-minute monitoring	~5 sec each	~$1.00/month
Daily summary run	~8 sec each	~$0.02/month

Even continuous monitoring every 30 minutes costs roughly one dollar per month in Apify platform credits.

---

Limitations

• GDACS data latency -- while earthquakes may appear within minutes (via USGS), floods, droughts, and wildfires can take hours to be reflected in the GDACS database depending on satellite observation cycles.
• Maximum 500 results per run -- the actor caps output at 500 events. For very large historical datasets, run multiple queries with different date ranges.
• No sub-national geographic filtering -- you cannot filter by specific city, state, or region. All filtering is by event type, alert level, and date range. Use the latitude/longitude output fields for post-processing geographic queries.
• Severity units vary by event type -- earthquake severity is in magnitude (M), cyclone severity is in wind speed (km/h), and flood severity uses different metrics. Comparisons across event types require domain knowledge.
• GDACS server-side filtering is unreliable -- this is why the actor applies its own client-side filters. In rare cases, the API may return fewer raw results than expected, which can reduce your final result count below maxResults.
• English-only output -- event titles, descriptions, and country names are provided in English as returned by the GDACS API.
• No push notification built-in -- the actor outputs data to an Apify dataset. For real-time notifications, configure Apify webhooks or integrations separately.

---

Responsible use

• Attribution -- GDACS data is produced by the United Nations OCHA and European Commission Joint Research Centre. When publishing or redistributing results, credit GDACS as the original data source.
• Do not overload the API -- although no rate limits are documented, avoid scheduling runs more frequently than every 10--15 minutes. The actor already requests efficiently with a single API call per run.
• Humanitarian sensitivity -- disaster data involves real human suffering. Use the data responsibly and avoid sensationalizing events for commercial gain.
• Not a replacement for official warnings -- this actor provides supplementary situational awareness. Always defer to official national emergency services and local authorities for life-safety decisions.
• Data accuracy -- GDACS aggregates data from multiple sources (USGS, NOAA, JRC, etc.) and preliminary reports may be revised. Cross-reference critical data points with the original source via the provided gdacsUrl links.

---

FAQ

Is the GDACS data free to use? Yes. GDACS is a joint initiative of the United Nations OCHA and the European Commission. The API is publicly available with no authentication required and no usage costs. You only pay for Apify compute time.

How often is the GDACS database updated? GDACS updates continuously in near real-time. Earthquake data from USGS often appears within minutes. Tropical cyclone and flood data are updated as new satellite observations become available, typically every few hours.

What are the three alert levels? Red indicates the highest severity events likely requiring international humanitarian response. Orange represents significant events with moderate regional impact. Green covers lower-severity events tracked for situational awareness.

Can I build an automated disaster notification system? Yes. Schedule the actor to run every 30--60 minutes, filter for Red or Orange alerts, and attach an Apify webhook to push results to Slack, email, Microsoft Teams, PagerDuty, or any HTTP endpoint.

What countries does GDACS cover? GDACS provides truly global coverage -- every country and territory worldwide, across all continents and ocean regions. Each event record includes affected countries with precise geographic coordinates.

Do I need an API key to use this actor? No. The underlying GDACS API is completely free and public. You only need an Apify account and API token to run the actor on the Apify platform.

What disaster types are tracked? Six types: Earthquake (EQ), Flood (FL), Tropical Cyclone (TC), Volcano (VO), Drought (DR), and Wildfire (WF).

Can I search historical disasters? Yes. Use the dateFrom and dateTo parameters in YYYY-MM-DD format to search any historical time window. Without date filters, the API returns the most recent events.

How does the actor handle unreliable GDACS filtering? The actor requests 3x your maxResults from the API and then applies its own client-side filters for event type and alert level. This compensates for occasional inconsistencies in the GDACS server-side filtering behavior.

Can I export results to CSV or Excel? Yes. After each run, open the Dataset tab in the Apify Console and click the export button to download results in JSON, CSV, Excel, XML, or RSS formats.

What does the isCurrent field mean? When isCurrent is true, the disaster event is still considered active and ongoing by GDACS. When false, the event has concluded or been superseded by updated assessments.

How do I filter results by geographic area? The actor does not support geographic bounding box input. Instead, use event type and alert level filters during the run, then filter the output by latitude, longitude, country, or affectedCountries fields in your downstream pipeline.

---

Related actors

Actor	Description
NOAA Weather Alert Monitor	Track severe weather alerts across the United States from the National Weather Service, including storms, tornadoes, and hurricane warnings.
FEMA Disaster Declaration Search	Search U.S. federal disaster declarations, emergency responses, and FEMA assistance data by state, year, and disaster type.
UK Environment Agency Flood Warnings	Monitor real-time flood warnings and alerts across England from the Environment Agency with severity levels and geographic data.
USGS Earthquake Search	Search the USGS earthquake catalog for seismic events worldwide with detailed magnitude, depth, and location filters.
Weather Forecast Search	Retrieve weather forecasts for any location worldwide including temperature, precipitation, wind, and multi-day outlooks.