# NASA Near-Earth Asteroids (NeoWs) Scraper (`parseforge/nasa-neows-asteroids-scraper`) Actor

Pull near-earth asteroid data from NASA NeoWs (Near Earth Object Web Service). Returns asteroid name, designation, hazardous flag, estimated diameter, close-approach date, miss-distance, relative velocity, orbiting body, and orbital data. Filter by date range or browse catalog.

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

## Pricing

from $14.00 / 1,000 result items

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 Near-Earth Asteroids (NeoWs) Scraper

> 🚀 **Pull near-earth asteroid data from NASA's NeoWs: name, hazardous flag, diameter, close-approach date, miss-distance, velocity.**

> 🕒 **Last updated:** 2026-05-07 · **📊 30 fields** per record · **~28,000 known NEOs** · close-approach feeds + full catalog browse · hazardous flag, diameter, miss-distance, orbital data

The **NASA Near-Earth Asteroids Scraper** pulls asteroid data from NASA's Near Earth Object Web Service (NeoWs). Output includes asteroid name, designation, potentially-hazardous flag, estimated diameter (min/max in meters and miles), close-approach date, miss-distance (km, lunar, AU), relative velocity, orbiting body, absolute magnitude, and orbital determination data.

NASA tracks **~28,000 known near-earth objects** with close approaches updated daily. The Actor offers two modes: a date-range feed (asteroids approaching Earth in a 7-day window) and a full catalog browse mode. Filter to potentially-hazardous asteroids (PHAs) only, or include all NEOs.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Astronomy enthusiasts, science journalists, planetary defense researchers, ML pipelines, educators, museum exhibits | Astronomy newsletters, science-news features, planetary-defense awareness, classroom material, ML training on orbital mechanics |

---

### 📋 What the NASA Near-Earth Asteroids (NeoWs) Scraper does

Five filtering workflows in a single run:

- 📅 **Close-approach feed.** Asteroids passing Earth in a 7-day window.
- 📚 **Catalog browse.** Paginate the full NeoWs catalog of 28,000+ NEOs.
- ⚠️ **Hazardous filter.** Restrict to potentially-hazardous asteroids (PHAs).
- 📐 **Multi-unit data.** Diameter in meters/km/miles, velocity in km/s and km/h, miss-distance in km/lunar/AU.
- 🔬 **Orbital data.** Orbit determination, observation count, first/last observation date.

> 💡 **Why it matters:** clean, server-side filtering and fresh data on every run.

---
### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan up to 1,000,000.</td></tr>
<tr><td><code>mode</code></td><td>string</td><td><code>"feed"</code></td><td>feed (date range) or browse (full catalog).</td></tr>
<tr><td><code>startDate</code></td><td>string</td><td><code>""</code></td><td>YYYY-MM-DD. Range max 7 days for feed.</td></tr>
<tr><td><code>endDate</code></td><td>string</td><td><code>""</code></td><td>YYYY-MM-DD. Empty = same as start.</td></tr>
<tr><td><code>hazardousOnly</code></td><td>boolean</td><td><code>false</code></td><td>Restrict to PHAs.</td></tr>
</tbody>
</table>

**Example: asteroids passing Earth this week.**

