# USGS Earthquake Data Scraper (`compute-edge/usgs-earthquake-scraper`) Actor

Extract earthquake event data from the USGS Earthquake Hazards Program API. Filter by date range, magnitude, geographic radius, and alert level. Returns structured data including magnitude, location, depth, tsunami warnings, significance scores, and community intensity reports.

- **URL**: https://apify.com/compute-edge/usgs-earthquake-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Data Scraper

Extract structured earthquake event data from the **USGS Earthquake Hazards Program**, the authoritative source for seismic activity worldwide. This Actor wraps the official USGS FDSN Event Web Service API to deliver clean, structured records of **earthquake events** including magnitude, precise geographic coordinates, depth, tsunami warnings, PAGER alert levels, community intensity reports, and significance scores.

The USGS Earthquake Hazards Program records and catalogs **thousands of seismic events daily** across the globe. This scraper transforms raw GeoJSON data from the USGS API into flat, analysis-ready records that can be exported to JSON, CSV, Excel, or fed directly into data pipelines and dashboards. Whether you are building a **real-time earthquake monitoring dashboard**, conducting **seismic risk analysis** for insurance or real estate, or feeding data into an **LLM-powered research agent**, this Actor provides the structured foundation you need.

### Key Features

- **Date range filtering** — Query any historical period from the USGS catalog (data available from 1900s to present)
- **Magnitude filtering** — Set minimum and/or maximum magnitude thresholds to focus on significant events
- **Geographic radius search** — Search within a specific radius (in km) around any latitude/longitude point
- **PAGER alert level filtering** — Filter by USGS PAGER alert level (green, yellow, orange, red) to find high-impact events
- **Comprehensive data fields** — 25+ fields per event including magnitude, location, depth, tsunami flag, community intensity, and more
- **Automatic pagination** — Handles the 20,000-record API limit transparently
- **Rate limit handling** — Built-in retry logic with exponential backoff
- **Clean output** — Epoch timestamps converted to ISO 8601, coordinates extracted from nested GeoJSON, flat record structure

### Output Data Fields

| Field | Type | Description |
|-------|------|-------------|
| eventId | string | Unique USGS event identifier |
| title | string | Human-readable event title (e.g., "M 5.2 - 10km NE of San Jose, CA") |
| magnitude | number | Event magnitude |
| magnitudeType | string | Magnitude calculation method (ml, mb, mw, etc.) |
| place | string | Descriptive location string |
| longitude | number | Event longitude (degrees) |
| latitude | number | Event latitude (degrees) |
| depth | number | Event depth in kilometers |
| time | string | Event time in ISO 8601 UTC format |
| updated | string | Last update time in ISO 8601 UTC format |
| timezoneOffset | number | Timezone offset in minutes from UTC |
| feltReports | number | Number of "Did You Feel It?" reports submitted |
| communityIntensity | number | Maximum reported Community Decimal Intensity (CDI) |
| instrumentalIntensity | number | Maximum estimated Modified Mercalli Intensity (MMI) |
| alertLevel | string | PAGER alert level: green, yellow, orange, or red |
| tsunami | boolean | Whether a tsunami warning was issued |
| significance | number | Significance score (0-1000), combining magnitude, felt reports, and impact |
| eventType | string | Event type (earthquake, quarry blast, explosion, etc.) |
| status | string | Review status (automatic or reviewed) |
| network | string | Contributing seismic network code |
| eventCode | string | Event code within the network |
| stationCount | number | Number of seismic stations that reported the event |
| minStationDistance | number | Minimum distance (degrees) to the nearest station |
| rmsResidual | number | Root-mean-square travel time residual (seconds) |
| azimuthalGap | number | Largest azimuthal gap between stations (degrees) |
| usgsUrl | string | Link to the USGS event detail page |
| detailApiUrl | string | USGS detail API endpoint for this event |

### How to Scrape USGS Earthquake Data

1. **Navigate to the Actor** in the Apify Store or Apify Console
2. **Set the start date** — Enter the beginning of your date range in YYYY-MM-DD format (e.g., `2024-01-01`)
3. **Set the end date** — Enter the end of your date range (e.g., `2024-12-31`)
4. **Set magnitude filters** (optional) — Enter a minimum magnitude like `4.0` to filter out minor tremors, or set both min and max for a specific range
5. **Set geographic filter** (optional) — Enter a center latitude, longitude, and search radius in km to focus on a specific region
6. **Set alert level** (optional) — Choose a PAGER alert level to find only high-impact events
7. **Set max results** — Control the output size (default: 100, max: 20,000)
8. **Click Start** and wait for the run to complete
9. **Download results** in JSON, CSV, Excel, or access via the Apify API

