# Natural Disaster & Earthquake Tracker (`scrapemint/natural-disaster-tracker`) Actor

Live worldwide disaster feed from official USGS and GDACS sources: earthquakes, cyclones, floods, volcanoes, droughts, and wildfires with alert levels, coordinates, and severity. Filter by magnitude, alert level, type, and country. Schedule with dedupe for a new-events feed. Pay per event.

- **URL**: https://apify.com/scrapemint/natural-disaster-tracker.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** News, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Natural Disaster & Earthquake Tracker

A live worldwide feed of earthquakes, tropical cyclones, floods, volcanic eruptions, droughts, and wildfires, from the two official sources risk teams trust:

- **USGS** - the US Geological Survey's global earthquake catalog, updated every minute, with magnitude, depth, tsunami flags, and PAGER impact alerts
- **GDACS** - the UN/European Commission Global Disaster Alert and Coordination System, with Green/Orange/Red alert levels and severity assessments for everything else

One normalized row per event, whatever the type.

### What you get

| Field | Description |
| --- | --- |
| `eventType` | Earthquake, Tropical cyclone, Flood, Volcanic eruption, Drought, Wildfire |
| `title` | Human-readable event name |
| `alertLevel` | green / orange / red severity assessment |
| `magnitude`, `depthKm`, `tsunamiWarning` | Earthquake specifics |
| `severityText` | GDACS impact assessment, e.g. affected area or population |
| `country`, `latitude`, `longitude` | Where |
| `startedAt`, `updatedAt` | When |
| `url` | Link to the official event report |
| `source` | USGS or GDACS |

### Run it as a monitor

Turn on `dedupe` and put the actor on a schedule (hourly, daily): every run returns only events it has not returned before. Quiet windows return nothing and cost nothing. That gives you a push-style disaster feed for:

- **Supply chain and logistics risk**: is anything happening near your suppliers, plants, or shipping routes? Filter by `countries`.
- **Insurance and reinsurance**: catastrophe awareness without an enterprise alerting contract.
- **NGOs and relief organizations**: Orange/Red alerts as they are issued.
- **Travel safety products and news automation**: structured events with coordinates, ready to map.

### Filters

- `eventTypes` - track only what matters to you
- `minMagnitude` - earthquake floor (5 feels, 6 damages, 7 destroys)
- `minAlertLevel` - green for everything, orange/red for serious events only
- `countries` - substring match on the event location
- `includeOngoing` - droughts and floods run for weeks; include or exclude events that started before your window

### Pricing

You pay per event row (`disaster_row`). The first 2 rows of every run are free, and runs that find nothing new cost nothing.

### Input example

```json
{
    "eventTypes": ["earthquake", "cyclone", "flood"],
    "minMagnitude": 5,
    "minAlertLevel": "orange",
    "countries": ["Japan", "Philippines", "Indonesia"],
    "dedupe": true
}
````

### Notes

- Both sources are official, public, and keyless. No login, no browser.
- Earthquakes come exclusively from USGS; GDACS earthquake entries are skipped so the same quake never appears twice.
- GDACS alert levels can change as an event develops; with `dedupe` on you see each event once, at the alert level it had when first returned.

# Actor input Schema

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

Which disaster types to track. Empty = all.

## `minMagnitude` (type: `integer`):

Earthquakes below this magnitude are skipped. 4 to 5 keeps it to quakes people feel; 6 and up is destructive.

## `minAlertLevel` (type: `string`):

GDACS and USGS PAGER alert severity floor. Green returns everything; orange and red only the serious events.

## `sinceHours` (type: `integer`):

How far back to include earthquakes. Max 720 (30 days).

## `includeOngoing` (type: `boolean`):

Droughts, floods, and cyclones can run for weeks. On: all currently active events are included regardless of start date. Off: only events that started inside the window.

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

Only events whose location mentions one of these, e.g. Japan, Kenya, Philippines. Empty = worldwide.

## `maxRows` (type: `integer`):

Cap on event rows returned. Controls total cost.

## `dedupe` (type: `boolean`):

Remember returned events across runs and skip them. Turn on with a schedule for a live new-disasters feed.

## Actor input object example

```json
{
  "eventTypes": [
    "earthquake",
    "cyclone",
    "flood",
    "volcano"
  ],
  "minMagnitude": 5,
  "minAlertLevel": "green",
  "sinceHours": 48,
  "includeOngoing": true,
  "countries": [],
  "maxRows": 50,
  "dedupe": false
}
```

# 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": [
        "earthquake",
        "cyclone",
        "flood",
        "volcano"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/natural-disaster-tracker").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": [
        "earthquake",
        "cyclone",
        "flood",
        "volcano",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/natural-disaster-tracker").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 '{
  "eventTypes": [
    "earthquake",
    "cyclone",
    "flood",
    "volcano"
  ]
}' |
apify call scrapemint/natural-disaster-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapemint/natural-disaster-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Natural Disaster & Earthquake Tracker",
        "description": "Live worldwide disaster feed from official USGS and GDACS sources: earthquakes, cyclones, floods, volcanoes, droughts, and wildfires with alert levels, coordinates, and severity. Filter by magnitude, alert level, type, and country. Schedule with dedupe for a new-events feed. Pay per event.",
        "version": "0.1",
        "x-build-id": "7Ep86zgRyslWWZscG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~natural-disaster-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-natural-disaster-tracker",
                "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/scrapemint~natural-disaster-tracker/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-natural-disaster-tracker",
                "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/scrapemint~natural-disaster-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-natural-disaster-tracker",
                "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": {
                    "eventTypes": {
                        "title": "Event types",
                        "type": "array",
                        "description": "Which disaster types to track. Empty = all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "earthquake",
                                "cyclone",
                                "flood",
                                "volcano",
                                "drought",
                                "wildfire"
                            ],
                            "enumTitles": [
                                "Earthquakes (USGS)",
                                "Tropical cyclones",
                                "Floods",
                                "Volcanic eruptions",
                                "Droughts",
                                "Wildfires"
                            ]
                        },
                        "default": []
                    },
                    "minMagnitude": {
                        "title": "Min earthquake magnitude",
                        "minimum": 0,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Earthquakes below this magnitude are skipped. 4 to 5 keeps it to quakes people feel; 6 and up is destructive.",
                        "default": 5
                    },
                    "minAlertLevel": {
                        "title": "Min alert level",
                        "enum": [
                            "green",
                            "orange",
                            "red"
                        ],
                        "type": "string",
                        "description": "GDACS and USGS PAGER alert severity floor. Green returns everything; orange and red only the serious events.",
                        "default": "green"
                    },
                    "sinceHours": {
                        "title": "Earthquake window (hours)",
                        "minimum": 1,
                        "maximum": 720,
                        "type": "integer",
                        "description": "How far back to include earthquakes. Max 720 (30 days).",
                        "default": 48
                    },
                    "includeOngoing": {
                        "title": "Include ongoing disasters",
                        "type": "boolean",
                        "description": "Droughts, floods, and cyclones can run for weeks. On: all currently active events are included regardless of start date. Off: only events that started inside the window.",
                        "default": true
                    },
                    "countries": {
                        "title": "Countries (optional)",
                        "type": "array",
                        "description": "Only events whose location mentions one of these, e.g. Japan, Kenya, Philippines. Empty = worldwide.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxRows": {
                        "title": "Max events per run",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Cap on event rows returned. Controls total cost.",
                        "default": 50
                    },
                    "dedupe": {
                        "title": "Skip events seen in previous runs",
                        "type": "boolean",
                        "description": "Remember returned events across runs and skip them. Turn on with a schedule for a live new-disasters feed.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
