# NASA JPL Fireball Events Scraper (`parseforge/jpl-fireball-events-scraper`) Actor

Pull atmospheric fireball and bolide events from the NASA JPL CNEOS catalog. Returns peak brightness time, radiated energy, impact energy in kilotons, latitude, longitude, altitude, and pre entry velocity. Useful for planetary defense work, meteor research, and mapping bright events.

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

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

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

## ☄️ NASA JPL Fireball Events Scraper

> 🚀 **Export atmospheric fireball and bolide events in seconds.** Pull every recorded fireball straight from NASA's Center for Near Earth Object Studies, with energy, location, altitude, and velocity for each event.

> 🕒 **Last updated:** 2026-06-05 · **📊 Up to 14 fields** per record · **1,000+ recorded events** · global atmospheric coverage

Track bright meteors and bolides detected by US Government sensors using the same public catalog NASA/JPL publishes for researchers. This Actor reads the keyless CNEOS Fireball API and returns clean, per event records with the newest events first.

Coverage spans more than a thousand fireball events going back over three decades. Each event carries its UTC peak brightness time, total radiated energy, estimated total impact energy in kilotons, latitude and longitude, peak brightness altitude, and where reported the pre entry velocity together with its three velocity components.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Astronomers and meteor researchers | Map bolide events and study energy distribution |
| Planetary defense and NEO analysts | Track impact energy and atmospheric entries |
| Data scientists and educators | Build fireball time series and teaching datasets |
| Science journalists and hobbyists | Find recent bright meteors over a region |

### 📋 What the NASA JPL Fireball Events Scraper does

This Actor connects to the NASA/JPL CNEOS Fireball API and returns one structured record per fireball event. Latitude and longitude arrive from the source as a magnitude plus a direction, so the Actor converts them into signed decimal coordinates ready to plot, while keeping the original direction letters for reference.

- **Event timing** the UTC date and time of peak brightness.
- **Energy** total radiated energy in joules times 10^10 and estimated total impact energy in kilotons of TNT.
- **Location** signed latitude and longitude of peak brightness, plus the original N/S and E/W directions.
- **Altitude** the height above the reference geoid at peak brightness in kilometers.
- **Velocity** the pre entry speed in kilometers per second and its x, y, and z components when reported.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

Optionally cap how many events you want, then narrow the catalog by date, minimum energy, or whether a location was reported. The newest events are returned first.

| Field | Type | Description |
|---|---|---|
| `maxItems` | integer | Maximum number of events to return. Free plan is limited to 10. |
| `dateMin` | string | Only events on or after this UTC date or date time. Accepts `YYYY-MM-DD`. |
| `dateMax` | string | Only events on or before this UTC date or date time. Accepts `YYYY-MM-DD`. |
| `energyMin` | number | Only events whose total radiated energy in joules times 10^10 is at least this value. |
| `requireLocation` | boolean | When enabled, only events that have a reported latitude and longitude are returned. |

Example, the latest fireball events:

