# USGS Earthquake Scraper — Global Seismic Events API (`logiover/usgs-earthquake-scraper`) Actor

Scrape USGS earthquake data by time range or magnitude. Extract id, place, magnitude, depth, coordinates, tsunami flag, alert level, and more. No API key, no login.

- **URL**: https://apify.com/logiover/usgs-earthquake-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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

## USGS Earthquake Scraper — Global Seismic Data, Magnitude, Depth & Alerts

Extract earthquake events worldwide from the USGS (United States Geological Survey) public API. Filter by time range, magnitude, and geographic bounding box. No API key or account required.

### What does USGS Earthquake Scraper do?

This actor queries the USGS Earthquake Hazards Program's official FDSN Web Service (`earthquake.usgs.gov/fdsnws/event/1/query`) — a free, keyless REST endpoint that provides real-time and historical seismic data for the entire planet. You supply a time window and optional magnitude threshold; the actor fetches a GeoJSON FeatureCollection, parses every feature, and delivers structured rows to your Apify dataset.

Each earthquake record carries the full set of USGS properties: timestamp (millisecond-precision, converted to ISO 8601), human-readable location description, magnitude and magnitude type (ml, mb, mw, etc.), WGS-84 coordinates (longitude, latitude, depth in km), tsunami flag, community-sourced felt reports, PAGER alert level (green/yellow/orange/red), review status (automatic or reviewed), event type, and a direct link to the USGS detail page.

The API supports up to 20,000 events per request. For longer historical spans or lower magnitude thresholds that would exceed 20,000 events, simply split your query into shorter time windows and run the actor multiple times — all results can be merged in Google Sheets or any ETL tool.

### Who is it for?

- **Earth scientists and seismologists** who need bulk seismic catalogs for statistical analysis, clustering algorithms, or recurrence-rate modeling.
- **Emergency management professionals** monitoring recent significant earthquakes (M 4.0+) across a region or globally for situational awareness dashboards.
- **Data journalists and newsrooms** building maps of major earthquakes for breaking-news stories or long-form earthquake risk investigations.
- **Insurance and reinsurance analysts** assessing seismic exposure, historical loss accumulation, and probabilistic hazard curves for a portfolio of locations.
- **Researchers and academics** building ML training datasets for earthquake early-warning systems, aftershock prediction models, or geo-hazard AI projects.

### Use cases

- **Global earthquake feed**: Pull all M 2.5+ quakes from the past 30 days and refresh a public dashboard or newsletter automatically.
- **Regional hazard analysis**: Filter by bounding box (e.g. Japan, Turkey, California) to build a time-series of local seismicity for academic research.
- **Tsunami risk monitoring**: Filter `tsunami=1` events to identify earthquakes that triggered tsunami watches or warnings over a historical period.
- **Felt-report analysis**: Collect events with high `felt` counts to understand public-impact patterns for urban resilience planning.
- **Training data generation**: Produce labeled datasets (magnitude, depth, location, alert level) for machine-learning earthquake classification tasks.

### Why use USGS Earthquake Scraper?

- **Completely keyless**: The USGS FDSN endpoint is a public government data service — no signup, no API key, no credits, zero friction.
- **15 output fields per event**: id, time, place, magnitude, magType, longitude, latitude, depth, tsunami, felt, alert, status, type, url, title — plus supplementary fields like cdi, mmi, sig, gap, rms, nst.
- **Bulk extracts up to 20,000 events**: One run can return a full month of global M 2.5+ activity (typically 8,000–15,000 events).
- **Flexible filtering**: Time range, min/max magnitude, and four-corner bounding box let you scope queries precisely.
- **Two modes**: `query` mode returns full event records; `count` mode returns only a metadata summary — useful for quick dashboards.
- **Pay-per-result Apify pricing**: You only pay for compute time; data is free from USGS.
- **Export in any format**: Apify dataset exports to JSON, CSV, Excel, XML, RSS, or JSONL in one click.

### What data can you extract?

