# USGS Earthquake Scraper (`solidcode/earthquake-usgs-gov-scraper`) Actor

\[💰 $0.9 / 1K] Search the official USGS global earthquake catalog and export clean records — magnitude, location, depth, time, alert level, tsunami and felt reports. Filter by magnitude, date range, region, and depth.

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

## Pricing

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

Pull earthquake records straight from the official USGS global catalog — magnitude, epicenter, depth, origin time, PAGER impact alerts, tsunami flags, and community "Did You Feel It?" counts, exported as one clean row per event. Search by magnitude, date, a circle around any city, a region box, depth band, alert level, or event type, with global coverage back to the early 1900s and near-real-time updates. Built for seismologists, insurers, news teams, and GIS analysts who need authoritative, structured quake data without wrestling with a raw scientific API.

### Why This Scraper?

- **The official USGS catalog — the authoritative global source** — every record comes from the United States Geological Survey's own earthquake catalog, the same dataset cited by researchers, governments, and news desks worldwide
- **Four geographic search modes** — search worldwide, within a circle around any point (lat/lon + radius in km), inside a rectangular region box (four edges), or anywhere and filter afterward
- **PAGER impact alerts (green / yellow / orange / red)** — filter to only the events USGS flagged as having limited, some, significant, or severe human impact
- **40+ event types** — keep only true earthquakes, or include quarry blasts, explosions, ice quakes, mining explosions, and landslides that share the catalog
- **Impact metrics on every event** — felt-report counts (DYFI), CDI and MMI shaking intensities, a tsunami flag, and the USGS significance score, all in one row
- **Coverage from the early 1900s to minutes ago** — run historical sweeps across decades or pull the latest events from the past 30 days
- **Sort by newest, oldest, strongest, or weakest** — order results by time or magnitude in either direction, so the events that matter to you land at the top
- **20 typed fields, ISO-8601 UTC timestamps** — clean magnitude types, decimal-degree coordinates, depth in kilometers, and a direct link to each USGS event page — no epoch integers, no nested blobs
- **Public-domain US government data** — USGS earthquake data carries no usage fee or license restriction, so you own what you extract

### Use Cases

**Research & Science**
- Build seismicity datasets for a fault zone, subduction margin, or tectonic plate boundary
- Study aftershock sequences by pulling every event within a circle around a mainshock
- Analyze depth distributions across a region with the depth-band filter

**Insurance & Risk Modeling**
- Quantify earthquake exposure for a portfolio by region box and magnitude floor
- Feed historical catalogs into catastrophe and probabilistic seismic hazard models
- Track significant-and-larger events near insured assets in near-real-time

**News & Media**
- Monitor for orange and red PAGER alerts to break high-impact quake stories first
- Pull the strongest events of the past day, week, or year ranked by magnitude
- Enrich coverage with felt-report counts and shaking intensity per event

**Disaster Response & Public Safety**
- Surface events with high felt-report counts to gauge where people are affected
- Filter to tsunami-flagged events along coastlines for early situational awareness
- Build alerting workflows around a city using circle search plus an alert-level floor

**GIS & Mapping Applications**
- Power interactive quake maps with decimal-degree epicenter coordinates and depth
- Generate region-specific layers using bounding-box search for any country or state
- Keep a rolling map layer fresh by pulling recent events on a schedule

### Getting Started

#### Recent Significant Quakes

The minimum useful input — a magnitude floor and a start date:

```json
{
    "minMagnitude": 4.5,
    "startTime": "2024-01-01"
}
````

#### Earthquakes Near a City

Find every event within 300 km of San Francisco in 2024:

```json
{
    "latitude": 37.77,
    "longitude": -122.42,
    "maxRadiusKm": 300,
    "minMagnitude": 2.5,
    "startTime": "2024-01-01",
    "endTime": "2024-12-31"
}
```

#### Region Box + Alert Level, Strongest First

Pull high-impact quakes inside a rectangle over Japan, ranked by magnitude:

```json
{
    "minLatitude": 30,
    "maxLatitude": 45,
    "minLongitude": 130,
    "maxLongitude": 145,
    "minMagnitude": 5,
    "alertLevel": "yellow",
    "eventType": "earthquake",
    "orderBy": "magnitude",
    "maxResults": 500
}
```

### Input Reference

#### Time Range

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startTime` | string | `"2024-01-01"` | Only include earthquakes on or after this date (`YYYY-MM-DD` or full date-and-time). Leave empty for the last 30 days. |
| `endTime` | string | — | Only include earthquakes on or before this date. Leave empty to include everything up to now. |

