# NASA JPL Small-Body Database Scraper (`parseforge/jpl-small-body-database-scraper`) Actor

Pull asteroid and comet science from the NASA JPL Small-Body Database. Returns full name, SPK-ID, diameter, albedo, rotation period, spectral type, orbital elements, MOID and orbit class. Ideal for mission target planning, research catalogues, and teaching orbital mechanics.

- **URL**: https://apify.com/parseforge/jpl-small-body-database-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, AI, 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 Small-Body Database Scraper

> 🚀 **Pull asteroid and comet science data in seconds.** Get full names, SPK-IDs, diameters, albedos, rotation periods, spectral types and a complete set of orbital elements straight from NASA/JPL.

> 🕒 **Last updated:** 2026-06-05 · **📊 31 fields** per record · 1.5M+ known small bodies reachable · Asteroids and comets

The NASA/JPL Small-Body Database (SBDB) is the reference catalogue for asteroids and comets in the Solar System, maintained by the Solar System Dynamics group at the Jet Propulsion Laboratory. This Actor reads the official keyless SBDB API and returns clean, structured records combining physical parameters (magnitude, diameter, albedo, rotation period, spectral type) with full orbital elements (semi-major axis, eccentricity, inclination, node, argument of perihelion, mean anomaly, period) plus MOID and orbit class.

You can either look up a specific list of objects by number, name or SPK-ID, or browse the catalogue by kind to list many bodies at once. Every record links back to its source on the SBDB API.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Astronomers and astrophysics researchers | Building asteroid and comet datasets for analysis |
| Aerospace and mission planning teams | Selecting targets by orbit class, MOID or diameter |
| Educators and planetarium developers | Teaching orbital mechanics with real numbers |
| Data scientists and hobbyists | Feeding orbital and physical data into models |

### 📋 What the NASA JPL Small-Body Database Scraper does

This Actor turns the SBDB API into a tidy table of asteroid and comet records. For each object it collects identification (full name, short name, designation, SPK-ID, kind, orbit class, NEO and PHA flags), physical parameters (absolute magnitude H, slope G, diameter, albedo, rotation period, spectral type) and orbital elements (a, e, i, node, argument of perihelion, mean anomaly, perihelion and aphelion distance, orbital period), together with Earth and Jupiter MOID and observation arc dates.

Two modes are available. Provide a list of designations to fetch specific bodies one by one with the richest physical data, or leave the list empty and browse the catalogue by kind to list many asteroids or comets quickly.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `designations` | array | List of numbers, names or SPK-IDs to look up individually (for example "433", "Eros", "99942"). |
| `browseKind` | string | When the list is empty, browse the catalogue by kind (asteroids or comets, all, numbered or unnumbered). |
| `maxItems` | integer | Maximum number of records to return. Free plan is capped at 10. |

Example 1, look up specific bodies:

