# NASA Near Earth Objects Scraper (`compute-edge/nasa-neo-scraper`) Actor

Scrape Near Earth Object (NEO) asteroid data from NASA NeoWs API including close approach dates, miss distances, estimated diameters, hazard status, and orbital information.

- **URL**: https://apify.com/compute-edge/nasa-neo-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## NASA Near-Earth Object (Asteroid) Scraper

### What does NASA Near-Earth Object Scraper do?

The **NASA Near-Earth Object Scraper** extracts comprehensive asteroid and comet data from NASA's NeoWs (Near Earth Object Web Service) API. This Actor fetches information about near-Earth objects including size estimates, orbital characteristics, close approach distances, and hazard assessments.

With this Actor, you can:
- **Browse all NEOs** — Paginate through NASA's complete catalog of near-Earth objects
- **Get weekly approach feed** — Fetch asteroids approaching Earth within a specific date range
- **Extract detailed data** — Size, speed, distance at closest approach, hazard status, and more

This Actor uses a direct API wrapper approach (no web scraping) for reliable, real-time data access. Perfect for researchers, scientists, data journalists, space enthusiasts, and applications requiring asteroid tracking data.

### Why use NASA Near-Earth Object Scraper?

**Business and research use cases:**
- **Astronomy research & education** — Compile asteroid datasets for academic papers, student projects, and science outreach
- **Space monitoring platforms** — Feed live near-Earth object data into dashboards or alerting systems
- **Data journalism** — Report on potentially hazardous asteroids and close approaches
- **Scientific visualization** — Create interactive maps and charts of asteroid trajectories and approach distances
- **AI training datasets** — Use NASA's official data to train models for space object detection or classification
- **Scheduled monitoring** — Set up automated workflows to track new or hazardous near-Earth objects

**Key advantages:**
- **Official NASA data** — Direct access to authoritative, peer-reviewed asteroid data
- **No authentication headaches** — Free DEMO_KEY for testing; users register once at NASA for production keys
- **Real-time updates** — Latest close approach data and orbital parameters
- **Structured JSON output** — Ready for analysis, integration, or further processing
- **Reliable and stable** — API maintained by NASA's Planetary Defense Coordination Office
- **Scalable on Apify** — Schedule recurring runs, monitor performance, and integrate with downstream tools

### How to use NASA Near-Earth Object Scraper

#### Step 1: Choose your mode

The Actor supports two modes:

1. **Browse Mode** (default) — Paginate through all cataloged NEOs. Useful for downloading the entire NEO database or sampling asteroids.
2. **Feed Mode** — Fetch asteroids approaching Earth within a 7-day window. Useful for monitoring upcoming close approaches.

#### Step 2: Set up input

**For Browse Mode:**
- Leave `Mode` as **"Browse All NEOs"**
- Set `Max Results` to the number of asteroids you want (1–5000)
- Leave `Start Date` empty