Each row in the output dataset represents one earthquake event. Here is the complete field reference:

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | USGS event identifier (e.g. `us7000mwak`) |
| `time` | string | Event origin time in ISO 8601 UTC (ms precision) |
| `updated` | string | Last time USGS updated this event record |
| `place` | string | Human-readable location string (e.g. "42 km SSE of Haines, Alaska") |
| `magnitude` | number | Preferred magnitude value |
| `magType` | string | Magnitude scale (ml, mb, mw, mww, mwc, md, etc.) |
| `longitude` | number | WGS-84 longitude in decimal degrees |
| `latitude` | number | WGS-84 latitude in decimal degrees |
| `depth` | number | Hypocenter depth in kilometers |
| `tsunami` | number | 1 if a tsunami message was issued, 0 otherwise |
| `felt` | number | Number of "Did You Feel It?" responses from the public |
| `cdi` | number | Maximum reported community-sourced intensity (DYFI) |
| `mmi` | number | Maximum estimated instrumental intensity (ShakeMap) |
| `alert` | string | PAGER alert level: green, yellow, orange, or red |
| `status` | string | `automatic` (machine-generated) or `reviewed` (human-verified) |
| `type` | string | Event type (earthquake, quarry blast, ice quake, etc.) |
| `url` | string | Direct USGS event page URL |
| `title` | string | Full event title (e.g. "M 5.1 - 42 km SSE of Haines, Alaska") |
| `net` | string | Contributing network code |
| `code` | string | Event code within the contributing network |
| `sig` | number | Significance score (0–1000) combining magnitude, PAGER, DYFI |
| `nst` | number | Number of seismic stations used to locate the earthquake |
| `gap` | number | Largest azimuthal gap between stations in degrees |
| `rms` | number | Root-mean-square travel-time residual in seconds |
| `dmin` | number | Horizontal distance from epicenter to nearest station in degrees |

#### Example output record