```json
{
    "designations": ["433", "1", "99942", "101955", "2", "4", "16", "21", "243"],
    "maxItems": 10
}
````

Example 2, browse many asteroids:

```json
{
    "designations": [],
    "browseKind": "a",
    "maxItems": 50
}
```

> ⚠️ **Good to Know:** the lookup mode returns the most complete physical data per object. The browse mode is faster for large lists but some physical fields can be empty when JPL has not measured them for that body.

### 📊 Output

| Field | Description |
|---|---|
| 📌 `fullName` | Full designation and name, for example "433 Eros (A898 PA)" |
| 🏷 `shortName` | Short name, for example "433 Eros" |
| 🔢 `designation` | Primary designation or number |
| 🆔 `spkId` | JPL SPK-ID unique identifier |
| 🧭 `kind` | Object kind code (asteroid or comet, numbered or not) |
| 🛰 `orbitClass` | Orbit class name, for example Amor, Apollo, Main-belt Asteroid |
| 🛰 `orbitClassCode` | Orbit class short code |
| 🌍 `neo` | Near-Earth object flag |
| ⚠️ `pha` | Potentially hazardous asteroid flag |
| ✨ `absoluteMagnitude` | Absolute magnitude H |
| 📉 `magnitudeSlope` | Magnitude slope parameter G |
| 📏 `diameterKm` | Effective diameter in kilometres |
| 🌗 `albedo` | Geometric albedo |
| 🔄 `rotationPeriodHours` | Rotation period in hours |
| 🎨 `spectralType` | Spectral type (Bus or Tholen) |
| 🪐 `semiMajorAxisAu` | Semi-major axis in au |
| 🥚 `eccentricity` | Orbital eccentricity |
| 📐 `inclinationDeg` | Inclination in degrees |
| ↗️ `ascendingNodeDeg` | Longitude of ascending node in degrees |
| 🧮 `argPerihelionDeg` | Argument of perihelion in degrees |
| 🔁 `meanAnomalyDeg` | Mean anomaly in degrees |
| 🟢 `perihelionDistAu` | Perihelion distance in au |
| 🔴 `aphelionDistAu` | Aphelion distance in au |
| ⏱ `orbitalPeriodDays` | Orbital period in days |
| 🌍 `moidAu` | Earth minimum orbit intersection distance in au |
| 🪐 `moidJupiterAu` | Jupiter MOID in au |
| 📅 `epoch` | Orbit solution epoch (Julian date) |
| 🔭 `firstObs` | Date of first observation |
| 🔭 `lastObs` | Date of last observation |
| 🔗 `sourceUrl` | Link back to the SBDB API record |
| 🕒 `scrapedAt` | Timestamp of collection |
| ❌ `error` | Error message when a lookup fails |

Sample records:

```json
{
    "fullName": "433 Eros (A898 PA)",
    "shortName": "433 Eros",
    "designation": "433",
    "spkId": "20000433",
    "kind": "an",
    "orbitClass": "Amor",
    "orbitClassCode": "AMO",
    "neo": true,
    "pha": false,
    "absoluteMagnitude": 10.39,
    "magnitudeSlope": 0.46,
    "diameterKm": 16.84,
    "albedo": 0.25,
    "rotationPeriodHours": 5.27,
    "spectralType": "S",
    "semiMajorAxisAu": 1.46,
    "eccentricity": 0.223,
    "inclinationDeg": 10.8,
    "ascendingNodeDeg": 304,
    "argPerihelionDeg": 179,
    "meanAnomalyDeg": 311,
    "perihelionDistAu": 1.13,
    "aphelionDistAu": 1.78,
    "orbitalPeriodDays": 643,
    "moidAu": 0.148,
    "moidJupiterAu": 3.29,
    "epoch": "2461000.5",
    "firstObs": "1893-10-29",
    "lastObs": "2021-05-13",
    "sourceUrl": "https://ssd-api.jpl.nasa.gov/sbdb.api?sstr=433&phys-par=true",
    "scrapedAt": "2026-06-05T15:54:59.626Z",
    "error": null
}
```

```json
{
    "fullName": "1 Ceres (A801 AA)",
    "shortName": "1 Ceres",
    "designation": "1",
    "spkId": "20000001",
    "kind": "an",
    "orbitClass": "Main-belt Asteroid",
    "orbitClassCode": "MBA",
    "neo": false,
    "pha": false,
    "absoluteMagnitude": 3.35,
    "diameterKm": 939.4,
    "albedo": 0.09,
    "rotationPeriodHours": 9.07417,
    "spectralType": "C",
    "semiMajorAxisAu": 2.77,
    "eccentricity": 0.0796,
    "inclinationDeg": 10.59,
    "moidAu": 1.58,
    "moidJupiterAu": 2.1,
    "sourceUrl": "https://ssd-api.jpl.nasa.gov/sbdb.api?sstr=1&phys-par=true",
    "scrapedAt": "2026-06-05T15:54:59.700Z",
    "error": null
}
```

```json
{
    "fullName": "99942 Apophis (2004 MN4)",
    "shortName": "99942 Apophis",
    "designation": "99942",
    "spkId": "20099942",
    "kind": "an",
    "orbitClass": "Aten",
    "orbitClassCode": "ATE",
    "neo": true,
    "pha": true,
    "absoluteMagnitude": 19.09,
    "diameterKm": 0.34,
    "albedo": 0.35,
    "rotationPeriodHours": 30.56,
    "spectralType": "Sq",
    "semiMajorAxisAu": 0.922,
    "eccentricity": 0.191,
    "inclinationDeg": 3.34,
    "moidAu": 0.000361,
    "sourceUrl": "https://ssd-api.jpl.nasa.gov/sbdb.api?sstr=99942&phys-par=true",
    "scrapedAt": "2026-06-05T15:54:59.820Z",
    "error": null
}
```

### ✨ Why choose this Actor

- Reads the official NASA/JPL SBDB API directly, no third party data sources.
- Combines physical and orbital parameters in a single flat record.
- Two modes, precise lookup or wide catalogue browse.
- Every record carries a source link back to JPL for verification.
- No API key and no account with JPL required.

### 📈 How it compares to alternatives

| Approach | Physical params | Full orbital elements | MOID and class | Structured output |
|---|---|---|---|---|
| This Actor | Yes | Yes | Yes | Yes |
| Manual SBDB web lookups | Yes | Yes | Yes | No, one page at a time |
| Generic HTML scrapers | Partial | Partial | Rarely | Fragile |

### 🚀 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 Small-Body Database Scraper.
3. Enter a list of designations, or leave it empty and pick a browse kind.
4. Set how many records you want and start the run.
5. Collect your structured asteroid and comet records when the run finishes.

### 💼 Business use cases

#### 🛰 Mission and target planning

| Need | How this helps |
|---|---|
| Shortlist reachable targets | Filter by orbit class, MOID and diameter |
| Assess approach geometry | Use semi-major axis, eccentricity and inclination |

#### 📊 Research datasets

| Need | How this helps |
|---|---|
| Build a clean catalogue | Browse thousands of asteroids or comets at once |
| Cross study physical and orbital traits | One record holds both sets of fields |

#### 🎓 Education and outreach

| Need | How this helps |
|---|---|
| Teach orbital mechanics | Real elements for famous bodies like Ceres and Apophis |
| Power planetarium content | Pull spectral types, sizes and rotation periods |

#### 🤖 Data products

| Need | How this helps |
|---|---|
| Feed dashboards and apps | Stable structured fields with source links |
| Enrich existing catalogues | Match by SPK-ID or designation |

### 🔌 Automating NASA JPL Small-Body Database Scraper

Connect runs to Make, Zapier, Slack, Airbyte, GitHub Actions or Google Drive through the Apify API and integrations. Schedule recurring runs to keep your catalogue fresh, or trigger a run whenever a new target list lands in your pipeline.

### 🌟 Beyond business use cases

- **Research:** assemble custom asteroid and comet samples for papers and simulations.
- **Personal:** track the orbit and properties of your favourite near-Earth objects.
- **Non-profit:** support science clubs and outreach with real Solar System data.
- **Experimentation:** prototype orbital models and visualisations with clean inputs.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com/), [Claude](https://claude.ai/), [Perplexity](https://www.perplexity.ai/) or [Copilot](https://copilot.microsoft.com/) and ask it to cluster bodies by spectral type, rank near-Earth objects by MOID, or explain the orbit class of any object.

### ❓ Frequently Asked Questions

**Is this affiliated with NASA or JPL?**
No. It is an independent tool that reads the public SBDB API. All data belongs to NASA/JPL.

**Do I need an API key?**
No. The SBDB API is keyless and free to query.

**How many objects can I fetch?**
The SBDB catalogue holds more than 1.5 million known small bodies. Free runs are capped at 10 records, paid runs go up to 1,000,000.

**What is the difference between the two modes?**
Lookup mode fetches each object individually with the fullest physical data. Browse mode lists many bodies of a chosen kind in one request.

**Can I look up a comet?**
Yes. Use a comet designation in the list, or set the browse kind to comets.

**What is an SPK-ID?**
A stable numeric identifier JPL assigns to each body, useful for joining datasets.

**What does MOID mean?**
Minimum orbit intersection distance, the closest the two orbits come. The Earth MOID helps flag hazardous objects.

**Why is a physical field sometimes empty?**
JPL only reports measured values. Diameter, albedo or rotation can be missing for poorly studied bodies.

**Are the orbital elements current?**
They reflect the latest orbit solution JPL publishes for each object, with the solution epoch included.

**Can I search by name?**
Yes. Names like "Eros" or "Bennu" work in the lookup list, alongside numbers and SPK-IDs.

### 🔌 Integrate with any app

Use the Apify API, webhooks and ready made integrations to push records into your warehouse, spreadsheet, notebook or notification channel.

### 🔗 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

## `designations` (type: `array`):

List of asteroid or comet designations, numbers, names or SPK-IDs to look up (for example "433", "99942", "Eros", "101955"). Each entry is fetched individually with full physical and orbital data. Leave empty to instead list many bodies via the catalogue browse mode below.

## `browseKind` (type: `string`):

When the designations list above is empty, browse the SBDB catalogue for many bodies of this kind. Asteroids and comets are listed with orbital and basic physical fields.

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

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

## Actor input object example

```json
{
  "designations": [
    "433",
    "1",
    "99942",
    "101955",
    "2",
    "4",
    "16",
    "21",
    "243"
  ],
  "browseKind": "a",
  "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 = {
    "designations": [
        "433",
        "1",
        "99942",
        "101955",
        "2",
        "4",
        "16",
        "21",
        "243"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/jpl-small-body-database-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 = {
    "designations": [
        "433",
        "1",
        "99942",
        "101955",
        "2",
        "4",
        "16",
        "21",
        "243",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/jpl-small-body-database-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 '{
  "designations": [
    "433",
    "1",
    "99942",
    "101955",
    "2",
    "4",
    "16",
    "21",
    "243"
  ],
  "maxItems": 10
}' |
apify call parseforge/jpl-small-body-database-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NASA JPL Small-Body Database Scraper",
        "description": "Pull asteroid and comet science from the NASA JPL Small-Body Database. Returns full name, SPK-ID, diameter, albedo, rotation period, spectral type, orbital elements, MOID and orbit class. Ideal for mission target planning, research catalogues, and teaching orbital mechanics.",
        "version": "0.1",
        "x-build-id": "0GOsGvgpc4ePs8yvI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~jpl-small-body-database-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-jpl-small-body-database-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-small-body-database-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-jpl-small-body-database-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-small-body-database-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-jpl-small-body-database-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": {
                    "designations": {
                        "title": "Object Designations",
                        "type": "array",
                        "description": "List of asteroid or comet designations, numbers, names or SPK-IDs to look up (for example \"433\", \"99942\", \"Eros\", \"101955\"). Each entry is fetched individually with full physical and orbital data. Leave empty to instead list many bodies via the catalogue browse mode below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "browseKind": {
                        "title": "Catalogue Browse Kind",
                        "enum": [
                            "a",
                            "c",
                            "an",
                            "au",
                            "cn",
                            "cu"
                        ],
                        "type": "string",
                        "description": "When the designations list above is empty, browse the SBDB catalogue for many bodies of this kind. Asteroids and comets are listed with orbital and basic physical fields.",
                        "default": "a"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