**For Feed Mode:**
- Set `Mode` to **"Weekly Approach Feed"**
- Set `Start Date` (YYYY-MM-DD format) — for example, `2024-01-15` fetches asteroids approaching Jan 15–21, 2024
- Leave `Max Results` empty (it's ignored in this mode)

#### Step 3: Provide or use default API key

- **Testing:** Use the default `DEMO_KEY` (rate-limited to 30 requests/hour)
- **Production:** Register free at [https://api.nasa.gov/](https://api.nasa.gov/) to get your personal API key with higher rate limits

#### Step 4: Run and download

Click **Start** and wait for results. Download your dataset as JSON, CSV, or Excel via the Output tab.

### Input

#### Input Schema

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `apiKey` | string | No | DEMO_KEY | NASA API key from [https://api.nasa.gov/](https://api.nasa.gov/). DEMO_KEY is rate-limited. |
| `feedMode` | enum | No | browse | Mode: `browse` (all NEOs) or `feed` (weekly approach). |
| `startDate` | string | No | (empty) | Start date for feed mode (YYYY-MM-DD format). Ignored in browse mode. |
| `maxResults` | integer | No | 100 | Maximum NEOs to return in browse mode (1–5000). Ignored in feed mode. |

#### Example Input (Browse Mode)

```json
{
  "apiKey": "DEMO_KEY",
  "feedMode": "browse",
  "maxResults": 50
}
````

#### Example Input (Feed Mode)

```json
{
  "apiKey": "DEMO_KEY",
  "feedMode": "feed",
  "startDate": "2024-01-15"
}
```

### Output

#### Output Fields

Each asteroid record includes:

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | NASA's unique NEO identifier (e.g., "2000433") |
| `name` | string | Asteroid/comet name (e.g., "433 Eros (A898 PA)") |
| `nasaJplUrl` | string | Link to NASA JPL's Small-Body Node database |
| `absoluteMagnitude` | number | Brightness magnitude (lower = brighter) |
| `estimatedDiameterMinKm` | number | Minimum size estimate (km) |
| `estimatedDiameterMaxKm` | number | Maximum size estimate (km) |
| `isPotentiallyHazardous` | boolean | Marked as potentially hazardous (NASA criteria) |
| `isSentryObject` | boolean | Listed in NASA's Sentry monitoring system |
| `closeApproachDate` | string | Date of closest approach (YYYY-MM-DD) |
| `closeApproachVelocityKmh` | string | Velocity relative to Earth (km/h) |
| `missDistanceKm` | string | Distance at closest approach (km) |
| `orbitingBody` | string | What the object orbits (typically "Earth") |

#### Example Output

```json
[
  {
    "id": "2000433",
    "name": "433 Eros (A898 PA)",
    "nasaJplUrl": "http://ssd.jpl.nasa.gov/sbdb.cgi?sstr=2000433",
    "absoluteMagnitude": 10.31,
    "estimatedDiameterMinKm": 21.7,
    "estimatedDiameterMaxKm": 48.6,
    "isPotentiallyHazardous": false,
    "isSentryObject": false,
    "closeApproachDate": "1975-06-19",
    "closeApproachVelocityKmh": "13089.0",
    "missDistanceKm": "49582150.0",
    "orbitingBody": "Earth"
  }
]
```

### Data Table

| Asteroid ID | Name | Diameter (km) | Hazardous | Closest Approach (km) | Speed (km/h) |
|-------------|------|---------------|-----------|------------------------|-------------|
| 2000433 | 433 Eros | 21.7–48.6 | No | 49,582,150 | 13,089 |
| 2000719 | 719 Albert | 13.0–29.0 | Yes | 5,500,000 | 18,970 |

### Pricing / Cost Estimation

**This Actor uses a direct API approach — no HTML parsing overhead.**

- **Per-result cost**: $0.001 per asteroid record
- **Typical run costs**:
  - 50 asteroids (browse mode) ≈ $0.05
  - 100 asteroids ≈ $0.10
  - 5,000 asteroids ≈ $5.00
  - Weekly feed (~200 asteroids) ≈ $0.20

**Free tier benefits:**

- DEMO\_KEY supports up to 30 requests/hour — ideal for testing
- Register free at <https://api.nasa.gov/> for higher limits

**How to optimize cost:**

- Start with `maxResults: 50` to test before larger runs
- Use feed mode to fetch only approaching asteroids (typically 10–50 per week)
- Schedule runs during off-peak hours if on a usage-based plan

### Tips & Advanced Options

#### Using a Custom NASA API Key

1. Register free at <https://api.nasa.gov/> with your email
2. You'll receive an API key instantly (look for `API_KEY` in the confirmation email)
3. Paste your key into the `apiKey` input field in the Actor
4. Your key grants 1,000 requests per hour (vs. 30 for DEMO\_KEY)

#### Feed Mode: Monitoring Upcoming Approaches

Use feed mode to monitor asteroids approaching Earth in a specific week:

```json
{
  "apiKey": "YOUR_API_KEY",
  "feedMode": "feed",
  "startDate": "2024-12-25"
}
```

This fetches all asteroids approaching Dec 25–31, 2024. Great for holiday close-approach monitoring!

#### Browse Mode: Sampling the Entire Catalog

```json
{
  "apiKey": "YOUR_API_KEY",
  "feedMode": "browse",
  "maxResults": 1000
}
```

Fetches the first 1,000 asteroids in NASA's catalog. You can repeat with different `maxResults` to download the complete database in batches.

#### Processing Output in Workflows

Export results as:

- **JSON** — For APIs and direct integration
- **CSV** — For Excel/Sheets analysis
- **HTML** — For web publishing

Then feed into:

- **Data visualization** — Create charts of asteroid sizes, distances, speeds
- **Alert systems** — Flag potentially hazardous asteroids
- **Database** — Bulk-import into your own systems

### FAQ, Disclaimers & Support

#### Legal Disclaimer

This Actor uses publicly available NASA data via the official NeoWs API. Data is free to use under NASA's open data policy. Always attribute data to NASA and link to <https://api.nasa.gov/> in any publication.

#### Frequently Asked Questions

**Q: What if I get a rate limit error?**
A: DEMO\_KEY is limited to 30 requests/hour. Register for a free API key at <https://api.nasa.gov/> for 1,000 requests/hour.

**Q: How often is the NEO data updated?**
A: NASA updates close approach data continuously as new observations arrive. The NEO database is maintained by the Planetary Defense Coordination Office.

**Q: Can I get data for a specific asteroid?**
A: This Actor returns paginated results. To find a specific asteroid by name, download a dataset and filter locally, or contact us for a custom solution.

**Q: What does "potentially hazardous" mean?**
A: NASA classifies an asteroid as potentially hazardous if it's larger than 25 meters AND passes within 7.5 million km of Earth. This does NOT mean an impact is likely—just that it meets NASA's monitoring criteria.

**Q: How far back does the data go?**
A: The close approach data covers historical records and future predictions. Dates range from the 1900s to 2200+.

**Q: Why are some asteroids missing a close approach date?**
A: The Actor returns the most recent/nearest close approach. If no recent approach is recorded, the date field may be null.

#### Known Limitations

- Feed mode fetches data within a 7-day window only (NASA API limit)
- DEMO\_KEY has a 30 req/hour rate limit
- Largest browse query returns up to 5,000 results

#### Getting Help

- **Issues or bugs?** Report them in the [Issues](https://github.com/apify-actor-projects/nasa-neo-scraper/issues) tab
- **Need a custom scraper?** We offer tailored solutions. Contact us via the support link in the Apify Console
- **Questions about the data?** Visit <https://api.nasa.gov/> or <https://cneos.jpl.nasa.gov/>

***

**Data source:** NASA Near Earth Object Web Service (NeoWs)
**Updated:** Data refreshed daily from NASA observations
**License:** Public domain (NASA)

# Actor input Schema

## `apiKey` (type: `string`):

Free API key from https://api.nasa.gov/ — use DEMO\_KEY for testing (rate-limited).

## `feedMode` (type: `string`):

Browse all NEOs or fetch weekly approach feed.

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

Start of 7-day window for feed mode (YYYY-MM-DD).

## `maxResults` (type: `integer`):

Maximum number of NEOs to return in browse mode.

## Actor input object example

```json
{
  "apiKey": "DEMO_KEY",
  "feedMode": "browse",
  "startDate": "",
  "maxResults": 100
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/nasa-neo-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/nasa-neo-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 '{}' |
apify call compute-edge/nasa-neo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NASA Near Earth Objects Scraper",
        "description": "Scrape Near Earth Object (NEO) asteroid data from NASA NeoWs API including close approach dates, miss distances, estimated diameters, hazard status, and orbital information.",
        "version": "0.0",
        "x-build-id": "hemJQrcaxOZ9FaslM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~nasa-neo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-nasa-neo-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/compute-edge~nasa-neo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-nasa-neo-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/compute-edge~nasa-neo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-nasa-neo-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": {
                    "apiKey": {
                        "title": "NASA API Key",
                        "type": "string",
                        "description": "Free API key from https://api.nasa.gov/ — use DEMO_KEY for testing (rate-limited).",
                        "default": "DEMO_KEY"
                    },
                    "feedMode": {
                        "title": "Mode",
                        "enum": [
                            "browse",
                            "feed"
                        ],
                        "type": "string",
                        "description": "Browse all NEOs or fetch weekly approach feed.",
                        "default": "browse"
                    },
                    "startDate": {
                        "title": "Start Date (feed mode only)",
                        "type": "string",
                        "description": "Start of 7-day window for feed mode (YYYY-MM-DD).",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results (browse mode only)",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of NEOs to return in browse mode.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```