# NASA APOD Scraper (`devilscrapes/nasa-apod-scraper`) Actor

Fetch NASA's Astronomy Picture of the Day for any date or date range via the NASA APOD API — title, explanation, image / video URL, HD URL, copyright, media type, date — export to JSON or CSV. A NASA APOD API wrapper; no key needed for small volumes.

- **URL**: https://apify.com/devilscrapes/nasa-apod-scraper.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** News, AI
- **Stats:** 2 total users, 0 monthly users, 75.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## NASA APOD Scraper

**💰 $1.50 / 1 000 results** &nbsp;·&nbsp; pay only for results &nbsp;·&nbsp; no credit card to try

_We do the dirty work so your dataset stays clean._ 😈

Extract NASA's Astronomy Picture of the Day for any date, date range, or random selection. Returns title, explanation, image URL, HD URL, copyright, media type, and date — structured JSON ready for your multimodal RAG pipeline, daily widget, or astronomy image archive bulk export.

</div>

---

### 🎯 What this scrapes

NASA's Astronomy Picture of the Day (apod.nasa.gov) has been publishing one space image or video per day since 1995 — over 10,000 beautifully captioned entries spanning galaxies, nebulae, rocket launches, and solar phenomena. This Actor wraps the official NASA APOD API (api.nasa.gov/planetary/apod), supports single-date, date-range, and random-pick modes, and delivers one clean structured row per entry.

The archive is free to access but bulk historical exports still need throttling, retry logic, and clean schema handling across 30 years of format variation (video days, absent copyright fields, HD URL gaps). We absorb all of that so you get consistent rows every time.

Target use cases span the full spectrum: indie developers shipping a daily space photo widget, researchers building a multimodal RAG dataset with captions, educators building astronomy lesson apps, and data artists exporting the nasa images dataset for print-on-demand posters.

### 🔥 Features

- 🛡️ **Browser fingerprint rotation** — `curl-cffi` impersonates real Chrome / Firefox / Safari TLS handshakes so the target sees a browser, not a Python script.
- 🌐 **Residential proxy rotation** via Apify Proxy — fresh session and exit IP whenever the target pushes back.
- 🔁 **Retries with exponential backoff** on `408 / 429 / 5xx` — up to 5 attempts per request, `Retry-After` honoured.
- 🧱 **Rate-limit-aware pacing** — when the API throttles us, we slow down and keep going rather than crashing out.
- 🧊 **Clean, typed dataset rows** — Pydantic-validated, ISO-8601 timestamps, stable IDs, JSON / CSV / Excel export straight from the Apify Console.
- 💰 **Pay-Per-Event pricing** — you only pay for results that land in your dataset. No data, no charge.
- 🎞️ **Video-day handling** — `media_type` field distinguishes images from YouTube / Vimeo embeds; `thumbnail_url` included when NASA provides it.
- 📅 **Full archive support** — date range mode lets you pull the entire astronomy image archive in one run; earliest entry is 1995-06-16.

### 💡 Use cases

- **Multimodal RAG dataset** — bulk-export the APOD archive as image-caption pairs to build or evaluate a vision-LLM retrieval pipeline.
- **Daily space photo widget** — run on a schedule, pull today's entry, push to your iOS / Android / desktop wallpaper service or Telegram bot.
- **Astronomy lesson app** — backfill 10+ years of entries into a CMS, pair captions with AI-generated quiz questions.
- **Generative art seeds** — feed APOD images and captions into a multimodal model or Stable Diffusion workflow.
- **Print-on-demand posters** — harvest HD image URLs from the nasa images dataset and generate high-resolution wall art.
- **Newsletter automation** — scheduled daily pull delivers title, explanation, and image URL to your email or Slack.

### ⚙️ How to use it

1. Click **Try for free** at the top of the page.
2. Choose a mode: **Today**, **Single date**, **Date range**, or **Random N**.
3. Optionally supply your own NASA API key (free at api.nasa.gov) to lift the shared-key rate cap.
4. Click **Start**. Output streams into the run's dataset in real time.
5. Export from **Storage → Dataset** as JSON, CSV, or Excel — or pull via the Apify REST API.

