# NASA EONET Natural Disasters: Wildfires, Storms, Volcanoes (`yadroo/nasa-eonet-events`) Actor

Natural events from NASA's keyless EONET tracker as rows: wildfires, severe storms, volcanoes, floods, icebergs, dust. One row per event with category, open/closed status, dates, latest coordinates, magnitude and sources, or one row per track position. Filter by category, region, box, size.

- **URL**: https://apify.com/yadroo/nasa-eonet-events.md
- **Developed by:** [Samat Makatov](https://apify.com/yadroo) (community)
- **Categories:** News, Developer tools, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 event row returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

## NASA EONET Natural Disasters: Wildfires, Storms, Volcanoes

NASA's Earth Observatory Natural Event Tracker (EONET) is a public catalogue of natural events on Earth: editors open an
event when a volcano observatory, a wildfire agency, a typhoon warning centre, the national ice centre or a disaster
alert system reports one, add a position every time the reporter publishes a new one, and close it when the event is
over. This actor turns that catalogue into rows — one row per event with its latest position, size and reporters, or one
row per recorded position so you get the whole path of a storm, the drift of an iceberg or the growth of a fire.

Filter by category, by a named region or your own box, by status, by time window, by reporting organisation and by size
in the unit the reporters use (acres, knots, square nautical miles). No API key, no login, no proxy, no browser: one
public JSON endpoint on `eonet.gsfc.nasa.gov`, filtered and normalised in memory. Made by Yadroo.

### Use cases

- **Live fire map for one region** — `categories: ["wildfires"]`, `region: "usWest"`: every fire the catalogue holds
  open inside your map window, with coordinates and acres, ready to drop on a tile layer.
- **Storm paths for ports and marine insurance** — `mode: "track"`, `categories: ["severeStorms"]`: the six-hourly
  positions of each cyclone with sustained wind in knots and the kilometres it moved since the previous advisory.
- **Eruption watch for aviation and travel desks** — `categories: ["volcanoes"]`, `status: "open"`: the volcanoes
  currently listed as erupting, with the vent coordinates and the observatory that reported them.
- **Iceberg drift for polar shipping and fisheries** — `categories: ["seaLakeIce"]`, `mode: "track"`: where each
  tracked berg has been, with its area in square nautical miles.
- **Weekly hazard line-up for a newsroom** — `sinceDays: 7` across all categories, `onlyNew: true` on a schedule, so a
  daily run reports only what appeared since the previous one.
- **A hazard layer for an agent or a RAG index** — `fields: ["eventId","title","categoryId","latitude","longitude","lastDate"]`
  keeps the row small enough to paste into a model context, and `eventIds` re-reads the same event every hour.

### Input

Nothing is required: with no input at all the actor writes the 50 most recent open events of every category.

| Field | Type | Default | Allowed values / notes |
|---|---|---|---|
| `mode` | string | `events` | `events` = one row per event, `track` = one row per recorded position. See [Modes](#modes) |
| `eventIds` | string\[] | — | e.g. `["EONET_24482"]`. Fetches those events directly; the filters below are then unused. An id the catalogue does not know yields a row with `found: false` |
| `categories` | string\[] | all | 13 values, see [Categories](#categories). Several are OR-ed by the source |
| `status` | string | `open` | `open`, `closed`, `all` |
| `region` | string | `world` | 17 named boxes, see [Regions](#regions) |
| `bbox` | string | — | Your own box as `minLon,maxLat,maxLon,minLat`, e.g. `-125,50,-100,31`. Overrides `region`. See [Box order](#box-order) |
| `sources` | string\[] | all | 33 reporting organisations, see [Reporting organisations](#reporting-organisations). OR-ed |
| `sinceDays` | integer | — | 1–3650. Keeps events with a position in the last N days. No default on purpose, see [Limits](#limits--faq) |
| `startDate` | string | — | UTC `YYYY-MM-DD`, inclusive. Used instead of `sinceDays` |
| `endDate` | string | run date | UTC `YYYY-MM-DD`, inclusive. Only together with `startDate` |
| `sinceHours` | integer | — | 1–8760. Applied by the actor: the newest position must be younger than this |
| `onlyNew` | boolean | `false` | Remember written event ids between runs and skip them next time |
| `magnitudeId` | string | — | Which measurement the size bounds use, 11 values, see [Measurements](#measurements) |
| `magnitudeMin` | integer | — | Lower bound, inclusive. Needs `magnitudeId` |
| `magnitudeMax` | integer | — | Upper bound, inclusive. Needs `magnitudeId` |
| `titleContains` | string\[] | — | Applied by the actor: keep titles holding one of these words, case-insensitive |
| `sortBy` | string | `latest` | `latest`, `oldest`, `magnitude`, `title`. Decides which events survive `maxItems` |
| `includePolygonCoordinates` | boolean | `false` | Write the full outline of polygon events into `polygonCoordinates` |
| `maxItems` | integer | `50` | 1–2000 rows (events, or positions in track mode). The cost brake |
| `maxTrackPointsPerEvent` | integer | `200` | 1–5000 positions per event in track mode, counted from the newest backwards |
| `fields` | string\[] | all | Keep only these output fields, in this order |

`categories`, `region`, `sources`, `magnitudeId` and `fields` are read against the catalogue's own vocabulary: an
obvious typo or a common word is corrected and the correction is logged (`"typhoon"` → `severeStorms`, `"wildfire"` →
`wildfires`, `"acres"` → `ac`, `"usWests"` → `usWest`). A value that matches nothing stops the run with the list of
valid values — the search is never widened behind your back.

Filters sent to the source: `categories`, `status`, `sources`, `sinceDays`/`startDate`+`endDate`, `region`/`bbox`,
`magnitudeId`+`magnitudeMin`/`magnitudeMax`. Applied by the actor after fetching: `sinceHours`, `titleContains`,
`onlyNew`, `sortBy`, `maxItems`, `maxTrackPointsPerEvent`, `fields`.

### Reference

#### Modes

- **`events`** — one row per event: the latest coordinates and size, the first and latest report date, how many
  positions were recorded, whether the editors still hold it open. Use the **Events** or **Timeline & size** view.
- **`track`** — one row per recorded position of each event, oldest first, with `pointIndex`, the observation time and
  `distanceKm` to the previous position (`null` on the first row of an event). Use the **Track positions** view.
  `maxTrackPointsPerEvent` keeps the newest positions of long-lived events — an iceberg can carry a decade of them.

#### Categories

| Id | What it holds |
|---|---|
| `drought` | Long absence of precipitation affecting agriculture, livestock, food and water |
| `dustHaze` | Dust storms, air pollution and other non-volcanic aerosols |
| `earthquakes` | Shaking and displacement events |
| `floods` | Inundation, water beyond river and lake extents |
| `landslides` | Landslides, mudslides, avalanches |
| `manmade` | Human-induced events extreme in their extent |
| `seaLakeIce` | Icebergs and other sea and lake ice, mostly tracked bergs with a designation like `D33D` |
| `severeStorms` | Tropical storms, hurricanes, typhoons, cyclones |
| `snow` | Heavy snow events |
| `tempExtremes` | Heat and cold extremes |
| `volcanoes` | Eruptions and volcanic plumes |
| `waterColor` | Algal blooms, sediment and other water discolouration |
| `wildfires` | Wildfires and, from the US agencies, prescribed burns (their titles start with `Prescribed Fire`) |

Well filled today: wildfires, severe storms, volcanoes and sea/lake ice. Thin: drought, snow, landslides, earthquakes,
temperature extremes, water colour and manmade — see [Limits](#limits--faq).

#### Regions

Sent to the source as `bbox` in its own order — west, north, east, south.

| Region | minLon, maxLat, maxLon, minLat |
|---|---|
| `world` | no box is sent |
| `northAmerica` | -170, 72, -50, 15 |
| `usWest` | -125, 50, -100, 31 |
| `usEast` | -100, 50, -66, 24 |
| `centralAmericaCaribbean` | -118, 33, -59, 5 |
| `southAmerica` | -82, 13, -34, -56 |
| `europe` | -25, 71, 45, 34 |
| `africa` | -20, 38, 52, -35 |
| `middleEast` | 25, 42, 63, 12 |
| `centralAsia` | 46, 56, 88, 35 |
| `russiaSiberia` | 60, 78, 180, 48 |
| `southAsia` | 60, 38, 93, 5 |
| `eastAsia` | 100, 54, 146, 18 |
| `southeastAsia` | 90, 25, 145, -12 |
| `australiaNewZealand` | 110, -8, 180, -50 |
| `arctic` | -180, 90, 180, 60 |
| `antarctic` | -180, -60, 180, -90 |

#### Box order

`bbox` is four decimal degrees in the source's order: **west edge, north edge, east edge, south edge**
(`minLon,maxLat,maxLon,minLat`). `46,56,88,35` covers Kazakhstan and its neighbours; `-125,50,-100,31` the US West. The
actor checks that west is smaller than east and south smaller than north and stops with a message naming the order when
they are swapped. A box crossing the 180th meridian is rejected: the source silently ignores such a box and answers with
the whole planet, so use two runs (… to 180 and -180 to …) instead.

#### Measurements

Reporters publish a size only for some categories, in their own unit. `magnitudeId` says which unit the bounds use;
the unit itself comes back in `magnitudeUnit`.

| Id | Unit in the rows | Used for |
|---|---|---|
| `ac` | `acres` | Wildfires (US agencies) |
| `ha` | `hectare` | Wildfires (other agencies) |
| `mag_kts` | `kts` | Severe storms — average maximum sustained wind |
| `sq_NM` | `NM^2` | Icebergs — area in square nautical miles |
| `mb` | `Mb` | Earthquakes — body wave magnitude |
| `mi` | `Mi/Mwp` | Earthquakes — integrated P-wave magnitude |
| `ml` | `Ml` | Earthquakes — Richter local magnitude |
| `mms` | `Mw/Mww` | Earthquakes — moment magnitude |
| `mwb` | `Mwb` | Earthquakes — body wave moment tensor |
| `mwc` | `Mwc` | Earthquakes — centroid moment tensor |
| `mwr` | `Mwr` | Earthquakes — moment tensor inversion |

Typical bounds: `ac` ≥ 1000 for large fires, `mag_kts` ≥ 64 for hurricane-force storms, `mag_kts` 34–63 for
tropical-storm strength, `sq_NM` ≥ 100 for big bergs.

#### Reporting organisations

`AVO` Alaska Volcano Observatory · `ABFIRE` Alberta Wildfire · `AU_BOM` Australia Bureau of Meteorology ·
`BYU_ICE` BYU Antarctic iceberg tracking · `BCWILDFIRE` British Columbia Wildfire Service · `CALFIRE` California
forestry and fire protection · `CEMS` Copernicus Emergency Management Service · `EO` NASA Earth Observatory ·
`Earthdata` NASA Earthdata · `FEMA` US Federal Emergency Management Agency · `FloodList` FloodList ·
`GDACS` Global Disaster Alert and Coordination System · `GLIDE` GLIDE identifiers · `InciWeb` US incident information ·
`IRWIN` US interagency wildfire reporting · `IDC` International Disasters Charter · `JTWC` Joint Typhoon Warning Center ·
`MRR` LANCE rapid response · `MBFIRE` Manitoba Wildfire Program · `NASA_ESRS` NASA Earth science and remote sensing ·
`NASA_DISP` NASA Earth science disasters programme · `NASA_HURR` NASA hurricane and typhoon updates ·
`NOAA_NHC` National Hurricane Center · `NOAA_CPC` NOAA weather and climate prediction · `PDC` Pacific Disaster Center ·
`ReliefWeb` ReliefWeb · `SIVolcano` Smithsonian global volcanism programme · `NATICE` US National Ice Center ·
`UNISYS` Unisys Weather · `USGS_EHP` USGS earthquake hazards · `USGS_CMT` USGS emergency operations ·
`HDDS` USGS hazards data distribution · `DFES_WA` Western Australia fire and emergency services.

The ids land in `sourceIds` and the reporter's own page in `sourceUrls`. Those pages live on other domains; the actor
prints them as data and never fetches them.

### Examples

**What is burning right now, anywhere**

```json
{ "mode": "events", "categories": ["wildfires"], "status": "open", "sortBy": "latest", "maxItems": 25 }
```

**Fires inside the US West map window**

```json
{ "mode": "events", "categories": ["wildfires"], "status": "open", "region": "usWest", "maxItems": 20 }
```

**Volcanoes the editors currently hold open**

```json
{ "mode": "events", "categories": ["volcanoes"], "status": "open", "sortBy": "latest", "maxItems": 20 }
```

**Paths of the tropical storms of the last three months**

```json
{ "mode": "track", "categories": ["severeStorms"], "status": "all", "sinceDays": 90, "maxTrackPointsPerEvent": 40, "maxItems": 60 }
```

**Fires of at least a thousand acres, largest first**

```json
{ "mode": "events", "categories": ["wildfires"], "status": "open", "magnitudeId": "ac", "magnitudeMin": 1000, "sortBy": "magnitude", "maxItems": 20 }
```

**Anything disruptive in South-East Asia this quarter**

```json
{ "mode": "events", "categories": ["wildfires", "severeStorms", "floods", "volcanoes"], "status": "all", "region": "southeastAsia", "sinceDays": 90, "maxItems": 25 }
```

### Output

A real row from a cloud run (`mode: "events"`, open wildfires, newest first):

```json
{
  "eventId": "EONET_24710",
  "title": "Wildfire Round Prarie, Morehouse, Louisiana",
  "description": "8 Miles NW from Bastrop, LA",
  "categoryId": "wildfires",
  "categoryTitle": "Wildfires",
  "categoryIds": [
    "wildfires"
  ],
  "status": "open",
  "closedAt": null,
  "firstDate": "2026-09-20T17:32:00.000Z",
  "lastDate": "2026-09-20T17:32:00.000Z",
  "durationDays": 0,
  "latitude": 32.858241,
  "longitude": -91.989455,
  "geometryType": "Point",
  "geometryCount": 1,
  "magnitudeValue": 738.55,
  "magnitudeUnit": "acres",
  "maxMagnitudeValue": 738.55,
  "sourceIds": [
    "IRWIN"
  ],
  "sourceUrls": [
    "https://irwin.doi.gov/observer/incidents/2026-LALAS-000390"
  ],
  "polygonCoordinates": [],
  "found": true,
  "url": "https://eonet.gsfc.nasa.gov/api/v3/events/EONET_24710",
  "fetchedAt": "2026-09-24T20:56:31.372Z"
}
```

`events` mode — always filled: `eventId`, `title`, `categoryId`, `categoryTitle`, `status`, `firstDate`, `lastDate`,
`latitude`, `longitude`, `geometryType`, `geometryCount`, `sourceIds`, `found`, `url`, `fetchedAt`.

| Field | Type | Meaning |
|---|---|---|
| `eventId` | string | Catalogue id, e.g. `EONET_24482` |
| `title` | string | Editor's title: the fire, storm, berg or volcano plus county or country |
| `description` | string|null | Extra note from the reporter; often `null` |
| `categoryId` / `categoryTitle` | string | First category of the event |
| `categoryIds` | string\[] | Every category of the event |
| `status` | string | `open` or `closed` |
| `closedAt` | string|null | When the editors closed it, UTC |
| `firstDate` / `lastDate` | string | First and latest recorded position, UTC |
| `durationDays` | number | Days between them |
| `latitude` / `longitude` | number | Latest position; the centre of the outline for polygon events |
| `geometryType` | string | `Point` or `Polygon` |
| `geometryCount` | number | Positions recorded so far |
| `magnitudeValue` / `magnitudeUnit` | number|null / string|null | Size at the latest position and its unit |
| `maxMagnitudeValue` | number|null | Largest size recorded for the event |
| `sourceIds` / `sourceUrls` | string\[] | Reporting organisations and their pages (data, never fetched) |
| `polygonCoordinates` | array | Outline as `[longitude, latitude]` pairs; empty unless `includePolygonCoordinates` |
| `found` | boolean | `false` for a requested id the catalogue does not know |
| `url` | string | The event in the source catalogue |
| `fetchedAt` | string | Run time, ISO 8601 UTC |

`track` mode writes `eventId`, `title`, `categoryId`, `categoryTitle`, `status`, `pointIndex` (position number inside
the event), `date` (observation time, UTC), `latitude`, `longitude`, `geometryType`, `magnitudeValue`,
`magnitudeUnit`, `distanceKm` (great-circle kilometres since the previous position, `null` on the first row of an
event), `found`, `url`, `fetchedAt`.

Dataset views: **Events** (map columns), **Timeline & size** (first/latest report, days tracked, closing date,
positions, largest size), **Track positions** (path with distance moved).

Every run also writes a `SUMMARY` record to the key-value store: the filters, how many events were read and matched,
how many rows were written, the ids that were not in the catalogue and any corrected input value.

### Use it from code / agents

```bash
curl -X POST "https://api.apify.com/v2/acts/yadroo~nasa-eonet-events/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"categories":["wildfires"],"status":"open","region":"usWest","maxItems":20}'
```

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('yadroo/nasa-eonet-events').call({ categories: ['volcanoes'], status: 'open', maxItems: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient
client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("yadroo/nasa-eonet-events").call(run_input={
    "mode": "track", "categories": ["severeStorms"], "sinceDays": 90, "maxItems": 200})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

MCP: add `https://mcp.apify.com` to Claude / Cursor / any MCP client and call the `yadroo/nasa-eonet-events` tool with
the same JSON input. For a model context, cut the row down with
`"fields": ["eventId","title","categoryId","latitude","longitude","lastDate","magnitudeValue","magnitudeUnit"]`.

On a schedule, set `onlyNew: true`: the actor keeps the ids it has already written in a named key-value store (one per
task) and writes only what is new, so a daily job stays a few rows long.

### Pricing

Pay per event: **$0.001 per run start + $0.002 per dataset row**. Every run is charged the start event, also when the
filters match nothing. Typical runs: 20 rows ≈ $0.041; 25 rows ≈ $0.051; 50 rows (the default) ≈ $0.101; a 60-position
storm-track run ≈ $0.121; the maximum `maxItems: 2000` ≈ $4.001. Apify plan tiers discount both prices (Bronze −10 %,
Silver −20 %, Gold and above −30 %).

`maxItems` is the cost brake and the run-time brake: the source answers a whole filtered result set in one response and
has no paging, so the actor reads a bounded window, sorts it the way you asked and then stops at `maxItems`.

### Limits & FAQ

- **How much the actor reads.** One request per run. The source has no paging, so the actor asks for a window of the
  most recent matches — ten times `maxItems`, at least 500 and at most 3000 events — then applies `sinceHours`,
  `titleContains`, the sort and the cap. When the window is full the status message says so; narrow the filters
  (category, region, `sinceDays`) to be sure you are looking at everything that matters. An unfiltered `status: "all"`
  run is answered by the source with an error, so a window is always sent.
- **`sinceDays` measures the last report, not the start of the event.** An event stays out of a 7-day window when no
  reporter published a new position in those seven days, even though it started last month and is still open. That is
  why `sinceDays` has no default: a volcano erupting since 2021 and an iceberg tracked since 2011 are open, but their
  newest position can be weeks old.
- **Thin categories.** Floods, drought, snow, landslides, earthquakes, temperature extremes, water colour and manmade
  are entered rarely; `floods` with `status: "open"` was empty on 2026-09-24 while `status: "all"` with a one-year
  window held hundreds. An empty run on those categories is the catalogue's state, not a failure — the run succeeds and
  the status message says nothing matched.
- **Editors close events late.** `status: "open"` can still hold an event that visibly ended, and `closedAt` arrives
  days after the fact. Count a season with `status: "closed"` or `"all"` rather than with the open list.
- **Outlines become a centre point.** Flood extents and large fire perimeters are published as polygons of hundreds to
  thousands of corners. A row carries their centre in `latitude`/`longitude`; switch `includePolygonCoordinates` on to
  get the ring itself (`[longitude, latitude]` pairs, truncated at 20 000 corners). Some 2026 flood outlines are
  published latitude first — the actor detects that (a latitude beyond ±90, or a box that only fits the other reading)
  and writes them the right way round.
- **Some dates run ahead of the clock.** A few alert-system entries carry a report or closing date in the future (the
  Thailand flood read on 2026-09-24 was closed `2026-10-06`). Those are the reporter's own timestamps, passed through
  unchanged rather than silently clipped.
- **Freshness follows the reporter.** Storm centres publish every six hours, ice and fire agencies once or twice a day,
  volcano observatories irregularly. `sinceHours` below six hours is often empty by nature.
- **Seasonality.** Fire and storm counts move with the season and the hemisphere; a category that fills 2000 rows in
  September can be quiet in February.
- **What this is not.** An event catalogue, not a warning service: no forecasts, no alert levels, no damage, casualty
  or insured-loss figures, no evacuation notices. The reporter links in `sourceUrls` lead to those where they exist.
- **Unknown ids.** An id the catalogue does not know is answered by the source with a server error rather than a
  "not found"; the actor verifies the service is up and then writes one row with `found: false` instead of failing.
- **Rate limits and licence.** The endpoint is keyless and publishes no rate limit; the actor sends one request per run
  and backs off on 429/5xx. `robots.txt` allows everything. The data is NASA's, published for open use — check the
  source's own terms before you republish it.

***

Made by **Yadroo**. Sibling actors: [open-meteo-weather](https://apify.com/yadroo/open-meteo-weather) ·
[osm-geocode](https://apify.com/yadroo/osm-geocode) · [public-holidays](https://apify.com/yadroo/public-holidays) ·
[google-news-search](https://apify.com/yadroo/google-news-search) · [rss-to-json](https://apify.com/yadroo/rss-to-json)

# Actor input Schema

## `mode` (type: `string`):

`events` writes one row per event: where it stands now (latest coordinates, latest magnitude), when it started, whether it is still open. `track` unrolls the same events into their recorded positions over time, which is what a storm path, an iceberg drift or a growing fire looks like on a map. The two modes write different fields, so pick one per run and read the matching dataset view.

## `eventIds` (type: `array`):

Fetch named events directly instead of searching, e.g. \["EONET\_24482"]. Ids look like `EONET_` plus a number and appear in `eventId` of every row, so a dashboard can re-read the same fire or storm each hour. An id the source does not know yields one row with `found: false` rather than a silent empty run. When this list is filled, the category, region, time and size filters below are ignored.

## `categories` (type: `array`):

Keep only these kinds of event; several entries are combined with OR by the source. Empty = every category. The catalogue is not evenly filled: wildfires, severe storms, volcanoes and sea/lake ice carry hundreds of events a year, while drought, snow, landslides and earthquakes are entered rarely, so a narrow category plus a short time window can legitimately match nothing.

## `status` (type: `string`):

`open` answers "what is burning, erupting or drifting right now" and is what a monitoring schedule wants. `closed` gives the finished events, each with a `closedAt` date, which is the honest basis for counting a season. Editors close events with a delay of days, so an event that visibly ended may still be open here.

## `region` (type: `string`):

A named box of longitudes and latitudes that is sent to the source as a spatial filter, so events outside it are never fetched or paid for. The exact corners of every region are printed in README > Reference dictionaries, and `bbox` below overrides this field when you need your own box. An event counts as inside when the source places it there; a storm that crosses the edge appears with the part of its track that the source kept.

## `bbox` (type: `string`):

Your own rectangle instead of a named region, written as four numbers in the source's order: west edge, north edge, east edge, south edge, e.g. `46,56,88,35` for Kazakhstan and its neighbours or `-125,50,-100,31` for the US West. The actor checks the order and stops with a clear message when the corners are swapped, instead of quietly returning the whole planet.

## `sources` (type: `array`):

Keep only events that at least one of these organisations reported; several entries are combined with OR. Use it when the reporter decides whether you trust the row: the ice centre for icebergs, the typhoon warning centre for Pacific storms, the volcanism programme for eruptions, the wildfire agencies for fires in their own province or state. Empty = every reporter. The ids come back in `sourceIds` and their pages in `sourceUrls`.

## `sinceDays` (type: `integer`):

Keep events with at least one recorded position inside this many days back from the start of the run. 7 answers "what moved this week", 90 covers a storm season. Leave it empty to ignore the age of an event, which matters for long-running volcanoes and icebergs: a volcano that has erupted since 2021 is open but may have no fresh position, so a short window hides it. Ignored when `startDate` is set.

## `startDate` (type: `string`):

Explicit window start as `2026-01-01`, used instead of `sinceDays` when you want a fixed period such as one fire season or one hurricane year. Inclusive.

## `endDate` (type: `string`):

Explicit window end, same format, inclusive. Empty = the day the run starts. Only used together with `startDate`.

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

A finer filter than `sinceDays`, applied by the actor after fetching: an event is kept when its newest recorded position is younger than this. 24 gives you the events that actually moved since yesterday, which is what a daily map refresh needs. Reporters update on their own rhythm - storm centres every six hours, ice and fire agencies once or twice a day - so windows under six hours are often empty by nature.

## `onlyNew` (type: `boolean`):

Remember the event ids of this actor in its key-value store and write only ids that are not there yet. Built for schedules: run it every morning with `status: open` and each run reports the events that appeared since the previous one. The first run writes everything it matches, so start it once by hand before you schedule it.

## `magnitudeId` (type: `string`):

Which measurement the size bounds below apply to. Each category carries its own kind of number - fires in acres or hectares, storms in knots of sustained wind, icebergs in square nautical miles - so a size filter only makes sense together with the matching category. Leave empty to ignore size.

## `magnitudeMin` (type: `integer`):

Lower bound on the measurement chosen above, inclusive: 1000 with acres keeps the large fires and drops the long tail of small ones, 64 with knots keeps hurricane-force storms, 100 with square nautical miles keeps the big icebergs.

## `magnitudeMax` (type: `integer`):

Upper bound on the same measurement, inclusive. Use it with the lower bound to cut one band out, for example tropical-storm strength between 34 and 63 knots.

## `titleContains` (type: `array`):

Keep only events whose title holds one of these words, compared without case, e.g. \["iceberg"] or \["typhoon", "hurricane"]. Titles are written by the editors and usually name the fire, the storm or the volcano plus its country or county, so this is the quickest way to follow one named storm across runs. Empty = no text filter.

## `sortBy` (type: `string`):

The order the actor applies before it cuts the result set to `maxItems`, so it decides which events you keep when the filters match more than you asked for. Newest activity first is the monitoring order; largest size first answers "the biggest fires burning now" and puts events without a measurement at the end. In track mode the positions of each event always stay in time order.

## `includePolygonCoordinates` (type: `boolean`):

Some events - flood extents, large fire perimeters - are published as polygons with hundreds of corner points. By default a row carries the centre of such a polygon in `latitude`/`longitude` and leaves `polygonCoordinates` empty, which keeps the dataset readable in a table. Switch this on when you draw the real outline on a map and can handle long arrays.

## `maxItems` (type: `integer`):

Stop after this many rows: events in `events` mode, positions in `track` mode. The source returns a whole filtered result set in one response and ignores small limits, so the actor applies this cap itself after sorting - a small number keeps the run short and cheap.

## `maxTrackPointsPerEvent` (type: `integer`):

Upper bound on the positions written for a single event in `track` mode, counted from the newest backwards. A six-hourly storm advisory over two weeks is about 60 positions; a long-lived iceberg can hold thousands, which would fill a run on its own.

## `fields` (type: `array`):

Keep only these fields, in this order, e.g. \["eventId", "title", "latitude", "longitude", "lastDate"]. Empty = every field of the mode.

## Actor input object example

```json
{
  "mode": "events",
  "categories": [
    "wildfires"
  ],
  "status": "open",
  "region": "world",
  "onlyNew": false,
  "sortBy": "latest",
  "includePolygonCoordinates": false,
  "maxItems": 50,
  "maxTrackPointsPerEvent": 200
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "categories": [
        "wildfires"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("yadroo/nasa-eonet-events").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 = { "categories": ["wildfires"] }

# Run the Actor and wait for it to finish
run = client.actor("yadroo/nasa-eonet-events").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 '{
  "categories": [
    "wildfires"
  ]
}' |
apify call yadroo/nasa-eonet-events --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yadroo/nasa-eonet-events"
        }
    }
}
```

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/RTfUevztka2q6hyS5/builds/XW2RbYa2xMh6Q04K2/openapi.json