#### Example: Find All M5+ Earthquakes in Q1 2024

```json
{
    "startDate": "2024-01-01",
    "endDate": "2024-03-31",
    "minMagnitude": 5.0,
    "maxResults": 1000
}
````

#### Example: Earthquakes Near Los Angeles (100km radius)

```json
{
    "startDate": "2024-01-01",
    "endDate": "2024-12-31",
    "minMagnitude": 3.0,
    "latitude": 34.0522,
    "longitude": -118.2437,
    "maxRadiusKm": 100,
    "maxResults": 500
}
```

#### Example: Red/Orange Alert Events Only

```json
{
    "startDate": "2020-01-01",
    "endDate": "2024-12-31",
    "alertLevel": "red",
    "maxResults": 100
}
```

### Sample Output

```json
{
    "eventId": "us7000m5n1",
    "title": "M 7.0 - 18 km W of Hachinohe, Japan",
    "magnitude": 7.0,
    "magnitudeType": "mww",
    "place": "18 km W of Hachinohe, Japan",
    "longitude": 141.268,
    "latitude": 40.521,
    "depth": 35.0,
    "time": "2024-01-01T07:10:09.000Z",
    "updated": "2024-01-15T12:30:00.000Z",
    "timezoneOffset": 540,
    "feltReports": 342,
    "communityIntensity": 6.2,
    "instrumentalIntensity": 6.8,
    "alertLevel": "yellow",
    "tsunami": true,
    "significance": 800,
    "eventType": "earthquake",
    "status": "reviewed",
    "network": "us",
    "eventCode": "7000m5n1",
    "stationCount": 182,
    "minStationDistance": 0.5,
    "rmsResidual": 0.89,
    "azimuthalGap": 22,
    "usgsUrl": "https://earthquake.usgs.gov/earthquakes/eventpage/us7000m5n1",
    "detailApiUrl": "https://earthquake.usgs.gov/fdsnws/event/1/query?eventid=us7000m5n1&format=geojson"
}
```

### Pricing

This Actor uses the USGS public API which is free and requires no authentication. Your costs are:

- **Actor start**: $0.00005 per run
- **Per result**: $0.002 per earthquake event record
- **Apify platform compute**: Billed separately based on usage

A typical run fetching 100 M5+ earthquakes costs approximately $0.20 in result fees plus minimal platform compute.

### Use Cases

- **Seismic risk assessment** — Analyze earthquake frequency and magnitude near properties, infrastructure, or planned construction sites
- **Insurance underwriting** — Feed historical earthquake data into risk models for property and casualty insurance
- **Academic research** — Study seismic patterns, tectonic plate activity, and earthquake clustering
- **Emergency management** — Monitor high-significance events and tsunami warnings for disaster preparedness
- **Real estate analysis** — Assess seismic risk for investment properties or development sites
- **Data journalism** — Build interactive earthquake maps and trend analysis for news stories
- **LLM/RAG pipelines** — Provide structured earthquake data to AI agents for natural language analysis

### Integrations

Connect USGS Earthquake Data Scraper with your existing tools:

- **Google Sheets** — Auto-export earthquake data to spreadsheets for analysis
- **Slack/Email** — Set up alerts when high-magnitude events are detected
- **Webhooks** — Trigger downstream processing when new data is available
- **API** — Access results programmatically via the Apify API

### FAQ

#### Is it legal to scrape USGS earthquake data?

Yes. This Actor uses the official USGS FDSN Event Web Service REST API, a public data service provided by the US government. The data is in the public domain and freely available for any use. No authentication is required.

#### How Much Does It Cost to Scrape USGS Earthquake Data?

See the pricing table above. At $0.002 per result, fetching 100 M5+ earthquakes costs approximately $0.20 in Actor fees plus minimal Apify compute costs.

#### Can I export USGS earthquake data to Excel or CSV?

Yes. Apify supports exporting results in JSON, CSV, Excel, XML, and other formats directly from the Dataset tab after a run completes.

#### How often is the USGS earthquake data updated?

The USGS records and catalogs seismic events in near real-time. New earthquakes typically appear in the API within minutes of occurrence. You can schedule this Actor to run at any interval.

#### What does the significance score mean?

Significance is a 0-1000 score combining magnitude, felt reports, and estimated impact. Higher values indicate more notable events. A score above 600 generally indicates a widely-felt, potentially damaging earthquake.

### Other Scrapers by SeatSignal

- [FEMA Disasters Scraper](https://apify.com/seatsignal/fema-disasters-scraper) — Extract federal disaster declaration data
- [USBR Water Data Scraper](https://apify.com/seatsignal/usbr-water-data-scraper) — Extract reservoir levels and dam operations data
- [EPA Drinking Water Scraper](https://apify.com/seatsignal/epa-drinking-water-scraper) — Extract drinking water system data
- [NRC Reactor Status Scraper](https://apify.com/seatsignal/nrc-reactor-status-scraper) — Extract nuclear reactor status data
- [EIA Energy Data Scraper](https://apify.com/seatsignal/eia-energy-scraper) — Extract petroleum, natural gas, and electricity data

### Legal Disclaimer

This Actor accesses publicly available data from the USGS Earthquake Hazards Program via their official public API. The USGS data is produced by a US government agency and is in the public domain. This Actor does not bypass any authentication, access controls, or terms of service. Users are responsible for ensuring their use of the data complies with applicable laws and regulations. For questions about USGS data usage, see the [USGS Data Policy](https://www.usgs.gov/information-policies-and-instructions/copyrights-and-credits).

For support, bug reports, or feature requests, please open an issue on the Actor's page in the Apify Store.

# Actor input Schema

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

Start date in YYYY-MM-DD format (e.g. '2024-01-01'). Required.

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

End date in YYYY-MM-DD format (e.g. '2024-12-31'). Required.

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

Minimum earthquake magnitude to include (e.g. 4.0 for significant quakes, 5.0 for strong quakes).

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

Maximum earthquake magnitude to include.

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

Center latitude for geographic radius search (e.g. 37.7749 for San Francisco). Requires longitude and maxRadiusKm.

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

Center longitude for geographic radius search (e.g. -122.4194 for San Francisco). Requires latitude and maxRadiusKm.

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

Search radius in kilometers around the center point. Requires latitude and longitude. Max 20001.6 km.

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

Filter by PAGER alert level. Green = low impact, Yellow = moderate, Orange = significant, Red = severe.

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

Maximum number of earthquake events to return.

## Actor input object example

```json
{
  "startDate": "2024-01-01",
  "endDate": "2024-12-31",
  "maxRadiusKm": 500,
  "alertLevel": "",
  "maxResults": 100
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startDate": "2024-01-01",
    "endDate": "2024-12-31"
};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/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 = {
    "startDate": "2024-01-01",
    "endDate": "2024-12-31",
}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/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 '{
  "startDate": "2024-01-01",
  "endDate": "2024-12-31"
}' |
apify call compute-edge/usgs-earthquake-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USGS Earthquake Data Scraper",
        "description": "Extract earthquake event data from the USGS Earthquake Hazards Program API. Filter by date range, magnitude, geographic radius, and alert level. Returns structured data including magnitude, location, depth, tsunami warnings, significance scores, and community intensity reports.",
        "version": "0.1",
        "x-build-id": "OoFOp8foxLb5iWZGy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~usgs-earthquake-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-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/compute-edge~usgs-earthquake-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-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/compute-edge~usgs-earthquake-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-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",
                "required": [
                    "startDate",
                    "endDate"
                ],
                "properties": {
                    "startDate": {
                        "title": "Start Date",
                        "type": "string",
                        "description": "Start date in YYYY-MM-DD format (e.g. '2024-01-01'). Required."
                    },
                    "endDate": {
                        "title": "End Date",
                        "type": "string",
                        "description": "End date in YYYY-MM-DD format (e.g. '2024-12-31'). Required."
                    },
                    "minMagnitude": {
                        "title": "Minimum Magnitude",
                        "type": "number",
                        "description": "Minimum earthquake magnitude to include (e.g. 4.0 for significant quakes, 5.0 for strong quakes)."
                    },
                    "maxMagnitude": {
                        "title": "Maximum Magnitude",
                        "type": "number",
                        "description": "Maximum earthquake magnitude to include."
                    },
                    "latitude": {
                        "title": "Center Latitude",
                        "type": "number",
                        "description": "Center latitude for geographic radius search (e.g. 37.7749 for San Francisco). Requires longitude and maxRadiusKm."
                    },
                    "longitude": {
                        "title": "Center Longitude",
                        "type": "number",
                        "description": "Center longitude for geographic radius search (e.g. -122.4194 for San Francisco). Requires latitude and maxRadiusKm."
                    },
                    "maxRadiusKm": {
                        "title": "Max Radius (km)",
                        "type": "number",
                        "description": "Search radius in kilometers around the center point. Requires latitude and longitude. Max 20001.6 km.",
                        "default": 500
                    },
                    "alertLevel": {
                        "title": "Alert Level",
                        "enum": [
                            "",
                            "green",
                            "yellow",
                            "orange",
                            "red"
                        ],
                        "type": "string",
                        "description": "Filter by PAGER alert level. Green = low impact, Yellow = moderate, Orange = significant, Red = severe.",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum number of earthquake events to return.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