#### Magnitude & Depth

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `minMagnitude` | number | `4.5` | Only include earthquakes at or above this magnitude (0–10). A higher floor returns fewer, larger events. |
| `maxMagnitude` | number | — | Only include earthquakes at or below this magnitude (0–10). |
| `minDepth` | number | — | Only return earthquakes at least this deep, in kilometers (events deeper than this value). Depth increases downward, so a higher number keeps only the deeper quakes. Leave empty for no minimum. |
| `maxDepth` | number | — | Only return earthquakes no deeper than this, in kilometers (events shallower than this value). Depth increases downward, so a lower number keeps only the shallower quakes. Leave empty for no maximum. |

#### Location

Use the circle fields together, or the box fields together — leave both groups empty to search worldwide.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `latitude` | number | — | Center latitude of a circle search (−90 to 90). |
| `longitude` | number | — | Center longitude of a circle search (−180 to 180). |
| `maxRadiusKm` | number | — | How far from the center point to search, in kilometers. |
| `minLatitude` | number | — | South edge (min latitude) of a rectangular region. |
| `maxLatitude` | number | — | North edge (max latitude) of a rectangular region. |
| `minLongitude` | number | — | West edge (min longitude) of a rectangular region. |
| `maxLongitude` | number | — | East edge (max longitude) of a rectangular region. |

#### Classification & Sorting

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `alertLevel` | select | `"Any (no filter)"` | Minimum PAGER impact alert: Any, Green or higher (limited impact), Yellow or higher (some impact), Orange or higher (significant impact), Red only (severe impact). |
| `eventType` | select | `"Earthquake"` | Kind of event: Any, Earthquake, Quarry blast, Explosion, Ice quake, Mining explosion. Defaults to Earthquake to exclude non-quake events. |
| `minFeltReports` | integer | — | Only include earthquakes that at least this many people reported feeling ("Did You Feel It?"). |
| `orderBy` | select | `"Newest first (by time)"` | Result order: Newest first, Oldest first, Strongest first (by magnitude), Weakest first (by magnitude). |

#### Output Size

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `1000` | The most earthquakes to return for this run (1 to 20,000). Narrow your search with the filters above when looking at long time ranges. |

### Output

Each record is one earthquake with 20 structured fields:

