# NASA Exoplanet Archive Scraper (`parseforge/nasa-exoplanet-archive-scraper`) Actor

Pull confirmed exoplanets straight from the NASA Exoplanet Archive. Each record carries planet name, host star, discovery method and year, orbital period, radius, mass, and distance in parsecs. Filter by detection method, year, or host star for research, teaching, or model building.

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

## Pricing

from $0.60 / 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 Exoplanet Archive Scraper

> 🚀 **Export the confirmed planet catalogue in seconds.** Pull from a live archive of 6,298 confirmed exoplanets with orbital, planetary and host star measurements in one structured feed.

> 🕒 **Last updated:** 2026-06-04 · **📊 14 fields** per record · 6,298 confirmed planets · 11 detection methods

The NASA Exoplanet Archive Scraper turns the official NASA Exoplanet Archive into a clean, structured dataset. It queries the archive's public TAP service and returns one canonical row per confirmed planet, complete with discovery details, orbital mechanics and host star properties.

Coverage spans every confirmed planet in the Planetary Systems table, from the first radial velocity detections to the latest TESS transits. Filter by detection method, discovery year, or host star name, and the actor builds a safe query against the archive so you only download the records you need.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Astronomers and astrophysics researchers | Building exoplanet datasets for analysis |
| Data scientists and ML engineers | Training and benchmarking models on planet data |
| Science educators and students | Classroom datasets and demonstrations |
| Science journalists and communicators | Fact-checking and sourcing discovery stats |
| Hobbyist astronomers and developers | Powering apps, dashboards and visualisations |

### 📋 What the NASA Exoplanet Archive Scraper does

This actor connects to the NASA Exoplanet Archive Table Access Protocol (TAP) endpoint and pulls confirmed exoplanet records from the Planetary Systems table. For each planet it returns the planet name, host star, discovery method, discovery year, discovery facility, orbital period, planet radius and mass in Earth units, semi major axis, system distance in parsecs, stellar temperature, and the number of stars and planets in the system.

You can run it three ways. Leave the filters empty to get the most recently confirmed planets, pick a detection method such as Transit or Microlensing, set a discovery year, or name a single host star to retrieve its entire planetary system. Filters combine, so you can ask for every Microlensing planet confirmed in 2023.

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

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `discoveryMethod` | select | No | Detection technique to filter by. Defaults to Any Method. |
| `discoveryYear` | integer | No | Calendar year a planet was confirmed, for example 2023. |
| `hostStar` | string | No | Exact host star name, case insensitive, for example TOI-1136. |
| `maxItems` | integer | No | Cap on returned records. Free plans are limited to 10. |

Example 1. Most recently confirmed planets.

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

Example 2. Every Microlensing planet confirmed in 2023.