```json
{
    "maxItems": 100,
    "mode": "feed",
    "startDate": "2026-05-01",
    "endDate": "2026-05-07"
}
````

**Example: first 100 PHAs in catalog.**

```json
{
    "maxItems": 100,
    "mode": "browse",
    "hazardousOnly": true
}
```

***

### 📊 Output

Each record contains **30 fields**. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 📛 `name` | string | `"(2003 GR22)"` |
| 🆔 `designation` | string | null | `"2003 GR22"` |
| 🆔 `neoReferenceId` | string | `"3152318"` |
| ⚠️ `isPotentiallyHazardous` | boolean | `false` |
| ⚠️ `isSentryObject` | boolean | `false` |
| 🔆 `absoluteMagnitudeH` | number | `22.17` |
| 📐 `diameterMinMeters` | number | `85.13` |
| 📐 `diameterMaxMeters` | number | `190.36` |
| 📅 `closeApproachDate` | string | `"2026-04-01"` |
| 📅 `closeApproachDateFull` | string | `"2026-Apr-01 12:00"` |
| 🚀 `relativeVelocityKms` | number | `12.78` |
| 📏 `missDistanceKm` | number | `41200000` |
| 📏 `missDistanceLunar` | number | `107.16` |
| 🌐 `orbitingBody` | string | `"Earth"` |
| 🔗 `nasaJplUrl` | string | `"https://ssd.jpl.nasa.gov/sbdb.cgi?sstr=3152318"` |

#### 📦 Sample records

<details>
<summary><strong>☄️ NEO close approach</strong></summary>

```json
{"name":"(2003 GR22)","neoReferenceId":"3152318","isPotentiallyHazardous":false,"absoluteMagnitudeH":22.17,"diameterMinMeters":85.13,"diameterMaxMeters":190.36,"closeApproachDate":"2026-04-01","relativeVelocityKms":12.78,"missDistanceKm":41200000}
```

</details>

<details>
<summary><strong>⚠️ Hazardous asteroid</strong></summary>

```json
{"name":"433 Eros (A898 PA)","isPotentiallyHazardous":true,"absoluteMagnitudeH":11.16,"diameterMinMeters":22000,"diameterMaxMeters":49200}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🛰️ | **NASA-authoritative.** Direct from NASA's Near Earth Object Web Service. |
| ⚠️ | **PHA detection.** Built-in filter for potentially-hazardous asteroids. |
| 📐 | **Multi-unit output.** Meters/km/miles, km/s and km/h, km/lunar/AU. |
| 🔬 | **Full orbital data.** Orbit determination, observation history. |
| ⚡ | **Fast.** 100 records in under 30 seconds. |

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ This Actor** | $5 free credit | **~28,000** NEOs | Live per run | date range, browse, hazardous filter | ⚡ 2 min |
| Manual NASA browse | Free | Manual | Live | Web filters | 🕒 Manual |
| ESA SSA portal | Free | Different scope | Live | Yes | 🐢 Account |
| Raw NASA dumps | Free | All | Periodic | Bulk only | 🐢 ETL |

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Find the NASA Near-Earth Asteroids (NeoWs) Scraper on the Apify Store.
3. 🎯 **Set input.** Pick filters and `maxItems`.
4. 🚀 **Run it.** Click **Start**.
5. 📥 **Download.** Grab results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🔭 Astronomy + Science

- Daily close-approach alerts
- Newsletter content on asteroids
- Planetary-defense awareness
- Citizen-science data feeds

</td>
<td width="50%" valign="top">

#### 📰 Science Journalism

- "Asteroid passes today" articles
- Year-in-review NEO summaries
- Hazardous-NEO investigations
- Visualizations and infographics

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🎓 Education

- Classroom astronomy content
- Museum exhibit data
- Reproducible astronomy snapshots
- Course materials with current data

</td>
<td width="50%" valign="top">

#### 🤖 ML + Research

- Train orbital-prediction models
- Build NEO-classification features
- Power planetary-defense dashboards
- Cross-train with survey data

</td>
</tr>
</table>

***

### 🔌 Automating NASA Near-Earth Asteroids (NeoWs) Scraper

Control the scraper programmatically:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval.

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Astronomy education datasets
- Reproducible NEO snapshots
- Course materials
- Cross-survey orbital studies

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal asteroid dashboards
- Sci-fi worldbuilding research
- Astronomy hobbyist data
- Newsletter content

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Planetary-defense awareness
- Astronomy education outreach
- Open-data contributions
- Civic science journalism

</td>
<td width="50%">

#### 🧪 Experimentation

- Train orbital-prediction models
- Prototype NEO-tracking apps
- Build asteroid visualizations
- Test orbital-mechanics libraries

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20NASA%20Near-Earth%20Asteroids%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20NASA%20Near-Earth%20Asteroids%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20NASA%20Near-Earth%20Asteroids%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20NASA%20Near-Earth%20Asteroids%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick mode (feed for date range or browse for full catalog). The Actor calls NASA's NeoWs API and emits one record per asteroid.

#### ⚠️ What is a potentially-hazardous asteroid?

An NEO with absolute magnitude H ≤ 22 and minimum orbit intersection distance (MOID) ≤ 0.05 AU. The Actor exposes the NASA-computed flag directly.

#### 📊 How many fields per record?

