# NASA EONET Natural Events Scraper (`parseforge/eonet-natural-events-scraper`) Actor

Track active natural events worldwide from NASA EONET — wildfires, severe storms, volcanoes, floods, sea ice, earthquakes. Filter by category, status, days back, magnitude bounds, and bounding box. Returns geometry, sources, and full event timelines.

- **URL**: https://apify.com/parseforge/eonet-natural-events-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $24.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/main/banners/banner-default.jpg?raw=true)

## 🌋 NASA EONET Natural Events Scraper

> 🚀 **Track Earth's natural events live, in seconds.** Pull active **wildfires, severe storms, volcanoes, floods, sea ice, earthquakes, droughts, landslides** and more from NASA's official Earth Observatory Natural Event Tracker. Filter by category, status, magnitude, and bounding box. No sign-up, no scraping, no parser to maintain.

> 🕒 **Last updated:** 2026-05-15 · **📊 19 fields** per record · **🌋 13 event categories** · **🌍 Worldwide** · **🛰️ NASA-backed**

The **NASA EONET Natural Events Scraper** queries the official EONET (Earth Observatory Natural Event Tracker) feed and returns up to **19 structured fields per record**, including the event ID, title, status (open / closed), description, categories, first and last reporting timestamps, latitude / longitude, peak magnitude with units, full geometry, and the upstream reporting sources (CAL FIRE, USGS, NOAA, Smithsonian, NASA, and more).

The catalogue covers **every category of natural event NASA tracks worldwide**, from wildfires and severe storms to volcanic activity, sea-and-lake ice, floods, dust and haze, earthquakes, drought, landslides, snow events, temperature extremes, water-color anomalies, and manmade events. This Actor makes that data downloadable as CSV, Excel, JSON, or XML in under five minutes. Filters run server-side, so you skip the parser engineering entirely.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Insurance and reinsurance teams, climate scientists, GIS engineers, emergency-management agencies, journalists, energy traders, supply-chain risk teams, civic-tech and disaster-response NGOs | Catastrophe-event monitoring, parametric-insurance triggers, climate research feeds, emergency dashboards, supply-chain disruption alerts, news-desk situational awareness, satellite-imagery cueing |

---

### 📋 What the EONET Natural Events Scraper does

Seven filtering workflows in a single run:

- 🌋 **Category filter.** Pick a single category from 13 (wildfires, severe storms, volcanoes, floods, sea and lake ice, earthquakes, drought, landslides, manmade, snow, temperature extremes, dust and haze, water color).
- 🚦 **Status filter.** Open (active), closed (ended), or all.
- 📅 **Days back.** Restrict to events with activity in the last N days (1-365).
- 📡 **Reporting source filter.** Restrict to a single monitoring agency (CAL FIRE, IRWIN, NOAA NHC, USGS, Smithsonian Volcanism, Copernicus EMS, FEMA, NASA Hurricane updates, and 25+ more).
- 📊 **Magnitude bounds.** Filter by minimum and maximum event magnitude (units depend on category - acres for wildfires, knots for storms, and so on).
- 📐 **Bounding box.** Restrict events to a geographic region (`minLon,minLat,maxLon,maxLat`).
- 🔢 **Max items.** Cap the dataset size for quick previews or full pulls.

Each record includes the EONET event ID, the event URL, title, current status (open / closed), the close date if ended, an optional description, the human-readable categories and their slug IDs, the first and last reporting timestamps, the latest known latitude and longitude, the peak magnitude with units, the geometry count, geometry type (Point or Polygon), every reporting source with its origin URL, the full geometry array (every position the event has been reported at), and a scrape timestamp.