```json
{
  "discoveryMethod": "Microlensing",
  "discoveryYear": 2023,
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** The TAP service can take a few seconds to respond on large queries. Some measurements such as planet mass or orbital period are not published for every planet, so those fields can be empty on individual records while always present for well studied systems.

### 📊 Output

| Field | Description |
|---|---|
| 🪐 `planetName` | Confirmed planet designation |
| ⭐ `hostName` | Host star name |
| 🔬 `discoveryMethod` | Detection technique |
| 📅 `discoveryYear` | Year the planet was confirmed |
| 🔭 `discoveryFacility` | Observatory or mission that found it |
| 🔄 `orbitalPeriodDays` | Orbital period in days |
| 📏 `planetRadiusEarth` | Planet radius in Earth radii |
| ⚖ `planetMassEarth` | Planet mass in Earth masses |
| 🛰 `orbitSemiMajorAxisAu` | Semi major axis in astronomical units |
| 📡 `distanceParsecs` | System distance in parsecs |
| 🌡 `stellarTempK` | Host star effective temperature in Kelvin |
| 🌟 `numStarsInSystem` | Number of stars in the system |
| 🌌 `numPlanetsInSystem` | Number of planets in the system |
| 🔗 `sourceUrl` | Archive overview page for the planet |

Real sample records:

```json
{
  "planetName": "TOI-2384 b",
  "hostName": "TOI-2384",
  "discoveryMethod": "Transit",
  "discoveryYear": 2024,
  "discoveryFacility": "Transiting Exoplanet Survey Satellite (TESS)",
  "orbitalPeriodDays": 2.13570304,
  "planetRadiusEarth": 11.48920522,
  "planetMassEarth": 624.85064816,
  "orbitSemiMajorAxisAu": 0.02793,
  "distanceParsecs": 191.51,
  "stellarTempK": 3943,
  "numStarsInSystem": 1,
  "numPlanetsInSystem": 1,
  "sourceUrl": "https://exoplanetarchive.ipac.caltech.edu/overview/TOI-2384%20b",
  "scrapedAt": "2026-06-04T19:39:25.926Z",
  "error": null
}
```

```json
{
  "planetName": "TOI-4010 b",
  "hostName": "TOI-4010",
  "discoveryMethod": "Transit",
  "discoveryYear": 2023,
  "discoveryFacility": "Transiting Exoplanet Survey Satellite (TESS)",
  "orbitalPeriodDays": 1.348335,
  "planetRadiusEarth": 3.02,
  "planetMassEarth": 11,
  "orbitSemiMajorAxisAu": 0.0229,
  "distanceParsecs": 177.504,
  "stellarTempK": 4960,
  "numStarsInSystem": 1,
  "numPlanetsInSystem": 4,
  "sourceUrl": "https://exoplanetarchive.ipac.caltech.edu/overview/TOI-4010%20b",
  "scrapedAt": "2026-06-04T19:39:25.999Z",
  "error": null
}
```

```json
{
  "planetName": "EPIC 212297394 c",
  "hostName": "EPIC 212297394",
  "discoveryMethod": "Transit",
  "discoveryYear": 2021,
  "discoveryFacility": "K2",
  "orbitalPeriodDays": 5.213965,
  "planetRadiusEarth": 2.27,
  "planetMassEarth": null,
  "orbitSemiMajorAxisAu": null,
  "distanceParsecs": 418.395,
  "stellarTempK": 5171,
  "numStarsInSystem": 1,
  "numPlanetsInSystem": 2,
  "sourceUrl": "https://exoplanetarchive.ipac.caltech.edu/overview/EPIC%20212297394%20c",
  "scrapedAt": "2026-06-04T19:39:26.030Z",
  "error": null
}
```

### ✨ Why choose this Actor

- Pulls directly from the official NASA Exoplanet Archive, the authoritative source for confirmed planets.
- Returns one canonical row per planet using the archive's default parameter set, so you avoid duplicate measurements.
- Builds the query safely from your inputs, with a fixed column whitelist and validated filter values.
- Covers 11 detection methods and 6,298 confirmed planets, refreshed as the archive updates.
- No account or key needed on the source side. Point it at a method, year, or host star and run.

### 📈 How it compares to alternatives

| Approach | Setup effort | Structured output | Filtering | Maintenance |
|---|---|---|---|---|
| This actor | Minutes | Yes, 14 clean fields | Method, year, host star | Handled for you |
| Writing raw TAP queries | Hours of ADQL | Manual parsing | Manual | You maintain it |
| Copying tables by hand | Very high | None | None | Constant rework |

### 🚀 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 Exoplanet Archive Scraper in the Apify Console.
3. Choose a discovery method, year, or host star, or leave the filters empty for recent planets.
4. Set how many records you want and click Start.
5. When the run finishes, open the dataset to review and use your exoplanet records.

### 💼 Business use cases

#### Research and analytics

| Use case | Benefit |
|---|---|
| Building analysis datasets | Start from clean, structured planet records |
| Cross study comparisons | Compare planets across methods and facilities |

#### Data and machine learning

| Use case | Benefit |
|---|---|
| Model training data | Feed orbital and physical parameters into models |
| Feature engineering | Derive density, insolation and other metrics |

#### Education and outreach

| Use case | Benefit |
|---|---|
| Classroom datasets | Hand students real, current planet data |
| Interactive demos | Power teaching visualisations |

#### Media and communication

| Use case | Benefit |
|---|---|
| Story fact-checking | Verify discovery years and counts |
| Data journalism | Source statistics for science coverage |

### 🔌 Automating NASA Exoplanet Archive Scraper

Connect the actor to the tools you already use.

- **Make**: trigger a run and route records into any scenario.
- **Zapier**: pass new planet records into thousands of apps.
- **Slack**: post fresh discoveries to a channel.
- **Airbyte**: load records into your warehouse.
- **GitHub**: schedule runs from your workflows.
- **Google Drive**: archive run results to a shared folder.

### 🌟 Beyond business use cases

- **Research**: assemble custom catalogues for a specific question.
- **Personal**: build a planet tracker or a hobby visualisation.
- **Non-profit**: support open science and public education projects.
- **Experimentation**: prototype astronomy apps and notebooks quickly.

### 🤖 Ask an AI assistant

Drop your dataset into an assistant and ask it to summarise or analyse the planets.

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

### ❓ Frequently Asked Questions

**Where does the data come from?**
The official NASA Exoplanet Archive, queried through its public Table Access Protocol service.

**Which planets are included?**
Confirmed planets from the Planetary Systems table, using the archive's default parameter set so you get one canonical row per planet.

**How many planets are available?**
6,298 confirmed planets at the time of the last update, growing as the archive adds new discoveries.

**Can I filter by detection method?**
Yes. Choose from 11 methods including Transit, Radial Velocity, Microlensing and Imaging, or leave it on Any Method.

**Can I filter by year?**
Yes. Set a discovery year to return only the planets confirmed in that calendar year.

**Can I get every planet around one star?**
Yes. Enter the exact host star name, for example TOI-1136, and the actor returns its whole planetary system.

**Why are some fields empty?**
Not every planet has every measurement published. Fields like planet mass or orbital period can be empty when the archive has no value, while well studied systems are complete.

**Do I need an API key or account for NASA?**
No. The archive's TAP service is public and the actor needs no key on the source side.

**What units are used?**
Radius and mass are in Earth units, orbital period is in days, semi major axis is in astronomical units, distance is in parsecs, and stellar temperature is in Kelvin.

**How many records can I get?**
Free plans are limited to 10 records per run. Paid plans can request up to 1,000,000.

**How current is the data?**
Each run queries the live archive, so results reflect the catalogue at the moment you run it.

**Is this affiliated with NASA?**
No. It is an independent tool that reads only publicly available data from the archive.

### 🔌 Integrate with any app

Every run produces a structured dataset you can pull through the Apify API, connect to webhooks, or wire into your own pipelines and applications.

### 🔗 Recommended Actors

- [NASA NeoWs Asteroids Scraper](https://apify.com/parseforge/nasa-neows-asteroids-scraper)
- [NASA POWER Energy Scraper](https://apify.com/parseforge/nasa-power-energy-scraper)
- [APOD NASA Images Scraper](https://apify.com/parseforge/apod-nasa-images-scraper)
- [SpaceX Launches Scraper](https://apify.com/parseforge/spacex-launches-scraper)
- [arXiv Scraper](https://apify.com/parseforge/arxiv-scraper)

> 💡 **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 NASA Exoplanet Archive. Only publicly available data collected.

# Actor input Schema

## `discoveryMethod` (type: `string`):

Filter confirmed planets by the technique used to detect them. Choose 'Any Method' to include every detection technique.

## `discoveryYear` (type: `integer`):

Optional. Return only planets confirmed in this calendar year (for example 2023). Leave empty to include every year.

## `hostStar` (type: `string`):

Optional. Return only planets orbiting this host star (case insensitive, exact star name, for example 'TOI-1136' or 'Kepler-11'). Leave empty to include every host.

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

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

## Actor input object example

```json
{
  "discoveryMethod": "Any Method",
  "discoveryYear": 2023,
  "hostStar": "TOI-1136",
  "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 = {
    "discoveryMethod": "Any Method",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nasa-exoplanet-archive-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 = {
    "discoveryMethod": "Any Method",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/nasa-exoplanet-archive-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 '{
  "discoveryMethod": "Any Method",
  "maxItems": 10
}' |
apify call parseforge/nasa-exoplanet-archive-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NASA Exoplanet Archive Scraper",
        "description": "Pull confirmed exoplanets straight from the NASA Exoplanet Archive. Each record carries planet name, host star, discovery method and year, orbital period, radius, mass, and distance in parsecs. Filter by detection method, year, or host star for research, teaching, or model building.",
        "version": "0.1",
        "x-build-id": "m6Nj9xFEioueqClG6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~nasa-exoplanet-archive-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-nasa-exoplanet-archive-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~nasa-exoplanet-archive-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-nasa-exoplanet-archive-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~nasa-exoplanet-archive-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-nasa-exoplanet-archive-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": {
                    "discoveryMethod": {
                        "title": "Discovery Method",
                        "enum": [
                            "Any Method",
                            "Transit",
                            "Radial Velocity",
                            "Microlensing",
                            "Imaging",
                            "Transit Timing Variations",
                            "Eclipse Timing Variations",
                            "Orbital Brightness Modulation",
                            "Pulsar Timing",
                            "Pulsation Timing Variations",
                            "Astrometry",
                            "Disk Kinematics"
                        ],
                        "type": "string",
                        "description": "Filter confirmed planets by the technique used to detect them. Choose 'Any Method' to include every detection technique.",
                        "default": "Any Method"
                    },
                    "discoveryYear": {
                        "title": "Discovery Year",
                        "minimum": 1989,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Optional. Return only planets confirmed in this calendar year (for example 2023). Leave empty to include every year."
                    },
                    "hostStar": {
                        "title": "Host Star Name",
                        "type": "string",
                        "description": "Optional. Return only planets orbiting this host star (case insensitive, exact star name, for example 'TOI-1136' or 'Kepler-11'). Leave empty to include every host."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