```json
{
  "id": "us7000mwak",
  "time": "2026-06-15T03:22:41.820Z",
  "updated": "2026-06-15T05:17:03.040Z",
  "place": "42 km SSE of Haines, Alaska",
  "magnitude": 5.1,
  "magType": "mww",
  "longitude": -135.1432,
  "latitude": 59.0871,
  "depth": 10.0,
  "tsunami": 0,
  "felt": 234,
  "cdi": 4.8,
  "mmi": 5.2,
  "alert": "green",
  "status": "reviewed",
  "type": "earthquake",
  "url": "https://earthquake.usgs.gov/earthquakes/eventpage/us7000mwak",
  "title": "M 5.1 - 42 km SSE of Haines, Alaska",
  "net": "us",
  "code": "7000mwak",
  "sig": 400,
  "nst": 87,
  "gap": 34,
  "rms": 0.71,
  "dmin": 0.428
}
````

### How to use

#### Option A — Query by time range and magnitude (most common)

Use this when you want all earthquakes globally or for a region during a specific period.

1. Open the actor and click **Try for free**.
2. Set **Mode** to `query`.
3. Set **Start Time** to your period start (e.g. `2026-01-01`).
4. Set **End Time** to your period end (e.g. `2026-06-30`).
5. Set **Minimum Magnitude** to your threshold (e.g. `4.0` for significant quakes, `2.5` for regional analysis).
6. Optionally set bounding box fields to restrict to a region.
7. Click **Start** and download results when the run completes.

**Example input (global M 4.0+ in June 2026):**

```json
{
  "mode": "query",
  "startTime": "2026-06-01",
  "endTime": "2026-07-01",
  "minMagnitude": 4.0,
  "maxResults": 20000
}
```

#### Option B — Count mode (metadata only)

Use this when you just need to know how many earthquakes match your criteria before committing to a full extraction.

1. Set **Mode** to `count`.
2. Fill in the same time/magnitude/bbox filters.
3. The actor returns one row with a `count` field and USGS metadata.

**Example input (count M 6.0+ globally, last year):**

```json
{
  "mode": "count",
  "startTime": "2025-07-01",
  "endTime": "2026-07-01",
  "minMagnitude": 6.0
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `query` | `query` returns event records; `count` returns event count only |
| `startTime` | string | — | Start of time window (ISO 8601, e.g. `2026-06-01`) |
| `endTime` | string | — | End of time window (ISO 8601). Defaults to current time if omitted |
| `minMagnitude` | number | `2.5` | Minimum magnitude threshold (0–10) |
| `maxMagnitude` | number | — | Maximum magnitude filter (optional) |
| `maxResults` | integer | `20000` | Hard cap on returned events (USGS API maximum is 20,000) |
| `minLatitude` | number | — | Bounding box south latitude (-90 to 90) |
| `maxLatitude` | number | — | Bounding box north latitude (-90 to 90) |
| `minLongitude` | number | — | Bounding box west longitude (-180 to 180) |
| `maxLongitude` | number | — | Bounding box east longitude (-180 to 180) |
| `proxy` | object | Datacenter | Apify proxy configuration. Datacenter is sufficient for USGS |

**Full example input JSON:**

```json
{
  "mode": "query",
  "startTime": "2026-06-01",
  "endTime": "2026-07-01",
  "minMagnitude": 4.0,
  "maxResults": 20000,
  "minLatitude": 30,
  "maxLatitude": 50,
  "minLongitude": 125,
  "maxLongitude": 145,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["DATACENTER"]
  }
}
```

### Output example

```json
{
  "id": "us7000mwak",
  "time": "2026-06-15T03:22:41.820Z",
  "updated": "2026-06-15T05:17:03.040Z",
  "place": "42 km SSE of Haines, Alaska",
  "magnitude": 5.1,
  "magType": "mww",
  "longitude": -135.1432,
  "latitude": 59.0871,
  "depth": 10.0,
  "tsunami": 0,
  "felt": 234,
  "cdi": 4.8,
  "mmi": 5.2,
  "alert": "green",
  "status": "reviewed",
  "type": "earthquake",
  "url": "https://earthquake.usgs.gov/earthquakes/eventpage/us7000mwak",
  "title": "M 5.1 - 42 km SSE of Haines, Alaska",
  "net": "us",
  "code": "7000mwak",
  "sig": 400,
  "nst": 87,
  "gap": 34,
  "rms": 0.71,
  "dmin": 0.428
}
```

### Tips for best results

- **Time range matters for volume**: A 30-day window at M 2.5+ globally yields roughly 8,000–15,000 events. Use shorter windows for lower magnitude thresholds to stay under the 20,000 limit.
- **Use M 4.0+ for "significant" global quakes**: At this threshold, a full month returns 400–800 events — a manageable dataset for most analysis.
- **Bounding box for regional studies**: Use the four latitude/longitude fields to restrict output to a specific country or fault zone. Japan bbox: minLat 30, maxLat 47, minLon 129, maxLon 146.
- **Count mode first**: Before running a large query, use `count` mode to verify how many events will be returned — avoids surprises.
- **Schedule recurring runs**: Use Apify's built-in Scheduler to pull fresh data daily or weekly for monitoring dashboards.
- **`reviewed` vs `automatic` status**: Machine-processed events (automatic) may have slightly less accurate locations. Filter `status=reviewed` for scientific accuracy.
- **Tsunami flag filtering**: Post-process to `tsunami === 1` to identify historically impactful events for coastal risk work.
- **Combine with Google Sheets**: Connect your dataset to Google Sheets via Apify integration for live earthquake tracking spreadsheets.
- **Depth interpretation**: Shallow quakes (depth < 70 km) generally cause more surface damage. Filter by depth for structural engineering analysis.
- **Alert level for impact triage**: PAGER alert green/yellow/orange/red maps to estimated fatality/economic thresholds — use it to quickly flag high-impact events.

### Integrations

The actor output integrates with any tool that can read Apify datasets:

- **Google Sheets**: Use the [Apify Google Sheets integration](https://apify.com/apify/google-sheets-import-export) to automatically sync earthquake data into a spreadsheet.
- **Slack**: Send earthquake alerts to a Slack channel via Apify webhooks triggered on run completion.
- **Zapier / Make**: Connect the dataset to 5,000+ apps — pipe new earthquakes into Airtable, Notion, a custom database, or an email template.
- **Webhooks**: Configure a POST webhook in the actor settings to notify your own API endpoint when a run finishes.
- **Scheduled runs**: Use Apify Scheduler to run the actor every hour or day and keep a fresh time-series of seismic activity.

### API usage

**cURL:**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/logiover~usgs-earthquake-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startTime": "2026-06-01",
    "endTime": "2026-07-01",
    "minMagnitude": 4.0
  }'
```

**Node.js (Apify client):**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('logiover/usgs-earthquake-scraper').call({
  startTime: '2026-06-01',
  endTime: '2026-07-01',
  minMagnitude: 4.0,
});

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

**Python:**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")

run = client.actor("logiover/usgs-earthquake-scraper").call(run_input={
    "startTime": "2026-06-01",
    "endTime": "2026-07-01",
    "minMagnitude": 4.0,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(f"Got {len(items)} earthquakes")
```

### Use with AI agents (MCP)

This actor is accessible via the [Apify MCP server](https://apify.com/apify/actors-mcp-server), allowing AI assistants like Claude to pull live USGS earthquake data on demand. Example prompt: *"Use the USGS Earthquake Scraper to get all M 5.0+ earthquakes in Turkey in the last 90 days and summarize the seismic activity pattern."* The actor will fetch, parse, and return structured data that the AI can immediately analyze, map, or summarize.

### FAQ

#### Is this actor free to use?

The USGS data source is a free US government public API — no key or account required. You pay only for Apify compute time (typically a few cents per run).

#### What is the geographic coverage?

Global. USGS aggregates seismic data from networks worldwide, including ANSS (Advanced National Seismic System), EMSC, ISC, and regional networks. Coverage is densest in the US, Japan, and Europe but extends to every active seismic zone on Earth.

#### What is the maximum number of results per run?

The USGS FDSN API hard-caps responses at 20,000 events per query. For periods or magnitude thresholds that would produce more events, split into multiple shorter time windows and combine the datasets.

#### Why am I getting zero results?

Check your time range and magnitude threshold. A very narrow window (e.g. a single day) at M 5.0+ may produce 0–5 events globally. Lower `minMagnitude` to 2.5 or widen the time range. Also verify your bounding box coordinates are in the correct order (minLat < maxLat, minLon < maxLon).

#### Some fields are null — is that a problem?

Yes, some fields are optional in USGS data. `felt`, `cdi`, `mmi`, and `alert` are only populated for significant earthquakes that triggered PAGER reports or received DYFI responses. `alert` is null for the majority of small events — this is expected.

#### How current is the data?

USGS updates its feed in near-real-time, with new automatic detections typically appearing within 5–15 minutes of an event. Reviewed events are updated within hours to days depending on significance.

#### Can I filter by event type?

Not directly in the input, but you can post-filter by the `type` field in the output. Values include `earthquake`, `quarry blast`, `explosion`, `ice quake`, `sonic boom`, and more.

#### How do I export data to Excel or CSV?

From the run's dataset view in Apify Console, click the **Export** button and select your format (CSV, Excel, JSON, JSONL, XML). You can also use the [Apify API](https://docs.apify.com/api/v2) to programmatically download datasets.

#### How fast does the actor run?

A single request to the USGS API returns up to 20,000 events in one HTTP call. Total run time is typically 30–90 seconds including build start-up, network fetch, and dataset push.

#### Is scraping USGS earthquake data legal?

The USGS is a US federal government agency. Its earthquake data is published under the [U.S. Government Open Data policy](https://www.data.gov/open-gov/) — fully public domain, freely usable for commercial and non-commercial purposes without restriction.

#### How often should I run the actor for monitoring?

For real-time monitoring, schedule the actor every 1–6 hours with a rolling time window (e.g. last 24 hours at M 4.0+). For historical research, a one-time run per time period is sufficient.

#### Are there related actors for other geo-hazard data?

Yes — check out other data actors in the [logiover collection on Apify Store](https://apify.com/logiover). Related topics include weather data, NOAA datasets, and global news monitoring.

### Is it legal?

This actor accesses data from `earthquake.usgs.gov`, an official US federal government website operated by the United States Geological Survey. All data published by USGS is in the public domain under 17 U.S.C. § 105, which exempts US government works from copyright. The FDSN Web Service is explicitly designed for programmatic access by researchers, developers, and the public. This actor does not scrape a human-facing website — it calls an official documented REST API that the USGS provides specifically for automated data retrieval.

### Related scrapers

- [NOAA Weather Scraper](https://apify.com/logiover) — historical and real-time weather data from NOAA's public APIs.
- [OpenStreetMap B2B Lead Scraper](https://apify.com/logiover/b2b-lead-scraper) — extract business data from OSM by sector and geography.
- [Common Vulnerabilities (CVE) Advisory Scraper](https://apify.com/logiover) — pull CVE/NVD security data without an API key.
- [Certificate Transparency Monitor](https://apify.com/logiover) — track new TLS certificates by domain using crt.sh.

# Actor input Schema

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

Run mode: 'query' to fetch earthquake events, 'count' to return only how many match.

## `timeRange` (type: `string`):

Preset time window for the search. Choose 'Custom range' to set exact Start/End times below.

## `startTime` (type: `string`):

Start of time range in ISO 8601 format (e.g. 2026-06-01 or 2026-06-01T00:00:00). Only used when Time Range is 'Custom range'.

## `endTime` (type: `string`):

End of time range in ISO 8601 format (e.g. 2026-07-01). Defaults to now if omitted. Only used when Time Range is 'Custom range'.

## `minMagnitude` (type: `number`):

Minimum earthquake magnitude (Richter scale). Leave empty to include all magnitudes. Use 4.0+ for significant quakes only.

## `maxMagnitude` (type: `number`):

Maximum earthquake magnitude filter (optional). Leave empty for no upper limit.

## `alertLevel` (type: `string`):

Filter by USGS PAGER alert level. Leave empty for all.

## `sortOrder` (type: `string`):

How to order the returned events.

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

Maximum number of earthquakes to return. Default 1000. USGS API hard cap is 20000 per request; use larger time ranges for more data.

## `minLatitude` (type: `number`):

Bounding box south latitude (-90 to 90). Use with the other bbox fields to filter by region.

## `maxLatitude` (type: `number`):

Bounding box north latitude (-90 to 90).

## `minLongitude` (type: `number`):

Bounding box west longitude (-180 to 180).

## `maxLongitude` (type: `number`):

Bounding box east longitude (-180 to 180).

## `proxy` (type: `object`):

Apify proxy settings. Automatic (any group) is recommended for this public government API.

## Actor input object example

```json
{
  "mode": "query",
  "timeRange": "week",
  "startTime": "2026-06-01",
  "endTime": "2026-07-01",
  "alertLevel": "",
  "sortOrder": "time",
  "maxResults": 1000,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/usgs-earthquake-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("logiover/usgs-earthquake-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 '{}' |
apify call logiover/usgs-earthquake-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USGS Earthquake Scraper — Global Seismic Events API",
        "description": "Scrape USGS earthquake data by time range or magnitude. Extract id, place, magnitude, depth, coordinates, tsunami flag, alert level, and more. No API key, no login.",
        "version": "1.0",
        "x-build-id": "gCSFdYratjxs3sVPE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/logiover~usgs-earthquake-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-logiover-usgs-earthquake-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/logiover~usgs-earthquake-scraper/runs": {
            "post": {
                "operationId": "runs-sync-logiover-usgs-earthquake-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/logiover~usgs-earthquake-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-logiover-usgs-earthquake-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": [
                            "query",
                            "count"
                        ],
                        "type": "string",
                        "description": "Run mode: 'query' to fetch earthquake events, 'count' to return only how many match.",
                        "default": "query"
                    },
                    "timeRange": {
                        "title": "Time Range",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "30days",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Preset time window for the search. Choose 'Custom range' to set exact Start/End times below.",
                        "default": "week"
                    },
                    "startTime": {
                        "title": "Start Time (custom range)",
                        "type": "string",
                        "description": "Start of time range in ISO 8601 format (e.g. 2026-06-01 or 2026-06-01T00:00:00). Only used when Time Range is 'Custom range'."
                    },
                    "endTime": {
                        "title": "End Time (custom range)",
                        "type": "string",
                        "description": "End of time range in ISO 8601 format (e.g. 2026-07-01). Defaults to now if omitted. Only used when Time Range is 'Custom range'."
                    },
                    "minMagnitude": {
                        "title": "Minimum Magnitude",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "number",
                        "description": "Minimum earthquake magnitude (Richter scale). Leave empty to include all magnitudes. Use 4.0+ for significant quakes only."
                    },
                    "maxMagnitude": {
                        "title": "Maximum Magnitude",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "number",
                        "description": "Maximum earthquake magnitude filter (optional). Leave empty for no upper limit."
                    },
                    "alertLevel": {
                        "title": "Alert Level (PAGER)",
                        "enum": [
                            "",
                            "green",
                            "yellow",
                            "orange",
                            "red"
                        ],
                        "type": "string",
                        "description": "Filter by USGS PAGER alert level. Leave empty for all.",
                        "default": ""
                    },
                    "sortOrder": {
                        "title": "Sort Order",
                        "enum": [
                            "time",
                            "time-asc",
                            "magnitude",
                            "magnitude-asc"
                        ],
                        "type": "string",
                        "description": "How to order the returned events.",
                        "default": "time"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum number of earthquakes to return. Default 1000. USGS API hard cap is 20000 per request; use larger time ranges for more data.",
                        "default": 1000
                    },
                    "minLatitude": {
                        "title": "Min Latitude (bbox)",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "Bounding box south latitude (-90 to 90). Use with the other bbox fields to filter by region."
                    },
                    "maxLatitude": {
                        "title": "Max Latitude (bbox)",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "Bounding box north latitude (-90 to 90)."
                    },
                    "minLongitude": {
                        "title": "Min Longitude (bbox)",
                        "minimum": -180,
                        "maximum": 180,
                        "type": "number",
                        "description": "Bounding box west longitude (-180 to 180)."
                    },
                    "maxLongitude": {
                        "title": "Max Longitude (bbox)",
                        "minimum": -180,
                        "maximum": 180,
                        "type": "number",
                        "description": "Bounding box east longitude (-180 to 180)."
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Automatic (any group) is recommended for this public government API.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
