# NASA JPL Horizons Ephemeris Scraper (`parseforge/jpl-horizons-ephemeris-scraper`) Actor

Pull NASA JPL Horizons physical data and observer ephemerides for any planet, moon, asteroid, or comet. Returns right ascension, declination, apparent magnitude, range in astronomical units, solar elongation, mean radius, mass, and rotation period. Built for astronomy research.

- **URL**: https://apify.com/parseforge/jpl-horizons-ephemeris-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 $4.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 Horizons Ephemeris Scraper

> 🚀 **Pull observer ephemerides and physical data in seconds.** Get right ascension, declination, apparent magnitude, range, elongation, plus mean radius, mass, density, and rotation period for any solar-system body from NASA JPL Horizons.

> 🕒 **Last updated:** 2026-06-08 · **📊 Up to 28 fields** per record · one record per ephemeris step · planets, moons, asteroids, comets, spacecraft

Turn NASA's Jet Propulsion Laboratory (JPL) Horizons system into clean, structured records you can drop into an observation planner, an orbital-mechanics study, a planetarium app, or a research notebook. Pick a body, an observing center, a time span, and a step size, and the Actor returns one row per epoch with the apparent sky position and the body's physical parameters attached to every row.

Coverage is the full Horizons catalog: the Sun, the eight planets, the Moon, Pluto, and any object addressable by a Horizons COMMAND id, including numbered asteroids (for example `433` Eros), comets (for example `1P` Halley), and spacecraft (for example `-125544` for the ISS). Observer geometry can be computed from Earth's center, the solar-system barycenter, the Sun, the Moon, or Mars.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Amateur and professional astronomers | Plan observations with RA/Dec and magnitude |
| Orbital and planetary researchers | Pull range, elongation, and physical constants |
| Planetarium and app developers | Seed a sky engine without a Horizons client |
| Educators and science communicators | Build clear datasets for teaching |

### 📋 What the NASA JPL Horizons Ephemeris Scraper does

This Actor calls the public NASA JPL Horizons API in OBSERVER mode and returns one clean record per ephemeris step:

- **Sky position** — right ascension and declination in the ICRF frame.
- **Brightness and geometry** — apparent magnitude, surface brightness, range in astronomical units, range rate, solar elongation with its leading/trailing code, and the Sun-target-observer angle.
- **Physical data** — mean and equatorial radius, mass, density, GM, sidereal rotation and orbit periods, obliquity, geometric albedo, mean temperature, and escape speed, parsed from the body's Horizons header and attached to every row.

The NASA logo is used as the record image. Every record carries a `scrapedAt` timestamp.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `body` | select | Body to query, by Horizons COMMAND id. Major bodies in the dropdown (Sun `10`, Mercury `199`, Venus `299`, Earth `399`, Moon `301`, Mars `499`, Jupiter `599`, Saturn `699`, Uranus `799`, Neptune `899`, Pluto `999`) or `custom`. Defaults to Mars (`499`). |
| `customBody` | string | Used only when `body` is `custom`. Any Horizons id, e.g. `433` (Eros), `1P` (Halley), `-125544` (ISS). |
| `center` | select | Observing center: Geocentric `500@399`, barycenter `500@0`, Sun `500@10`, Moon `500@301`, or Mars `500@499`. Defaults to geocentric. |
| `startTime` | string | First epoch of the span, e.g. `2026-06-08` (a time like `2026-06-08 12:00` also works). |
| `stopTime` | string | Last epoch of the span. Must be after the start. |
| `stepSize` | string | Interval between rows, e.g. `1 d`, `6 h`, `30 m`, or a count like `20` to split the span into equal steps. |
| `maxItems` | integer | How many rows to return. Free plan is capped at 10. |