30, including name, designation, hazardous flag, diameter ranges, close-approach data, velocity, miss-distance, orbital determination, and JPL URL.

#### 📅 What's the maximum feed date range?

NeoWs limits feed queries to 7 days. Use browse mode for catalog-wide pulls.

#### 📐 What does diameter range mean?

NASA estimates minimum and maximum diameter from absolute magnitude and an assumed albedo range.

#### 🔁 Can I schedule runs?

Yes. Schedule daily for fresh close-approach feeds.

#### ⚖️ Is this data free?

Yes. NASA publishes NeoWs under public-domain. The actor can use the DEMO\_KEY rate-limited public key by default.

#### 💳 Do I need a paid Apify plan?

No. The free plan covers preview runs.

#### 🆘 What if a run fails?

Apify retries transient errors. NASA's DEMO\_KEY rate-limits at 30 req/hr; for high-volume runs, use the NASA\_API\_KEY env var.

#### ☄️ Are comets included?

No. NeoWs focuses on asteroids. For comets, ESA and JPL Horizons offer alternative endpoints.

***

### 🔌 Integrate with any app

NASA Near-Earth Asteroids (NeoWs) Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets to Sheets

***

### 🔗 Recommended Actors

- [**🚀 SpaceX Launches**](https://apify.com/parseforge/spacex-launches-scraper) - Every SpaceX launch with rocket and payload
- [**🌍 REST Countries**](https://apify.com/parseforge/rest-countries-scraper) - Country reference data
- [**🌐 Wikidata Entity Search**](https://apify.com/parseforge/wikidata-entity-search-scraper) - 100M+ open knowledge-graph entities
- [**🌍 Open-Meteo Weather**](https://apify.com/parseforge/open-meteo-weather-scraper) - Global weather forecasts
- [**📚 Project Gutenberg Books**](https://apify.com/parseforge/project-gutenberg-books-scraper) - 75,000+ free public-domain books

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the National Aeronautics and Space Administration (NASA), JPL, or any astronomical observatory. All trademarks mentioned are the property of their respective owners. Only publicly available open data is collected.

# Actor input Schema

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

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

## `mode` (type: `string`):

feed = asteroids approaching Earth in date range; browse = paginate full catalog.

## `startDate` (type: `string`):

YYYY-MM-DD. Range max 7 days.

## `endDate` (type: `string`):

YYYY-MM-DD. Empty = same as start.

## `hazardousOnly` (type: `boolean`):

Filter to only PHAs (potentially hazardous asteroids).

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "feed",
  "startDate": "2026-05-01",
  "endDate": "2026-05-07",
  "hazardousOnly": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "maxItems": 10,
    "mode": "feed",
    "startDate": "2026-05-01",
    "endDate": "2026-05-07"
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "mode": "feed",
    "startDate": "2026-05-01",
    "endDate": "2026-05-07",
}

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

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "mode": "feed",
  "startDate": "2026-05-01",
  "endDate": "2026-05-07"
}' |
apify call parseforge/nasa-neows-asteroids-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NASA Near-Earth Asteroids (NeoWs) Scraper",
        "description": "Pull near-earth asteroid data from NASA NeoWs (Near Earth Object Web Service). Returns asteroid name, designation, hazardous flag, estimated diameter, close-approach date, miss-distance, relative velocity, orbiting body, and orbital data. Filter by date range or browse catalog.",
        "version": "1.0",
        "x-build-id": "L4aoHiftbLZkuCayB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~nasa-neows-asteroids-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-nasa-neows-asteroids-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-neows-asteroids-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-nasa-neows-asteroids-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-neows-asteroids-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-nasa-neows-asteroids-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "feed",
                            "browse"
                        ],
                        "type": "string",
                        "description": "feed = asteroids approaching Earth in date range; browse = paginate full catalog.",
                        "default": "feed"
                    },
                    "startDate": {
                        "title": "Start date (feed mode)",
                        "type": "string",
                        "description": "YYYY-MM-DD. Range max 7 days."
                    },
                    "endDate": {
                        "title": "End date (feed mode)",
                        "type": "string",
                        "description": "YYYY-MM-DD. Empty = same as start."
                    },
                    "hazardousOnly": {
                        "title": "Potentially hazardous only",
                        "type": "boolean",
                        "description": "Filter to only PHAs (potentially hazardous asteroids).",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```