> 💡 **Why it matters:** real-time natural-event tracking drives parametric-insurance payouts, news-desk situational awareness, climate-risk dashboards, and supply-chain alerting. Building your own pipeline means writing a feed client, mapping 13 categories to internal taxonomies, normalising magnitude units, and refreshing constantly. This Actor skips all of that and gives you a clean refreshed snapshot on every run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded EONET dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>category</code></td><td>string</td><td><code>""</code></td><td>One of 13 EONET categories. Empty = all categories.</td></tr>
<tr><td><code>status</code></td><td>string</td><td><code>"open"</code></td><td><code>open</code> (active), <code>closed</code> (ended), or <code>all</code>.</td></tr>
<tr><td><code>days</code></td><td>integer</td><td><em>none</em></td><td>Restrict to events with activity in the last N days (1-365).</td></tr>
<tr><td><code>source</code></td><td>string</td><td><code>""</code></td><td>One of 30+ reporting sources (CAL FIRE, IRWIN, NOAA NHC, USGS, and more).</td></tr>
<tr><td><code>magnitudeMin</code></td><td>integer</td><td><em>none</em></td><td>Minimum event magnitude (units depend on category).</td></tr>
<tr><td><code>magnitudeMax</code></td><td>integer</td><td><em>none</em></td><td>Maximum event magnitude.</td></tr>
<tr><td><code>bbox</code></td><td>string</td><td><code>""</code></td><td>Bounding box: <code>minLon,minLat,maxLon,maxLat</code>.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: every active wildfire in the contiguous United States.**

```json
{
    "maxItems": 200,
    "category": "wildfires",
    "status": "open",
    "bbox": "-125,24,-66,49"
}
````

**Example: severe storms reported in the last 30 days, both active and closed.**

```json
{
    "maxItems": 100,
    "category": "severeStorms",
    "status": "all",
    "days": 30
}
```

> ⚠️ **Good to Know:** EONET aggregates upstream reporting agencies, and each event inherits the reporting cadence and accuracy of its source (CAL FIRE updates wildfire perimeters frequently, USGS posts earthquake epicentres within minutes, Smithsonian reports volcano activity on observatory schedules). Use the `sources` field on each record to see exactly which agencies are reporting.

***

### 📊 Output

Each event record carries up to **19 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `id` | string | `"EONET_20098"` |
| 🔗 `url` | string | `"https://eonet.gsfc.nasa.gov/api/v3/events/EONET_20098"` |
| 📌 `title` | string | `"Eagle Lake Fire Wildfire, Hancock, Iowa"` |
| 🚦 `status` | string | `"open"` |
| 📅 `closedAt` | ISO 8601 | null | `null` |
| 📝 `description` | string | null | `null` |
| 🏷️ `categories` | array | `["Wildfires"]` |
| 🆔 `categoryIds` | array | `["wildfires"]` |
| 📅 `firstReportedAt` | ISO 8601 | `"2026-05-14T11:04:00Z"` |
| 📅 `lastReportedAt` | ISO 8601 | `"2026-05-14T11:04:00Z"` |
| 📍 `latitude` | number | `43.11279415` |
| 📍 `longitude` | number | `-93.72348843` |
| 📊 `peakMagnitudeValue` | number | null | `550` |
| 📏 `magnitudeUnit` | string | null | `"acres"` |
| 🔢 `geometryCount` | number | `1` |
| 📐 `geometryType` | string | `"Point"` |
| 📦 `sources` | array | `[{"id": "IRWIN", "url": "https://irwin.doi.gov/..."}]` |
| 📦 `geometry` | array | `[{"date", "type", "coordinates", "magnitudeValue", "magnitudeUnit"}]` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-15T18:25:17.672Z"` |

#### 📦 Sample record

<details>
<summary><strong>🔥 Active wildfire: Eagle Lake Fire, Hancock County, Iowa</strong></summary>