**Example 1 — daily Mars ephemeris from Earth**
```json
{
    "body": "499",
    "center": "500@399",
    "startTime": "2026-06-08",
    "stopTime": "2026-06-18",
    "stepSize": "1 d",
    "maxItems": 10
}
````

**Example 2 — asteroid 433 Eros, geocentric, six-hour steps**

```json
{
    "body": "custom",
    "customBody": "433",
    "center": "500@399",
    "startTime": "2026-06-08",
    "stopTime": "2026-06-10",
    "stepSize": "6 h",
    "maxItems": 9
}
```

> ⚠️ **Good to Know:** the row count is set by your time span and step size. A 10-day span at `1 d` yields about 11 rows. Some physical-data fields are not published for every body, so a field like `geometricAlbedo` or `meanTemperatureK` may be null for objects where Horizons does not provide it.

### 📊 Output

Each ephemeris record looks like this:

| Field | Description |
|---|---|
| 🖼 `imageUrl` | NASA logo |
| 🪐 `bodyName` | Resolved target body name |
| 🆔 `bodyId` | Horizons COMMAND id used |
| 🎯 `centerName` | Observing center body name |
| 📍 `centerSite` | Center-site name |
| 📅 `dateUtc` | Epoch of the row (UT) |
| 🧭 `raIcrf` | Right ascension, ICRF |
| 🧭 `decIcrf` | Declination, ICRF |
| ✨ `apparentMagnitude` | Apparent visual magnitude |
| 🔆 `surfaceBrightness` | Surface brightness |
| 📏 `deltaAu` | Observer-target range in AU |
| 🚀 `rangeRateKmS` | Range rate (km/s) |
| ☀ `solarElongationDeg` | Solar elongation in degrees |
| ↔ `elongationCode` | Elongation leading/trailing code |
| 📐 `sunTargetObserverDeg` | Sun-target-observer angle |
| 🌐 `meanRadiusKm` | Mean radius (km) |
| 🌐 `equatorialRadiusKm` | Equatorial radius (km) |
| ⚖ `massKg` | Mass (kg) |
| 🧪 `densityGCm3` | Density (g/cm³) |
| 🔭 `gmKm3S2` | GM (km³/s²) |
| 🔁 `siderealRotationPeriodHr` | Sidereal rotation period (hours) |
| 🛰 `siderealOrbitPeriodYr` | Sidereal orbit period (years) |
| 🌀 `obliquityToOrbitDeg` | Obliquity to orbit |
| 🌑 `geometricAlbedo` | Geometric albedo |
| 🌡 `meanTemperatureK` | Mean temperature (K) |
| 💨 `escapeSpeedKmS` | Escape speed (km/s) |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — ephemeris row**

```json
{
    "imageUrl": "https://upload.wikimedia.org/wikipedia/commons/thumb/e/e5/NASA_logo.svg/512px-NASA_logo.svg.png",
    "bodyName": "Mars (499)",
    "bodyId": "499",
    "centerName": "Earth (399)",
    "centerSite": "GEOCENTRIC",
    "dateUtc": "2026-Jun-08 00:00",
    "raIcrf": "05 41 22.18",
    "decIcrf": "+24 12 03.4",
    "apparentMagnitude": 1.64,
    "surfaceBrightness": 5.42,
    "deltaAu": 2.41887341,
    "rangeRateKmS": 18.742133,
    "solarElongationDeg": 21.3107,
    "elongationCode": "T",
    "sunTargetObserverDeg": 18.4521,
    "meanRadiusKm": 3389.92,
    "equatorialRadiusKm": 3396.19,
    "massKg": 6.4171e23,
    "densityGCm3": 3.933,
    "gmKm3S2": 42828.375,
    "siderealRotationPeriodHr": 24.622962,
    "siderealOrbitPeriodYr": 1.88081578,
    "obliquityToOrbitDeg": 25.19,
    "geometricAlbedo": 0.15,
    "meanTemperatureK": 210,
    "escapeSpeedKmS": 5.027,
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

### ✨ Why choose this Actor

- Observer ephemeris and physical data in one record, ready for analysis.
- Works for planets, moons, Pluto, asteroids, comets, and spacecraft via Horizons ids.
- Choose the observing center: Earth, barycenter, Sun, Moon, or Mars.
- Flexible sampling with `1 d`, `6 h`, `30 m`, or a step count.
- No account, no API key, and no Horizons client to build.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Physical data | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Attached per row | None on your side |
| Parsing Horizons by hand | Hours | Fragile | Manual | Constant |
| Writing your own API client | Days | Depends | You parse it | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the NASA JPL Horizons Ephemeris Scraper.
3. Choose a `body` (or `custom` plus a `customBody` id) and an observing `center`.
4. Set `startTime`, `stopTime`, `stepSize`, and `maxItems`.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Observation planning

| Goal | How this helps |
|---|---|
| Schedule a target | Use RA/Dec, magnitude, and elongation per epoch |
| Track a close approach | Sweep a span at a fine step size |

#### Research and analysis

| Goal | How this helps |
|---|---|
| Study geometry over time | Use range, range rate, and Sun-target-observer angle |
| Reference physical constants | Read mass, radius, density, and rotation per body |

#### Apps and tools

| Goal | How this helps |
|---|---|
| Power a sky map | Feed clean ICRF positions to your renderer |
| Build a body fact sheet | Pull the physical-data block in one run |

#### Education

| Goal | How this helps |
|---|---|
| Teach orbital motion | Show how position changes step by step |
| Compare planets | Tabulate radius, mass, and rotation side by side |

### 🔌 Automating NASA JPL Horizons Ephemeris Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into sheets or databases.
- **Slack** to post an object's nightly position to a channel.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** assemble long ephemeris series for an orbital study.
- **Personal:** plan a night of observing your favorite planet.
- **Non-profit:** power a community planetarium or outreach event.
- **Experimentation:** prototype a space app without wrangling the Horizons text format.

### 🤖 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 it to find the brightest night, plot range over time, or convert RA/Dec into alt/az for your location.

### ❓ Frequently Asked Questions

**Do I need a NASA or JPL account or API key?**
No. The Actor reads the public NASA JPL Horizons API, which needs no login.

**Which bodies can I query?**
Any object with a Horizons COMMAND id: planets, moons, Pluto, the Sun, numbered asteroids, comets, and spacecraft. Use the dropdown for major bodies or `custom` for everything else.

**What is the observing center?**
Where the observer sits. Geocentric (`500@399`) gives the standard sky position from Earth. Barycenter, Sun, Moon, and Mars centers give other geometries.

**What does the step size accept?**
Intervals like `1 d`, `6 h`, `30 m`, or a plain count like `20` that splits the span into equal steps.

**What frame are RA and Dec in?**
The ICRF (International Celestial Reference Frame), returned as `raIcrf` and `decIcrf`.

**Why are some physical fields null?**
Horizons does not publish every physical parameter for every body. Fields it does not provide come back null rather than guessed.

**Is the physical data on every row?**
Yes. The body's physical constants are parsed once and attached to each ephemeris row for convenience.

**What does the elongation code mean?**
`solarElongationDeg` is the angle from the Sun; `elongationCode` marks whether the body is leading or trailing the Sun.

**How fresh is the data?**
Each run queries Horizons live, so it reflects the current ephemeris computation.

**Can I schedule this?**
Yes. Use Apify Schedules to refresh an object's ephemeris on any cadence.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- [USNO Astronomical Almanac Scraper](https://apify.com/parseforge)
- [NOAA CoastWatch ERDDAP Ocean Data Scraper](https://apify.com/parseforge)
- More science and reference data Actors in the [ParseForge collection](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 is collected.

# Actor input Schema

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

The solar-system body to query, by NASA JPL Horizons COMMAND id. Pick a major body here, or choose 'Custom id' and type any other Horizons id (asteroid, comet, spacecraft) in the field below.

## `customBody` (type: `string`):

Only used when Body is set to 'Custom id'. Any valid NASA JPL Horizons COMMAND id, for example '433' (Eros), '1P' (Halley), or '-125544' (ISS). Leave empty when a major body is selected above.

## `center` (type: `string`):

Where the observer sits. Geocentric is the standard sky position from Earth's center. Solar-system barycenter and the Sun give heliocentric-style geometry.

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

First epoch of the ephemeris span, in YYYY-MM-DD (a time like '2026-06-08 12:00' also works).

## `stopTime` (type: `string`):

Last epoch of the ephemeris span, in YYYY-MM-DD. Must be after the start time.

## `stepSize` (type: `string`):

Sampling interval between rows, for example '1 d', '6 h', '30 m', or a count like '20' to split the span into 20 equal steps.

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

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

## Actor input object example

```json
{
  "body": "499",
  "center": "500@399",
  "startTime": "2026-06-08",
  "stopTime": "2026-06-18",
  "stepSize": "1 d",
  "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 = {
    "startTime": "2026-06-08",
    "stopTime": "2026-06-18",
    "stepSize": "1 d",
    "maxItems": 10
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startTime": "2026-06-08",
    "stopTime": "2026-06-18",
    "stepSize": "1 d",
    "maxItems": 10,
}

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

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

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

```

## CLI example

```bash
echo '{
  "startTime": "2026-06-08",
  "stopTime": "2026-06-18",
  "stepSize": "1 d",
  "maxItems": 10
}' |
apify call parseforge/jpl-horizons-ephemeris-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NASA JPL Horizons Ephemeris Scraper",
        "description": "Pull NASA JPL Horizons physical data and observer ephemerides for any planet, moon, asteroid, or comet. Returns right ascension, declination, apparent magnitude, range in astronomical units, solar elongation, mean radius, mass, and rotation period. Built for astronomy research.",
        "version": "0.1",
        "x-build-id": "06o09aUvtmohLYORL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~jpl-horizons-ephemeris-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-jpl-horizons-ephemeris-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-horizons-ephemeris-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-jpl-horizons-ephemeris-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-horizons-ephemeris-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-jpl-horizons-ephemeris-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": {
                    "body": {
                        "title": "Body",
                        "enum": [
                            "10",
                            "199",
                            "299",
                            "399",
                            "301",
                            "499",
                            "599",
                            "699",
                            "799",
                            "899",
                            "999",
                            "custom"
                        ],
                        "type": "string",
                        "description": "The solar-system body to query, by NASA JPL Horizons COMMAND id. Pick a major body here, or choose 'Custom id' and type any other Horizons id (asteroid, comet, spacecraft) in the field below.",
                        "default": "499"
                    },
                    "customBody": {
                        "title": "Custom body id",
                        "type": "string",
                        "description": "Only used when Body is set to 'Custom id'. Any valid NASA JPL Horizons COMMAND id, for example '433' (Eros), '1P' (Halley), or '-125544' (ISS). Leave empty when a major body is selected above."
                    },
                    "center": {
                        "title": "Observing center",
                        "enum": [
                            "500@399",
                            "500@0",
                            "500@10",
                            "500@301",
                            "500@499"
                        ],
                        "type": "string",
                        "description": "Where the observer sits. Geocentric is the standard sky position from Earth's center. Solar-system barycenter and the Sun give heliocentric-style geometry.",
                        "default": "500@399"
                    },
                    "startTime": {
                        "title": "Start time",
                        "type": "string",
                        "description": "First epoch of the ephemeris span, in YYYY-MM-DD (a time like '2026-06-08 12:00' also works)."
                    },
                    "stopTime": {
                        "title": "Stop time",
                        "type": "string",
                        "description": "Last epoch of the ephemeris span, in YYYY-MM-DD. Must be after the start time."
                    },
                    "stepSize": {
                        "title": "Step size",
                        "type": "string",
                        "description": "Sampling interval between rows, for example '1 d', '6 h', '30 m', or a count like '20' to split the span into 20 equal steps."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```