```json
{
    "eventId": "us6000m0xz",
    "magnitude": 7.2,
    "magnitudeType": "mww",
    "place": "12 km SW of Acari, Peru",
    "time": "2024-06-28T05:36:36.902Z",
    "updated": "2025-02-09T14:16:45.954Z",
    "latitude": -15.65,
    "longitude": -74.69,
    "depth": 27.5,
    "tsunami": true,
    "felt": 115,
    "cdi": 8.3,
    "mmi": 7.689,
    "alert": "yellow",
    "significance": 893,
    "status": "reviewed",
    "eventType": "earthquake",
    "title": "M 7.2 - 12 km SW of Acari, Peru",
    "url": "https://earthquake.usgs.gov/earthquakes/eventpage/us6000m0xz",
    "extractedAt": "2026-06-19T20:47:14Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `eventId` | string | Unique USGS event identifier. |
| `magnitude` | number | Magnitude value of the event. |
| `magnitudeType` | string | How magnitude was measured (e.g. `mww`, `mb`, `ml`, `md`). |
| `place` | string | Human-readable location description. |
| `time` | string | Event origin time, ISO-8601 (UTC). |
| `updated` | string | When the record was last revised by USGS, ISO-8601 (UTC). |
| `eventType` | string | Event classification (earthquake, quarry blast, explosion, …). |
| `status` | string | Review status — `reviewed` (analyst-confirmed) or `automatic`. |

#### Location

| Field | Type | Description |
|-------|------|-------------|
| `latitude` | number | Epicenter latitude in decimal degrees. |
| `longitude` | number | Epicenter longitude in decimal degrees. |
| `depth` | number | Hypocenter depth below the surface, in kilometers. |

#### Impact

| Field | Type | Description |
|-------|------|-------------|
| `tsunami` | boolean | Whether the event carried a tsunami indicator. |
| `felt` | number | null | Number of "Did You Feel It?" community reports. |
| `cdi` | number | null | Community Decimal Intensity (reported shaking). |
| `mmi` | number | null | Modified Mercalli Intensity (estimated shaking). |
| `alert` | string | null | PAGER impact alert: green, yellow, orange, or red. |
| `significance` | number | USGS significance score combining magnitude, felt, and impact. |
| `title` | string | Full event title (e.g. `M 7.2 - 12 km SW of Acari, Peru`). |
| `url` | string | Direct link to the USGS event page. |
| `extractedAt` | string | ISO-8601 timestamp of when this record was captured. |

### Tips for Best Results

- **Keep any single search under 20,000 events** — the catalog caps one search at 20,000 matches. Narrow by magnitude, date range, or region to stay under the cap and get complete results instead of a "narrow your search" notice.
- **Raise the magnitude floor for big historical sweeps** — decades of small quakes number in the millions. A `minMagnitude` of 5 or 6 keeps multi-year searches fast and well under the cap.
- **Use circle search for "within X km of a city"** — `latitude` + `longitude` + `maxRadiusKm` is more accurate than a box for distance-from-a-point questions like aftershock studies.
- **Use the region box for countries and states** — four edges (`minLatitude`/`maxLatitude`/`minLongitude`/`maxLongitude`) cleanly fence a rectangular area such as a country or state.
- **Filter by `eventType` to drop noise** — the catalog mixes in quarry blasts and explosions; the default `Earthquake` keeps only genuine quakes.
- **Set `minFeltReports` to find quakes people actually noticed** — a floor of 10 or more surfaces events with real community impact, ideal for news and response workflows.
- **Sort with `orderBy` to put the right events first** — `Strongest first (by magnitude)` for biggest-events lists, `Newest first` for live monitoring.

### Pricing

**From $0.90 per 1,000 results** — among the lowest rates for authoritative earthquake data, with no monthly rental. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.11 | $0.10 | $0.10 | $0.09 |
| 1,000 | $1.05 | $1.00 | $0.95 | $0.90 |
| 10,000 | $10.50 | $10.00 | $9.50 | $9.00 |
| 100,000 | $105.00 | $100.00 | $95.00 | $90.00 |

A "result" is one earthquake record returned in your dataset. **No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.** Platform fees depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs when a run completes
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects earthquake records from the official USGS Earthquake Hazards Program catalog, which is public-domain data produced by the United States Geological Survey and carries no usage fee or license restriction. You are responsible for using the data lawfully and for complying with applicable terms of service. When republishing, a credit to the USGS is appreciated and, for some uses, expected. Do not use the data for any unlawful or harmful purpose.

# Actor input Schema

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

Only include earthquakes that happened on or after this date. Use the format YYYY-MM-DD (for example 2024-01-01) or a full date-and-time like 2024-01-01T00:00:00. Leave empty to use the USGS default, which is the last 30 days.

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

Only include earthquakes that happened on or before this date. Use the format YYYY-MM-DD (for example 2024-12-31) or a full date-and-time. Leave empty to include everything up to now.

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

Only include earthquakes at or above this magnitude. For example, 4.5 returns moderate-and-larger quakes and skips the many tiny ones. Leave empty for no minimum.

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

Only include earthquakes at or below this magnitude. Leave empty for no maximum.

## `latitude` (type: `number`):

Latitude of the point to search around, between -90 and 90 (for example 37.77 for San Francisco). Use together with the longitude and radius below to find earthquakes near a specific place.

## `longitude` (type: `number`):

Longitude of the point to search around, between -180 and 180 (for example -122.42 for San Francisco).

## `maxRadiusKm` (type: `number`):

How far from the center point to search, in kilometers (for example 200). Only earthquakes inside this circle are returned.

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

Southern edge of a rectangular search area, between -90 and 90. Use the four box fields together to search a region such as a country or state. Leave empty if you are searching by circle or worldwide.

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

Northern edge of the rectangular search area, between -90 and 90.

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

Western edge of the rectangular search area, between -180 and 180.

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

Eastern edge of the rectangular search area, between -180 and 180.

## `minDepth` (type: `number`):

Only return earthquakes at least this deep, in kilometers (events deeper than this value). Depth increases downward, so a higher number keeps only the deeper quakes. Leave empty for no minimum.

## `maxDepth` (type: `number`):

Only return earthquakes no deeper than this, in kilometers (events shallower than this value). Depth increases downward, so a lower number keeps only the shallower quakes. Leave empty for no maximum.

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

Only include earthquakes with at least this USGS PAGER impact alert. Green is least severe and red is most severe; each level also includes everything more severe. Leave on 'Any' to include all earthquakes.

## `eventType` (type: `string`):

Only include events of this kind. The catalog also records quarry blasts, explosions, and other non-earthquake events; choose 'Earthquake' to exclude those, or 'Any' to keep everything.

## `minFeltReports` (type: `integer`):

Only include earthquakes that people actually reported feeling, at or above this number of community reports. For example, 10 returns events that at least 10 people felt. Leave empty for no minimum.

## `orderBy` (type: `string`):

How to order the earthquakes that are returned.

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

The most earthquakes to return for this run (1 to 20,000). A limit keeps runs fast and predictable. The USGS catalog can hold millions of events, so always narrow your search with the filters above when looking at long time ranges.

## Actor input object example

```json
{
  "startTime": "2024-01-01",
  "minMagnitude": 4.5,
  "alertLevel": "",
  "eventType": "earthquake",
  "orderBy": "time",
  "maxResults": 1000
}
```

# Actor output Schema

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

Table of earthquakes with magnitude, place, time, depth, alert level, and a link to the USGS event page.

# 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 = {
    "startTime": "2024-01-01",
    "endTime": "",
    "minMagnitude": 4.5,
    "alertLevel": "",
    "eventType": "earthquake",
    "orderBy": "time",
    "maxResults": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/earthquake-usgs-gov-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 = {
    "startTime": "2024-01-01",
    "endTime": "",
    "minMagnitude": 4.5,
    "alertLevel": "",
    "eventType": "earthquake",
    "orderBy": "time",
    "maxResults": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/earthquake-usgs-gov-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 '{
  "startTime": "2024-01-01",
  "endTime": "",
  "minMagnitude": 4.5,
  "alertLevel": "",
  "eventType": "earthquake",
  "orderBy": "time",
  "maxResults": 1000
}' |
apify call solidcode/earthquake-usgs-gov-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USGS Earthquake Scraper",
        "description": "[💰 $0.9 / 1K] Search the official USGS global earthquake catalog and export clean records — magnitude, location, depth, time, alert level, tsunami and felt reports. Filter by magnitude, date range, region, and depth.",
        "version": "1.0",
        "x-build-id": "Fyq0BNdk0NszK9Fia"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~earthquake-usgs-gov-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-earthquake-usgs-gov-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/solidcode~earthquake-usgs-gov-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-earthquake-usgs-gov-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/solidcode~earthquake-usgs-gov-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-earthquake-usgs-gov-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": {
                    "startTime": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Only include earthquakes that happened on or after this date. Use the format YYYY-MM-DD (for example 2024-01-01) or a full date-and-time like 2024-01-01T00:00:00. Leave empty to use the USGS default, which is the last 30 days."
                    },
                    "endTime": {
                        "title": "End date",
                        "type": "string",
                        "description": "Only include earthquakes that happened on or before this date. Use the format YYYY-MM-DD (for example 2024-12-31) or a full date-and-time. Leave empty to include everything up to now."
                    },
                    "minMagnitude": {
                        "title": "Minimum magnitude",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "number",
                        "description": "Only include earthquakes at or above this magnitude. For example, 4.5 returns moderate-and-larger quakes and skips the many tiny ones. Leave empty for no minimum."
                    },
                    "maxMagnitude": {
                        "title": "Maximum magnitude",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "number",
                        "description": "Only include earthquakes at or below this magnitude. Leave empty for no maximum."
                    },
                    "latitude": {
                        "title": "Center latitude",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "Latitude of the point to search around, between -90 and 90 (for example 37.77 for San Francisco). Use together with the longitude and radius below to find earthquakes near a specific place."
                    },
                    "longitude": {
                        "title": "Center longitude",
                        "minimum": -180,
                        "maximum": 180,
                        "type": "number",
                        "description": "Longitude of the point to search around, between -180 and 180 (for example -122.42 for San Francisco)."
                    },
                    "maxRadiusKm": {
                        "title": "Radius (km)",
                        "minimum": 0,
                        "maximum": 20001,
                        "type": "number",
                        "description": "How far from the center point to search, in kilometers (for example 200). Only earthquakes inside this circle are returned."
                    },
                    "minLatitude": {
                        "title": "South edge (min latitude)",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "Southern edge of a rectangular search area, between -90 and 90. Use the four box fields together to search a region such as a country or state. Leave empty if you are searching by circle or worldwide."
                    },
                    "maxLatitude": {
                        "title": "North edge (max latitude)",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "Northern edge of the rectangular search area, between -90 and 90."
                    },
                    "minLongitude": {
                        "title": "West edge (min longitude)",
                        "minimum": -360,
                        "maximum": 360,
                        "type": "number",
                        "description": "Western edge of the rectangular search area, between -180 and 180."
                    },
                    "maxLongitude": {
                        "title": "East edge (max longitude)",
                        "minimum": -360,
                        "maximum": 360,
                        "type": "number",
                        "description": "Eastern edge of the rectangular search area, between -180 and 180."
                    },
                    "minDepth": {
                        "title": "Minimum depth (km)",
                        "minimum": -100,
                        "maximum": 1000,
                        "type": "number",
                        "description": "Only return earthquakes at least this deep, in kilometers (events deeper than this value). Depth increases downward, so a higher number keeps only the deeper quakes. Leave empty for no minimum."
                    },
                    "maxDepth": {
                        "title": "Maximum depth (km)",
                        "minimum": -100,
                        "maximum": 1000,
                        "type": "number",
                        "description": "Only return earthquakes no deeper than this, in kilometers (events shallower than this value). Depth increases downward, so a lower number keeps only the shallower quakes. Leave empty for no maximum."
                    },
                    "alertLevel": {
                        "title": "PAGER alert level",
                        "enum": [
                            "",
                            "green",
                            "yellow",
                            "orange",
                            "red"
                        ],
                        "type": "string",
                        "description": "Only include earthquakes with at least this USGS PAGER impact alert. Green is least severe and red is most severe; each level also includes everything more severe. Leave on 'Any' to include all earthquakes.",
                        "default": ""
                    },
                    "eventType": {
                        "title": "Event type",
                        "enum": [
                            "",
                            "earthquake",
                            "quarry blast",
                            "explosion",
                            "ice quake",
                            "mining explosion"
                        ],
                        "type": "string",
                        "description": "Only include events of this kind. The catalog also records quarry blasts, explosions, and other non-earthquake events; choose 'Earthquake' to exclude those, or 'Any' to keep everything.",
                        "default": "earthquake"
                    },
                    "minFeltReports": {
                        "title": "Minimum 'Did You Feel It?' reports",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include earthquakes that people actually reported feeling, at or above this number of community reports. For example, 10 returns events that at least 10 people felt. Leave empty for no minimum."
                    },
                    "orderBy": {
                        "title": "Sort results by",
                        "enum": [
                            "time",
                            "time-asc",
                            "magnitude",
                            "magnitude-asc"
                        ],
                        "type": "string",
                        "description": "How to order the earthquakes that are returned.",
                        "default": "time"
                    },
                    "maxResults": {
                        "title": "Maximum earthquakes",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "The most earthquakes to return for this run (1 to 20,000). A limit keeps runs fast and predictable. The USGS catalog can hold millions of events, so always narrow your search with the filters above when looking at long time ranges.",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