```json
{
    "id": "EONET_20098",
    "url": "https://eonet.gsfc.nasa.gov/api/v3/events/EONET_20098",
    "title": "Eagle Lake Fire Wildfire, Hancock, Iowa",
    "status": "open",
    "categories": ["Wildfires"],
    "categoryIds": ["wildfires"],
    "firstReportedAt": "2026-05-14T11:04:00Z",
    "lastReportedAt": "2026-05-14T11:04:00Z",
    "latitude": 43.11279415,
    "longitude": -93.72348843,
    "peakMagnitudeValue": 550,
    "magnitudeUnit": "acres",
    "geometryCount": 1,
    "geometryType": "Point",
    "sources": [
        {"id": "IRWIN", "url": "https://irwin.doi.gov/observer/incidents/c283aec9-aab3-4720-addc-47bb6a433a32"}
    ],
    "geometry": [
        {
            "magnitudeValue": 550,
            "magnitudeUnit": "acres",
            "date": "2026-05-14T11:04:00Z",
            "type": "Point",
            "coordinates": [-93.72348843, 43.11279415]
        }
    ],
    "scrapedAt": "2026-05-15T18:25:17.672Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🌍 | **Global coverage.** Active and closed natural events worldwide across 13 categories. |
| 🎯 | **Multi-dimensional filters.** Category, status, days back, source, magnitude bounds, and bounding box combine freely. |
| 🛰️ | **Authoritative source.** NASA's official Earth Observatory Natural Event Tracker, fed by CAL FIRE, USGS, NOAA, Smithsonian, Copernicus EMS, and 25+ agencies. |
| 📐 | **Full geometry.** Every reported position kept as a `geometry` array, plus the latest lat/lon as scalars. |
| ⚡ | **Fast.** 100 events in seconds, full active set in under a minute. |
| 🔁 | **Always fresh.** Every run hits the live tracker, so the dataset reflects current activity. |
| 🚫 | **No authentication.** Public open-data feed. No login needed. |

> 📊 Real-time natural-event data sits at the heart of every parametric-insurance trigger, news-desk catastrophe monitor, and climate-risk dashboard.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ NASA EONET Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **13 categories, worldwide** | **Live per run** | category, status, days, source, magnitude, bounding box | ⚡ 2 min |
| Commercial catastrophe data feeds | $10k - $100k/year | Comparable + analytics | Streaming | Many | 🐢 Weeks (procurement) |
| Direct USGS / NOAA / CAL FIRE feeds | Free | Single agency each | Variable | Source-specific | 🕒 Days per source |
| News-driven event tracking | Variable | Editorial subset | Manual | None | ⏳ Inconsistent |

Pick this Actor when you want consolidated multi-agency coverage, server-side filtering, and zero pipeline maintenance.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the NASA EONET Natural Events Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a category (or leave empty), choose a status, optionally add a date window, magnitude range, or bounding box, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor pull the live tracker.
5. 📥 **Download.** Grab your dataset in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to a downloaded events dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🏦 Insurance & Reinsurance

- Parametric-trigger monitoring for wildfire and storm policies
- Loss-reserve modelling fed by live event geometry
- Catastrophe-bond tracking with magnitude bounds
- Real-time exposure dashboards for underwriters

</td>
<td width="50%" valign="top">

#### 📰 Newsroom & Situational Awareness

- Live wildfire and storm dashboards for news desks
- Volcano-activity alerts cued by Smithsonian reports
- Earthquake bulletins seeded with USGS source links
- Map-based explainers for breaking-news segments

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🚚 Supply Chain & Logistics

- Disruption alerts when storms enter shipping lanes
- Wildfire proximity checks for warehouse footprints
- Volcano ash-cloud monitoring for aviation routing
- Flood-event triggers on intermodal nodes

</td>
<td width="50%" valign="top">

#### ⚡ Energy & Commodities

- Hurricane tracking for Gulf of Mexico operations
- Wildfire alerts for grid and pipeline corridors
- Flood and drought signals for hydro and agriculture trades
- Volcano monitoring for SO2 emissions and shipping

</td>
</tr>
</table>

***

### 🔌 Automating EONET Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Hourly refreshes during fire season, every-15-minute refreshes for hurricane tracking, daily refreshes for archival catalogues - all kept in sync automatically.

***

### 🌟 Beyond business use cases

Open natural-event data powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Climate-impact studies tracking event frequency over years
- Geography coursework on wildfire and storm geography
- Reproducible disaster datasets for environmental papers
- Cross-disciplinary research linking events to socio-economic data

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects mapping every active wildfire on a globe
- Live storm-tracker dashboards for hobbyist meteorologists
- Data-art pieces visualising volcanic activity over time
- Personal weather-and-disaster newsletters

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Disaster-response tools for volunteer emergency networks
- Civic dashboards alerting communities to nearby events
- Investigative journalism on under-reported natural disasters
- Mutual-aid platforms cued by live event feeds

</td>
<td width="50%">

#### 🧪 Experimentation

- Train classification models on event categories from titles
- Build agent pipelines that brief emergency teams on overnight events
- Prototype satellite-imagery cueing systems on event geometry
- Stress-test mapping infrastructure with real geo data

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20NASA%20EONET%20Natural%20Events%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20NASA%20EONET%20Natural%20Events%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20NASA%20EONET%20Natural%20Events%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20NASA%20EONET%20Natural%20Events%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a category, status, and optional filters in the input form, click Start, and the Actor pulls the live event tracker, applies your filters, and emits a clean structured row per event. No browser automation, no captchas, no setup.

#### 📏 How accurate is the data?

Every event inherits the accuracy of its upstream reporting agency (CAL FIRE for wildfires, USGS for earthquakes, NOAA for hurricanes, Smithsonian for volcanoes). Use the `sources` field to see which agencies reported each event and follow the source URL for full detail.

#### 🔁 How often is the dataset refreshed?

EONET is updated continuously as upstream agencies post new reports. Every run of this Actor pulls the live tracker.

#### 🌋 Which event categories are supported?

Wildfires, severe storms, volcanoes, floods, sea and lake ice, earthquakes, drought, landslides, manmade events, snow events, temperature extremes, dust and haze, and water color anomalies.

#### 📊 What units are magnitudes in?

Units depend on the category. Wildfires use acres, severe storms use knots (sustained wind), volcanoes use VEI when reported, and so on. The `magnitudeUnit` field on every record names the unit explicitly.

#### 📐 How do I scope to a country or region?

Use the `bbox` filter with `minLon,minLat,maxLon,maxLat`. For example, the contiguous US is `-125,24,-66,49`, mainland Europe is roughly `-12,35,30,72`, and Japan is `128,30,146,46`.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (every 15 minutes during hurricane season, hourly for wildfires, daily for archival pulls).

#### ⚖️ Is this data legal to use?

EONET is published under NASA's open-data policy. NASA-produced data is generally free of copyright restrictions in the United States. Review NASA's terms for your specific application.

#### 💼 Can I use this data commercially?

Yes. NASA EONET data is open for commercial reuse. You remain responsible for following NASA's usage guidelines and crediting upstream agencies where appropriate.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. If a run still fails, you can inspect the log in the Runs tab, fix the input, and re-run. Partial datasets from failed runs are preserved so you never lose progress.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

NASA EONET Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step disaster-monitoring workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get new-event alerts in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe events into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh wildfire perimeters into your insurance dashboard, or alert your operations team in Slack when a hurricane crosses a watch zone.

***

### 🔗 Recommended Actors

- [**🛰️ CelesTrak TLE Satellites Scraper**](https://apify.com/parseforge/celestrak-tle-satellites-scraper) - Two-line element sets for tracking active satellites
- [**🚀 Launch Library SpaceDevs Scraper**](https://apify.com/parseforge/ll-spacedevs-launch-scraper) - Upcoming and historical rocket launches worldwide
- [**🌅 NASA Astronomy Picture of the Day Scraper**](https://apify.com/parseforge/apod-nasa-images-scraper) - APOD archive with full metadata
- [**🌎 OurAirports Global Airport Database Scraper**](https://apify.com/parseforge/ourairports-scraper) - 85,000+ airports worldwide
- [**⚡ Carbon Intensity UK Scraper**](https://apify.com/parseforge/carbon-intensity-uk-scraper) - National Grid carbon intensity feed

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by NASA, the Earth Observatory, or any of the agencies whose reports EONET aggregates. All trademarks mentioned are the property of their respective owners. Only publicly available open natural-event data is collected.

# Actor input Schema

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

What to scrape. Events returns natural-event records (default). Categories, Sources and Layers enumerate the EONET catalogue dimensions for discovery.

## `category` (type: `string`):

Filter to a specific natural event category. Leave empty to include every category.

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

Open events are still active. Closed events have ended. All returns both.

## `days` (type: `integer`):

Limit results to events with activity in the last N days. Leave empty for no time limit.

## `source` (type: `string`):

Filter to events reported by a specific monitoring source.

## `magnitudeMin` (type: `number`):

Only include events with magnitude value at or above this threshold. Decimals are allowed (units depend on category — acres for wildfires, knots for storms, etc.).

## `magnitudeMax` (type: `number`):

Only include events with magnitude value at or below this threshold. Decimals are allowed.

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

Restrict events to a geographic box. Format: minLon,minLat,maxLon,maxLat (e.g. -125,24,-66,49 for the contiguous US).

## `maxGeometryPoints` (type: `integer`):

Cap the geometry array per event (most-recent points kept). Set to 0 to skip geometry entirely. Default 200.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "mode": "events",
  "category": "",
  "status": "all",
  "source": "",
  "bbox": "",
  "maxGeometryPoints": 200,
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview of scraped data

## `fullData` (type: `string`):

Complete dataset

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/eonet-natural-events-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/eonet-natural-events-scraper").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 '{
  "maxItems": 10
}' |
apify call parseforge/eonet-natural-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NASA EONET Natural Events Scraper",
        "description": "Track active natural events worldwide from NASA EONET — wildfires, severe storms, volcanoes, floods, sea ice, earthquakes. Filter by category, status, days back, magnitude bounds, and bounding box. Returns geometry, sources, and full event timelines.",
        "version": "0.0",
        "x-build-id": "u1b9YEKPGKRYTp7rL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~eonet-natural-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-eonet-natural-events-scraper",
                "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/parseforge~eonet-natural-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-eonet-natural-events-scraper",
                "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/parseforge~eonet-natural-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-eonet-natural-events-scraper",
                "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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "events",
                            "categories",
                            "sources",
                            "layers"
                        ],
                        "type": "string",
                        "description": "What to scrape. Events returns natural-event records (default). Categories, Sources and Layers enumerate the EONET catalogue dimensions for discovery.",
                        "default": "events"
                    },
                    "category": {
                        "title": "Event Category",
                        "enum": [
                            "",
                            "drought",
                            "dustHaze",
                            "earthquakes",
                            "floods",
                            "landslides",
                            "manmade",
                            "seaLakeIce",
                            "severeStorms",
                            "snow",
                            "tempExtremes",
                            "volcanoes",
                            "waterColor",
                            "wildfires"
                        ],
                        "type": "string",
                        "description": "Filter to a specific natural event category. Leave empty to include every category.",
                        "default": ""
                    },
                    "status": {
                        "title": "Event Status",
                        "enum": [
                            "all",
                            "open",
                            "closed"
                        ],
                        "type": "string",
                        "description": "Open events are still active. Closed events have ended. All returns both.",
                        "default": "all"
                    },
                    "days": {
                        "title": "Days Back",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Limit results to events with activity in the last N days. Leave empty for no time limit."
                    },
                    "source": {
                        "title": "Reporting Source",
                        "enum": [
                            "",
                            "AVO",
                            "ABFIRE",
                            "AU_BOM",
                            "BYU_ICE",
                            "BCWILDFIRE",
                            "CALFIRE",
                            "CEMS",
                            "EO",
                            "Earthdata",
                            "FEMA",
                            "FloodList",
                            "GDACS",
                            "GLIDE",
                            "InciWeb",
                            "IRWIN",
                            "IDC",
                            "JTWC",
                            "MRR",
                            "MBFIRE",
                            "NASA_ESRS",
                            "NASA_DISP",
                            "NASA_HURR",
                            "NOAA_NHC",
                            "NOAA_CPC",
                            "PDC",
                            "ReliefWeb",
                            "SIVolcano",
                            "NATICE",
                            "UNISYS",
                            "USGS_EHP",
                            "USGS_CMT",
                            "HDDS",
                            "DFES_WA"
                        ],
                        "type": "string",
                        "description": "Filter to events reported by a specific monitoring source.",
                        "default": ""
                    },
                    "magnitudeMin": {
                        "title": "Minimum Magnitude",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only include events with magnitude value at or above this threshold. Decimals are allowed (units depend on category — acres for wildfires, knots for storms, etc.)."
                    },
                    "magnitudeMax": {
                        "title": "Maximum Magnitude",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only include events with magnitude value at or below this threshold. Decimals are allowed."
                    },
                    "bbox": {
                        "title": "Bounding Box",
                        "type": "string",
                        "description": "Restrict events to a geographic box. Format: minLon,minLat,maxLon,maxLat (e.g. -125,24,-66,49 for the contiguous US).",
                        "default": ""
                    },
                    "maxGeometryPoints": {
                        "title": "Max Geometry Points per Event",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap the geometry array per event (most-recent points kept). Set to 0 to skip geometry entirely. Default 200.",
                        "default": 200
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```