For bulk astronomy image archive exports, use **Date range** mode with `startDate` and `endDate`. The run will page through the range, retry on throttles, and deliver one row per day.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `mode` | `string` | no | `today` | `today`, `single_date`, `range`, or `random`. |
| `date` | `string` | no | — | ISO date (YYYY-MM-DD). Used when `mode=single_date`. Earliest: 1995-06-16. |
| `startDate` | `string` | no | — | ISO date (YYYY-MM-DD). Range start, inclusive. |
| `endDate` | `string` | no | — | ISO date (YYYY-MM-DD). Range end, inclusive. |
| `count` | `integer` | no | `5` | How many random APODs. Used when `mode=random`. |
| `apiKey` | `string` | no | — | Your personal NASA API key. Without one, `DEMO_KEY` is used (30 req/hour, 50 req/day). |
| `thumbsForVideos` | `boolean` | no | `true` | Adds `thumbnail_url` for video APODs (YouTube / Vimeo). |
| `proxyConfiguration` | `object` | no | `{"useApifyProxy": false}` | Proxy settings. Increase resilience on long bulk runs by enabling Apify Proxy. |

#### Example input

```json
{
  "mode": "range",
  "startDate": "2024-01-01",
  "endDate": "2024-01-31",
  "thumbsForVideos": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### 📤 Output

One dataset row per APOD entry.

| Field | Type | Notes |
|---|---|---|
| `date` | `string` | APOD date (YYYY-MM-DD). |
| `title` | `string` | Title of the APOD entry. |
| `explanation` | `string` | Full curator-written description. |
| `url` | `string` | Primary image or video URL. |
| `hdurl` | `string \| null` | HD image URL when available. |
| `thumbnail_url` | `string \| null` | Video thumbnail when NASA provides it. |
| `media_type` | `string` | `image` or `video`. |
| `copyright` | `string \| null` | Credit / copyright string. Absent for public-domain NASA imagery. |
| `service_version` | `string \| null` | NASA API service version tag. |
| `apod_url` | `string` | Canonical APOD page URL on apod.nasa.gov. |
| `scraped_at` | `string` | ISO-8601 timestamp of when this row was recorded. |

#### Example output

```json
{
  "date": "2026-05-15",
  "title": "Spiral Galaxy NGC 1232",
  "explanation": "One of the most photogenic galaxies in the southern sky...",
  "media_type": "image",
  "url": "https://apod.nasa.gov/apod/image/2605/NGC1232.jpg",
  "hdurl": "https://apod.nasa.gov/apod/image/2605/NGC1232_full.jpg",
  "copyright": "ESO; J. Spyromilio",
  "apod_url": "https://apod.nasa.gov/apod/ap260515.html",
  "scraped_at": "2026-05-15T09:12:34Z"
}
```

### 💰 Pricing

Pay-Per-Event — you only pay when these events fire:

| Event | USD | What it means |
|---|---:|---|
| `actor-start` | $0.005 | One-off warm-up charge per run |
| `result` | $0.0015 | Per dataset item delivered |

**1,000 results ≈ $1.50.** No subscription, no minimum. New Apify accounts start with $5 of free credit — enough to pull several years of APOD entries before spending a cent.

### 🚧 Limitations

- The APOD archive contains one entry per day since 1995-06-16, giving roughly 11,000 total entries. It is not a million-image dataset — pitch it as a curated multimodal-RAG corpus or fine-tuning seed, not as a large-scale training set.
- We surface image and HD URLs as-is from NASA's API. We do not proxy or cache images ourselves — the buyer is responsible for downloading from the target host.
- `thumbnail_url` is available only for video entries where NASA includes it; not all video APODs carry a thumbnail.
- A small share of APOD entries feature imagery by external photographers who retain their own copyright. The `copyright` field is present on every row — downstream use must respect it.

### ❓ FAQ

**Do I need a NASA API key?**

Not to get started. The `DEMO_KEY` lets you fetch a handful of entries to verify the data shape. For bulk astronomy image archive exports or scheduled daily runs, register a free personal key at api.nasa.gov — it raises the per-hour cap significantly and avoids sharing quota with other users of the demo key.

**What is the astronomy picture of the day API and how does this Actor wrap it?**

NASA publishes a JSON endpoint at `api.nasa.gov/planetary/apod` — the official astronomy picture of the day API. This Actor calls that endpoint, handles pagination for date ranges, manages rate-limit retries, normalises the response schema across 30 years of format variation, and writes Pydantic-validated rows to an Apify dataset. You get a clean, queryable table without touching the raw API.

**Can I use this as a multimodal RAG dataset?**

Yes. Each row contains the title, the full curator-written explanation (your caption), and both a standard-resolution and HD image URL. That is a complete image-caption pair. Export as JSON, upload to HuggingFace, and you have an astronomy domain corpus ready for semantic search or vision-LLM evaluation.

**Why do some rows have `media_type: video`?**

Roughly 10–15% of APOD entries are videos (rocket launches, solar animations, telescope time-lapses). The `url` field points to YouTube or Vimeo; `thumbnail_url` contains the video thumbnail when NASA provides it. Filter `media_type == "image"` if you need images-only.

**What is the earliest APOD entry?**

1995-06-16. Total archive size as of mid-2026 is approximately 11,000 entries.

**Can I bulk-download the actual image files?**

We provide the URL — pair this Actor with a generic file-download Actor or a curl loop to retrieve the image bytes. We intentionally do not bundle image download to keep the pricing predictable.

### 💬 Your feedback

Spotted a bug, hit a rate-limit edge case, or need a new field? Open an issue on the Actor's **Issues** tab in Apify Console — we ship fixes weekly and read every report.

***

<div align="center">

Built by **[Devil Scrapes](https://apify.com/DevilScrapes)** 😈 — a small fleet of
opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

</div>

# Actor input Schema

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

How to choose APODs.

## `date` (type: `string`):

ISO date (YYYY-MM-DD). The earliest APOD is 1995-06-16.

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

ISO date (YYYY-MM-DD). Range inclusive on both ends.

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

ISO date (YYYY-MM-DD).

## `count` (type: `integer`):

How many random APODs.

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

Get one at api.nasa.gov. Without one we use <code>DEMO\_KEY</code> (30 req/hour, 50 req/day).

## `thumbsForVideos` (type: `boolean`):

Adds `thumbnail_url` for video APODs (YouTube/Vimeo).

## `proxyConfiguration` (type: `object`):

NASA's API is open. Proxy optional.

## Actor input object example

```json
{
  "mode": "today",
  "date": "2024-01-01",
  "startDate": "2026-01-01",
  "endDate": "2026-01-07",
  "count": 5,
  "thumbsForVideos": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/nasa-apod-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 = { "proxyConfiguration": { "useApifyProxy": False } }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NASA APOD Scraper",
        "description": "Fetch NASA's Astronomy Picture of the Day for any date or date range via the NASA APOD API — title, explanation, image / video URL, HD URL, copyright, media type, date — export to JSON or CSV. A NASA APOD API wrapper; no key needed for small volumes.",
        "version": "0.4",
        "x-build-id": "ceBgZbVkxBagmVlA7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~nasa-apod-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-nasa-apod-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/devilscrapes~nasa-apod-scraper/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-nasa-apod-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/devilscrapes~nasa-apod-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-nasa-apod-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "today",
                            "single_date",
                            "range",
                            "random"
                        ],
                        "type": "string",
                        "description": "How to choose APODs.",
                        "default": "today"
                    },
                    "date": {
                        "title": "Date (when mode=single_date)",
                        "type": "string",
                        "description": "ISO date (YYYY-MM-DD). The earliest APOD is 1995-06-16."
                    },
                    "startDate": {
                        "title": "Start date (when mode=range)",
                        "type": "string",
                        "description": "ISO date (YYYY-MM-DD). Range inclusive on both ends."
                    },
                    "endDate": {
                        "title": "End date (when mode=range)",
                        "type": "string",
                        "description": "ISO date (YYYY-MM-DD)."
                    },
                    "count": {
                        "title": "Random count (when mode=random)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "How many random APODs.",
                        "default": 5
                    },
                    "apiKey": {
                        "title": "NASA API key (optional)",
                        "type": "string",
                        "description": "Get one at api.nasa.gov. Without one we use <code>DEMO_KEY</code> (30 req/hour, 50 req/day)."
                    },
                    "thumbsForVideos": {
                        "title": "Include video thumbnails",
                        "type": "boolean",
                        "description": "Adds `thumbnail_url` for video APODs (YouTube/Vimeo).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "NASA's API is open. Proxy optional.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```