# NASA JPL Close Approach Scraper (`parseforge/jpl-close-approach-scraper`) Actor

Track every asteroid and comet that swings past Earth using NASA JPL CNEOS data. Returns object designation, close approach date, nominal distance in astronomical units and lunar distances, relative velocity, and absolute magnitude H. Filter by date, distance, brightness, or target body.

- **URL**: https://apify.com/parseforge/jpl-close-approach-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 Close Approach Scraper

> 🚀 **Export near-Earth object close approaches in seconds.** Pull every asteroid and comet flyby tracked by NASA/JPL CNEOS, with distance, velocity, and brightness for each pass.

> 🕒 **Last updated:** 2026-06-05 · **📊 15 fields** per record · Earth, the Moon, and every major planet · Historical and predicted approaches

Track the asteroids and comets that swing close to Earth using data straight from NASA's Jet Propulsion Laboratory. The CNEOS Close-Approach Data (CAD) service catalogues every known near-Earth object pass, and this Actor turns that catalogue into clean, structured records you can drop into a notebook, a dashboard, or an alerting pipeline.

**Coverage:** Pick any date window, distance threshold, brightness limit, and target body. The service spans approaches that have already happened and ones predicted decades into the future, for Earth, the Moon, Mercury through Pluto, or all bodies at once.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Astronomers and astrophotographers | Planning observation nights around upcoming flybys |
| Data scientists and students | Building near-Earth object datasets for analysis |
| Science communicators and educators | Sourcing real numbers for articles and lessons |
| Developers and hobbyists | Powering sky-watch apps, bots, and alert feeds |

### 📋 What the JPL Close Approach Scraper does

This Actor queries the NASA/JPL CNEOS Close-Approach Data API and returns one record per close approach. Each record carries the object designation and full name, the calendar and Julian close-approach date, the nominal, minimum, and maximum approach distance in astronomical units, a matching distance in lunar distances, the relative and infinity velocity in kilometres per second, the absolute magnitude H, the orbit solution ID, and the target body. A direct link to the object's JPL Small-Body Database page is included for every record.

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

### ⚙️ Input

Configure a run with a date window, distance and brightness filters, and a target body. Every field has a sensible default, so you can run it as-is for a near-Earth sample.

| Field | Type | Description |
|---|---|---|
| `dateMin` | string | Earliest close-approach date (YYYY-MM-DD or `now`) |
| `dateMax` | string | Latest close-approach date (YYYY-MM-DD or a span like `+60`) |
| `maxDistanceAu` | string | Only return approaches nearer than this distance in au |
| `maxMagnitude` | string | Optional. Only return objects brighter than this H value |
| `body` | string | Target body. Earth, the Moon, a planet, or all bodies |
| `maxItems` | integer | Free users limited to 10. Paid users up to 1,000,000 |