```json
{
  "maxItems": 10
}
````

Example, energetic events with a known location since 2020:

```json
{
  "maxItems": 100,
  "dateMin": "2020-01-01",
  "energyMin": 5,
  "requireLocation": true
}
```

> ⚠️ **Good to Know:** Velocity and its three components are only available for events where the reporting sensor measured them. For many older or partially reported events the velocity fields are null, while energy, time, and location are still present. This reflects the source catalog and is not a gap in collection.

### 📊 Output

Each record below is from a real run of this Actor.

| Field | Description |
|---|---|
| 🕒 `date` | UTC date and time of peak brightness |
| ✨ `energy` | Total radiated energy in joules times 10^10 |
| 💥 `impactEnergy` | Estimated total impact energy in kilotons of TNT |
| 🌐 `latitude` | Signed latitude of peak brightness |
| 🌐 `longitude` | Signed longitude of peak brightness |
| 🧭 `latitudeDirection` | Original latitude direction, N or S |
| 🧭 `longitudeDirection` | Original longitude direction, E or W |
| 📏 `altitude` | Altitude of peak brightness in kilometers |
| 🚀 `velocity` | Pre entry velocity in kilometers per second |
| ➡️ `velocityX` | Velocity x component in kilometers per second |
| ⬆️ `velocityY` | Velocity y component in kilometers per second |
| 🔼 `velocityZ` | Velocity z component in kilometers per second |
| 🔗 `sourceUrl` | The NASA/JPL Fireball API endpoint |
| 🕒 `scrapedAt` | When this record was collected |
| ❌ `error` | Error message, null on success |

Real sample records:

```json
{
  "date": "2026-05-30 18:06:23",
  "energy": 42.1,
  "impactEnergy": 1.1,
  "latitude": 42,
  "longitude": -70.5,
  "latitudeDirection": "N",
  "longitudeDirection": "W",
  "altitude": 32,
  "velocity": null,
  "velocityX": null,
  "velocityY": null,
  "velocityZ": null,
  "sourceUrl": "https://ssd-api.jpl.nasa.gov/fireball.api",
  "scrapedAt": "2026-06-05T15:56:12.041Z",
  "error": null
}
```

```json
{
  "date": "2026-05-21 02:15:51",
  "energy": 3.5,
  "impactEnergy": 0.12,
  "latitude": 46.6,
  "longitude": 133.1,
  "latitudeDirection": "N",
  "longitudeDirection": "E",
  "altitude": 31.5,
  "velocity": 15.8,
  "velocityX": 14.4,
  "velocityY": -6.5,
  "velocityZ": 1,
  "sourceUrl": "https://ssd-api.jpl.nasa.gov/fireball.api",
  "scrapedAt": "2026-06-05T15:56:12.113Z",
  "error": null
}
```

```json
{
  "date": "2026-05-10 16:57:37",
  "energy": 6,
  "impactEnergy": 0.19,
  "latitude": -45.6,
  "longitude": -109.8,
  "latitudeDirection": "S",
  "longitudeDirection": "W",
  "altitude": 32.7,
  "velocity": 22.9,
  "velocityX": -13,
  "velocityY": 18.7,
  "velocityZ": 2.1,
  "sourceUrl": "https://ssd-api.jpl.nasa.gov/fireball.api",
  "scrapedAt": "2026-06-05T15:56:12.154Z",
  "error": null
}
```

### ✨ Why choose this Actor

- **Official source.** Data comes straight from the NASA/JPL CNEOS Fireball API, the same catalog used by planetary defense researchers.
- **Plot ready coordinates.** Latitude and longitude are converted into signed decimals while the original direction letters stay available.
- **Honest fields.** Velocity is reported only when the source measured it, and the Actor never pads missing values with fake numbers.
- **Useful filters.** Narrow by date window, minimum radiated energy, or whether a location was reported.
- **No keys required.** The source is keyless, so you can run it right away.

### 📈 How it compares to alternatives

| Approach | Coverage | Signed coordinates | Velocity components | Filters |
|---|---|---|---|---|
| This Actor | Full CNEOS catalog | Yes | Yes when reported | Date, energy, location |
| Manual API calls | Full catalog | No, magnitude plus direction | Only with extra parameter | Manual |
| Static dataset dumps | Often stale | Varies | Varies | None |

### 🚀 How to use

1. Sign up for a free Apify account using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the NASA JPL Fireball Events Scraper.
3. Optionally set a date window, a minimum energy, or require a known location.
4. Set how many events you want with `maxItems`, then start the run.
5. Collect your structured fireball records when the run finishes.

### 💼 Business use cases

#### 🛡 Planetary defense monitoring

| Need | How this Actor helps |
|---|---|
| Track atmospheric entries | Pull recent events with impact energy and altitude |
| Flag energetic bolides | Filter by minimum radiated energy |

#### 🔭 Scientific research

| Need | How this Actor helps |
|---|---|
| Study energy distribution | Build datasets of radiated and impact energy |
| Analyze entry geometry | Use velocity components for trajectory work |

#### 🗺 Geospatial analysis

| Need | How this Actor helps |
|---|---|
| Map fireballs by region | Use signed latitude and longitude directly |
| Focus on located events | Require a reported location |

#### 🎓 Education and outreach

| Need | How this Actor helps |
|---|---|
| Build classroom datasets | Return clean, per event records |
| Find recent bright meteors | Sort by the newest events first |

### 🔌 Automating NASA JPL Fireball Events Scraper

Connect this Actor to your stack so new fireball events flow where you need them.

- **Make** trigger a scenario when a run finishes and route records onward.
- **Zapier** push new events into a sheet or notification.
- **Slack** post a message when a new energetic bolide appears.
- **Airbyte** sync records into your warehouse.
- **GitHub** kick off runs from your workflows.
- **Google Drive** archive each run for later analysis.

### 🌟 Beyond business use cases

- **Research** assemble a long term fireball catalog for statistical study.
- **Personal** watch for bright meteors reported over your part of the world.
- **Non-profit** support science communication with current, sourced data.
- **Experimentation** prototype impact energy models and entry simulations.

### 🤖 Ask an AI assistant

Drop your records into an assistant and ask it to summarize, cluster, or chart them.

- [ChatGPT](https://chat.openai.com/)
- [Claude](https://claude.ai/)
- [Perplexity](https://www.perplexity.ai/)
- [Microsoft Copilot](https://copilot.microsoft.com/)

### ❓ Frequently Asked Questions

**Where does the data come from?**
The NASA/JPL CNEOS Fireball API, a public catalog of atmospheric fireball and bolide events detected by US Government sensors.

**Do I need an API key?**
No. The source is keyless, so the Actor works out of the box.

**Why is velocity null on some events?**
Velocity and its components are only published when the reporting sensor measured them. Energy, time, and location are still returned for those events.

**What does the energy field mean?**
It is the total radiated energy in joules times 10^10, the same unit the source uses.

**What is impact energy?**
The estimated total impact energy in kilotons of TNT, derived by the source from the radiated energy.

**Are the coordinates ready to plot?**
Yes. The Actor converts the source magnitude and direction into a signed decimal latitude and longitude, and keeps the direction letters too.

**Can I filter by date?**
Yes. Use `dateMin` and `dateMax` with a `YYYY-MM-DD` date or a full date time.

**Can I get only energetic events?**
Yes. Set `energyMin` to a minimum total radiated energy.

**How many events are available?**
The catalog holds more than a thousand events and grows as new fireballs are reported.

**How current is the data?**
Each run reads the live API, so you always get the latest reported events first.

### 🔌 Integrate with any app

Records can be picked up by any tool that reads the Apify API, so you can send fireball events into dashboards, sheets, warehouses, or alerting workflows.

### 🔗 Recommended Actors

- [Solar System Bodies Scraper](https://apify.com/parseforge)
- [NASA Exoplanet Archive Scraper](https://apify.com/parseforge)
- [NOAA SWPC Space Weather Scraper](https://apify.com/parseforge)
- [OpenChargeMap Scraper](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with NASA or JPL. Only publicly available data collected.

# Actor input Schema

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

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

## `dateMin` (type: `string`):

Only return events on or after this UTC date or date-time. Accepts YYYY-MM-DD or YYYY-MM-DDThh:mm:ss. Leave empty for no lower bound.

## `dateMax` (type: `string`):

Only return events on or before this UTC date or date-time. Accepts YYYY-MM-DD or YYYY-MM-DDThh:mm:ss. Leave empty for no upper bound.

## `energyMin` (type: `number`):

Only return events whose total radiated energy in joules x 10^10 is at least this value. Leave empty for no minimum.

## `requireLocation` (type: `boolean`):

When enabled, only events that have a reported latitude and longitude are returned.

## Actor input object example

```json
{
  "maxItems": 10,
  "dateMin": "2020-01-01",
  "dateMax": "2026-06-01",
  "energyMin": 1,
  "requireLocation": false
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/jpl-fireball-events-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/jpl-fireball-events-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/jpl-fireball-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NASA JPL Fireball Events Scraper",
        "description": "Pull atmospheric fireball and bolide events from the NASA JPL CNEOS catalog. Returns peak brightness time, radiated energy, impact energy in kilotons, latitude, longitude, altitude, and pre entry velocity. Useful for planetary defense work, meteor research, and mapping bright events.",
        "version": "0.1",
        "x-build-id": "9VKL0IEfeCKbnT8tS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~jpl-fireball-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-jpl-fireball-events-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~jpl-fireball-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-jpl-fireball-events-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~jpl-fireball-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-jpl-fireball-events-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "dateMin": {
                        "title": "Date From",
                        "type": "string",
                        "description": "Only return events on or after this UTC date or date-time. Accepts YYYY-MM-DD or YYYY-MM-DDThh:mm:ss. Leave empty for no lower bound."
                    },
                    "dateMax": {
                        "title": "Date To",
                        "type": "string",
                        "description": "Only return events on or before this UTC date or date-time. Accepts YYYY-MM-DD or YYYY-MM-DDThh:mm:ss. Leave empty for no upper bound."
                    },
                    "energyMin": {
                        "title": "Minimum Total Radiated Energy",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only return events whose total radiated energy in joules x 10^10 is at least this value. Leave empty for no minimum."
                    },
                    "requireLocation": {
                        "title": "Require Location",
                        "type": "boolean",
                        "description": "When enabled, only events that have a reported latitude and longitude are returned.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