```json
{
    "dateMin": "2026-01-01",
    "dateMax": "2026-03-01",
    "maxDistanceAu": "0.05",
    "body": "Earth",
    "maxItems": 10
}
````

```json
{
    "dateMin": "2025-01-01",
    "dateMax": "2030-01-01",
    "maxDistanceAu": "0.01",
    "maxMagnitude": "22",
    "body": "Earth",
    "maxItems": 500
}
```

> ⚠️ **Good to Know:** The API caps a single query at a wide but finite window. For multi-decade sweeps, run several requests with adjacent date ranges. Distance is the nominal close-approach distance, with the minimum and maximum bounds reflecting orbit uncertainty.

### 📊 Output

| Field | Description |
|---|---|
| 🪨 `designation` | Object provisional or permanent designation |
| 📛 `fullName` | Full catalogued name of the object |
| 🌍 `body` | The body the object approaches |
| 📅 `closeApproachDate` | Calendar date and time of closest approach (UTC) |
| 🕓 `julianDate` | Julian date of closest approach |
| 📏 `nominalDistanceAu` | Nominal approach distance in astronomical units |
| 🌙 `nominalDistanceLd` | Nominal approach distance in lunar distances |
| 📐 `minDistanceAu` | Minimum possible approach distance (au) |
| 📐 `maxDistanceAu` | Maximum possible approach distance (au) |
| 🚀 `relativeVelocityKmS` | Velocity relative to the body at approach (km/s) |
| 💫 `infinityVelocityKmS` | Velocity at infinity (km/s) |
| ✨ `absoluteMagnitude` | Absolute magnitude H (smaller means larger object) |
| 🛰 `orbitId` | Orbit solution identifier |
| 🔗 `sourceUrl` | Link to the JPL Small-Body Database lookup |
| 🕒 `scrapedAt` | Timestamp of when the record was collected |

Sample records from a live run:

```json
{
    "designation": "2025 YL4",
    "fullName": "(2025 YL4)",
    "body": "Earth",
    "closeApproachDate": "2026-Jan-01 15:44",
    "julianDate": 2461042.155848,
    "nominalDistanceAu": 0.00969853,
    "nominalDistanceLd": 3.7744,
    "minDistanceAu": 0.00966626,
    "maxDistanceAu": 0.0097308,
    "relativeVelocityKmS": 9.8181,
    "infinityVelocityKmS": 9.7901,
    "absoluteMagnitude": 26.67,
    "orbitId": "4",
    "sourceUrl": "https://ssd.jpl.nasa.gov/tools/sbdb_lookup.html#/?sstr=2025%20YL4",
    "scrapedAt": "2026-06-05T15:56:03.180Z",
    "error": null
}
```

```json
{
    "designation": "2025 XC7",
    "fullName": "(2025 XC7)",
    "body": "Earth",
    "closeApproachDate": "2026-Jan-01 23:42",
    "julianDate": 2461042.487163,
    "nominalDistanceAu": 0.02282497,
    "nominalDistanceLd": 8.8828,
    "minDistanceAu": 0.0228117,
    "maxDistanceAu": 0.02283823,
    "relativeVelocityKmS": 6.5598,
    "infinityVelocityKmS": 6.542,
    "absoluteMagnitude": 25.41,
    "orbitId": "16",
    "sourceUrl": "https://ssd.jpl.nasa.gov/tools/sbdb_lookup.html#/?sstr=2025%20XC7",
    "scrapedAt": "2026-06-05T15:56:03.281Z",
    "error": null
}
```

```json
{
    "designation": "2025 YZ",
    "fullName": "(2025 YZ)",
    "body": "Earth",
    "closeApproachDate": "2026-Jan-02 05:29",
    "julianDate": 2461042.72881,
    "nominalDistanceAu": 0.03618111,
    "nominalDistanceLd": 14.0806,
    "minDistanceAu": 0.03592027,
    "maxDistanceAu": 0.03644194,
    "relativeVelocityKmS": 6.6676,
    "infinityVelocityKmS": 6.6565,
    "absoluteMagnitude": 25.41,
    "orbitId": "4",
    "sourceUrl": "https://ssd.jpl.nasa.gov/tools/sbdb_lookup.html#/?sstr=2025%20YZ",
    "scrapedAt": "2026-06-05T15:56:03.304Z",
    "error": null
}
```

### ✨ Why choose this Actor

- Data comes directly from NASA's Jet Propulsion Laboratory, the authoritative source for near-Earth object tracking.
- Distances arrive in both astronomical units and lunar distances, so you can read a flyby at a glance.
- Filters for date, distance, brightness, and body let you target exactly the passes you care about.
- Each record links straight to the JPL Small-Body Database for deeper orbit and physical data.
- Clean, flat records that drop straight into spreadsheets, notebooks, and databases.

### 📈 How it compares to alternatives

| Approach | Setup | Filtering | Structured output |
|---|---|---|---|
| This Actor | None, run and go | Date, distance, magnitude, body | Yes, 15 flat fields |
| Reading the CNEOS web table | Manual copy paste | Limited | No |
| Writing your own API client | Hours of coding | You build it | You build it |

### 🚀 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 JPL Close Approach Scraper and click Try for free.
3. Set your date window, distance threshold, and target body, or keep the defaults.
4. Click Start and watch the records arrive.
5. Browse the results in the table view or pull them through the Apify API into your own tools.

### 💼 Business use cases

#### Media and science communication

| Need | How this helps |
|---|---|
| Timely flyby coverage | Surface upcoming close approaches with real distances and dates |
| Fact-checked numbers | Source figures directly from NASA/JPL |

#### Education and outreach

| Need | How this helps |
|---|---|
| Classroom datasets | Hand students real near-Earth object records to analyse |
| Observation planning | Pick targets bright enough for a given telescope |

#### Software and apps

| Need | How this helps |
|---|---|
| Sky-watch features | Feed a clean flyby feed into an app or bot |
| Alerting | Flag objects passing within a chosen distance |

#### Research and analysis

| Need | How this helps |
|---|---|
| Population studies | Build datasets across years and bodies |
| Velocity and size trends | Combine magnitude and velocity fields for analysis |

### 🔌 Automating JPL Close Approach Scraper

Connect this Actor to the tools your team already uses:

- **Make** and **Zapier** to trigger runs and route records into other apps.
- **Slack** to post alerts when an object passes within a set distance.
- **Airbyte** to sync results into a warehouse.
- **GitHub** Actions to schedule recurring pulls.
- **Google Drive** to archive each run for later analysis.

### 🌟 Beyond business use cases

- **Research:** assemble multi-year near-Earth object catalogues for study.
- **Personal:** plan a night of asteroid spotting around the next bright flyby.
- **Non-profit:** power free public sky-watch resources and newsletters.
- **Experimentation:** prototype space-themed visualisations and bots.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask questions like which object passes closest this month, or how velocity relates to approach distance across the dataset.

### ❓ Frequently Asked Questions

**Where does the data come from?**
The NASA/JPL CNEOS Close-Approach Data API, the official near-Earth object tracking service maintained by the Jet Propulsion Laboratory.

**Do I need an API key?**
No. The source is public and keyless. Just run the Actor.

**What is a lunar distance?**
The mean distance from Earth to the Moon. One astronomical unit equals roughly 389 lunar distances, so the Moon sits at one LD.

**What does absolute magnitude H mean?**
A measure of intrinsic brightness. A smaller H generally means a larger object.

**Can I track approaches to other planets?**
Yes. Choose the Moon, Mercury through Pluto, or all bodies at once in the body field.

**Does it include past approaches?**
Yes. Set a start date in the past to retrieve historical passes.

**How far into the future does it go?**
The service predicts approaches decades ahead. Use a future end date to retrieve them.

**Why are there minimum and maximum distances?**
They reflect the uncertainty in the object's orbit. The nominal value is the best estimate.

**How many records can I get?**
Free runs return up to 10 records. Paid plans return up to 1,000,000.

**What is the orbit ID?**
An identifier for the specific orbit solution used to compute the approach.

### 🔌 Integrate with any app

Every run writes to an Apify storage you can read through the API, webhooks, or any of the supported integrations, so the records flow straight into your stack.

### 🔗 Recommended Actors

- [NASA Exoplanet Archive Scraper](https://apify.com/parseforge)
- [Solar System Bodies Scraper](https://apify.com/parseforge)
- [NOAA SWPC Space Weather 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 the Jet Propulsion Laboratory. Only publicly available data collected.

# Actor input Schema

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

Earliest close-approach date to include (format YYYY-MM-DD). You may also use 'now' for today. Defaults to 2026-01-01.

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

Latest close-approach date to include (format YYYY-MM-DD, or a span such as '+60' days from the start). Defaults to 2026-03-01.

## `maxDistanceAu` (type: `string`):

Only return approaches nearer than this nominal distance in astronomical units. One au is about 389 lunar distances. Defaults to 0.05.

## `maxMagnitude` (type: `string`):

Optional. Only return objects with an absolute magnitude H below this value. Lower H means a larger, brighter object. Leave empty to include all sizes.

## `body` (type: `string`):

The body the object approaches. Choose Earth for near-Earth objects or pick another planet or the Moon.

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

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

## Actor input object example

```json
{
  "dateMin": "2026-01-01",
  "dateMax": "2026-03-01",
  "maxDistanceAu": "0.05",
  "maxMagnitude": "22",
  "body": "Earth",
  "maxItems": 10
}
```

# 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 = {
    "dateMin": "2026-01-01",
    "dateMax": "2026-03-01",
    "maxDistanceAu": "0.05",
    "body": "Earth",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/jpl-close-approach-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 = {
    "dateMin": "2026-01-01",
    "dateMax": "2026-03-01",
    "maxDistanceAu": "0.05",
    "body": "Earth",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/jpl-close-approach-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 '{
  "dateMin": "2026-01-01",
  "dateMax": "2026-03-01",
  "maxDistanceAu": "0.05",
  "body": "Earth",
  "maxItems": 10
}' |
apify call parseforge/jpl-close-approach-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NASA JPL Close Approach Scraper",
        "description": "Track every asteroid and comet that swings past Earth using NASA JPL CNEOS data. Returns object designation, close approach date, nominal distance in astronomical units and lunar distances, relative velocity, and absolute magnitude H. Filter by date, distance, brightness, or target body.",
        "version": "0.1",
        "x-build-id": "G9tR3KMDnmZEBfdhN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~jpl-close-approach-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-jpl-close-approach-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-close-approach-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-jpl-close-approach-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-close-approach-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-jpl-close-approach-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": {
                    "dateMin": {
                        "title": "Start Date",
                        "type": "string",
                        "description": "Earliest close-approach date to include (format YYYY-MM-DD). You may also use 'now' for today. Defaults to 2026-01-01.",
                        "default": "2026-01-01"
                    },
                    "dateMax": {
                        "title": "End Date",
                        "type": "string",
                        "description": "Latest close-approach date to include (format YYYY-MM-DD, or a span such as '+60' days from the start). Defaults to 2026-03-01.",
                        "default": "2026-03-01"
                    },
                    "maxDistanceAu": {
                        "title": "Maximum Distance (au)",
                        "type": "string",
                        "description": "Only return approaches nearer than this nominal distance in astronomical units. One au is about 389 lunar distances. Defaults to 0.05.",
                        "default": "0.05"
                    },
                    "maxMagnitude": {
                        "title": "Maximum H Magnitude",
                        "type": "string",
                        "description": "Optional. Only return objects with an absolute magnitude H below this value. Lower H means a larger, brighter object. Leave empty to include all sizes."
                    },
                    "body": {
                        "title": "Target Body",
                        "enum": [
                            "Earth",
                            "Moon",
                            "Merc",
                            "Venus",
                            "Mars",
                            "Jupiter",
                            "Saturn",
                            "Uranus",
                            "Neptune",
                            "Pluto",
                            "ALL"
                        ],
                        "type": "string",
                        "description": "The body the object approaches. Choose Earth for near-Earth objects or pick another planet or the Moon.",
                        "default": "Earth"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
