# USNO Astronomical Almanac Scraper (`parseforge/usno-astronomical-almanac-scraper`) Actor

Pull sun and moon rise, set, and transit times from the US Naval Observatory for any date and place. Returns moon phase, fraction illuminated, nearest phase date, civil twilight, and solar noon by latitude and longitude. Handy for photography planning, sailing, and field research.

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

## Pricing

from $4.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🌅 USNO Astronomical Almanac Scraper

> 🚀 **Pull sun and moon almanac data in seconds.** Get rise, set, and transit times, twilight, moon phase, and illumination from the US Naval Observatory for any date and place on Earth.

> 🕒 **Last updated:** 2026-06-08 · **📊 Up to 24 fields** per record · one record per location per date · global coverage

Turn the US Naval Observatory (USNO) almanac into clean, structured records you can drop into a photography planner, a sailing log, a field-research dataset, or an astronomy app. Give it one or more `latitude,longitude` points and a date or date range, and it returns the sun and moon events for each day at each place.

Coverage is global. The USNO rise/set/transit service computes events for any coordinate between latitude -90 and 90 and longitude -180 and 180, including polar day and polar night notes when the sun or moon never rises or sets. Times can be returned in UTC or shifted to any time-zone offset, with an optional daylight saving flag.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Photographers and videographers | Plan golden hour, blue hour, and moonlit shoots |
| Sailors, pilots, and surveyors | Look up twilight and solar noon for navigation |
| Field researchers and ecologists | Tie observations to sun and moon timing |
| Astronomy app and bot developers | Seed a rise/set engine without writing one |

### 📋 What the USNO Astronomical Almanac Scraper does

This Actor calls the public USNO rise/set/transit/twilight API and returns one clean record per location per date:

- **Sun events** — rise, set, upper transit (solar noon), and the begin/end of civil twilight.
- **Moon events** — rise, set, and upper transit.
- **Moon phase** — current phase name, fraction illuminated, and the nearest principal phase with its date and time.
- **Context** — the day of week, the time-zone offset used, and a daylight saving flag.

Polar conditions (continuous day or night) are passed through as a `sunNote` or `moonNote` instead of a time. Every record carries a `scrapedAt` timestamp.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `locations` | array | One or more `latitude,longitude` pairs. Latitude -90 to 90, longitude -180 to 180. Defaults to `38.9,-77.0` (Washington DC). |
| `startDate` | string | First date to fetch, in `YYYY-MM-DD`. Defaults to today. |
| `endDate` | string | Last date to fetch, in `YYYY-MM-DD`. Leave empty to fetch only the start date. A record is produced for every day in the range. |
| `tz` | integer | Hours offset from UTC for the returned times, -12 to 14. Use `0` for UTC, `-5` for US Eastern Standard Time. Defaults to `0`. |
| `dst` | boolean | When on, times are shifted one hour forward for daylight saving and flagged in the output. Defaults to `false`. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — one week of almanac data for Washington DC**
```json
{
    "locations": ["38.9,-77.0"],
    "startDate": "2026-06-08",
    "endDate": "2026-06-14",
    "tz": -5,
    "maxItems": 7
}
````

**Example 2 — a single date for several cities in UTC**

```json
{
    "locations": ["51.5,-0.13", "35.68,139.69", "-33.87,151.21"],
    "startDate": "2026-06-08",
    "tz": 0,
    "maxItems": 10
}
```

> ⚠️ **Good to Know:** the number of records is locations × dates. Three locations across a 10-day range is 30 records. At high latitudes near the solstices, the sun or moon may never rise or set; in that case the time fields are null and the reason appears in `sunNote` or `moonNote`.

### 📊 Output

Each almanac record looks like this:

| Field | Description |
|---|---|
| 📅 `date` | Observation date (`YYYY-MM-DD`) |
| 🧭 `latitude` | Latitude used for the query |
| 🧭 `longitude` | Longitude used for the query |
| 🗓 `dayOfWeek` | Day of the week for the date |
| ⏱ `timeZoneOffset` | UTC offset applied to the times |
| 🌗 `isDaylightSaving` | Whether a DST shift was applied |
| 🌙 `currentMoonPhase` | Current moon phase name |
| 💡 `fractionIlluminated` | Fraction of the moon illuminated |
| 🌑 `nearestPhaseName` | Nearest principal phase (New, First Quarter, etc.) |
| 📆 `nearestPhaseDate` | Date of that nearest phase |
| 🕐 `nearestPhaseTime` | Time of that nearest phase |
| 🌅 `sunRise` | Sunrise time |
| 🌇 `sunSet` | Sunset time |
| ☀ `sunTransit` | Solar noon (upper transit) |
| 🌄 `beginCivilTwilight` | Start of civil twilight |
| 🌆 `endCivilTwilight` | End of civil twilight |
| 📝 `sunNote` | Polar day/night note for the sun, if any |
| 🌘 `moonRise` | Moonrise time |
| 🌒 `moonSet` | Moonset time |
| 🌕 `moonTransit` | Moon upper transit |
| 📝 `moonNote` | Polar note for the moon, if any |
| 🔢 `apiVersion` | USNO API version that served the data |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — almanac record**

```json
{
    "date": "2026-06-08",
    "latitude": 38.9,
    "longitude": -77.0,
    "dayOfWeek": "Monday",
    "timeZoneOffset": -5,
    "isDaylightSaving": false,
    "currentMoonPhase": "Waning Gibbous",
    "fractionIlluminated": "0.83",
    "nearestPhaseName": "Last Quarter",
    "nearestPhaseDate": "2026-06-09",
    "nearestPhaseTime": "14:43",
    "sunRise": "04:43",
    "sunSet": "19:32",
    "sunTransit": "12:07",
    "beginCivilTwilight": "04:11",
    "endCivilTwilight": "20:04",
    "sunNote": null,
    "moonRise": "23:51",
    "moonSet": "09:42",
    "moonTransit": "04:33",
    "moonNote": null,
    "apiVersion": "3.0.1",
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per location per date, ready for a spreadsheet or database.
- Handles single dates or long date ranges in one run.
- Returns times in UTC or any time-zone offset, with an optional DST shift.
- Passes through polar day and polar night notes instead of dropping them.
- No account, no API key, and no login required.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Date ranges | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Copying from an almanac site | Hours | Inconsistent | Manual | Constant |
| Writing your own astronomy code | Days | Depends | You build it | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the USNO Astronomical Almanac Scraper.
3. Enter one or more `locations` as `latitude,longitude`.
4. Set a `startDate` (and optional `endDate`), `tz`, and `maxItems`.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Photography and film

| Goal | How this helps |
|---|---|
| Plan golden and blue hour | Use sunrise, sunset, and civil twilight times |
| Schedule moonlit scenes | Use moonrise, moonset, phase, and illumination |

#### Marine and aviation

| Goal | How this helps |
|---|---|
| Prep navigation logs | Pull twilight and solar noon by coordinate |
| Brief crews on daylight | Snapshot sun and moon timing for a route |

#### Field research

| Goal | How this helps |
|---|---|
| Align observations to light | Tag samples with sun and moon timing |
| Build long time series | Sweep a date range for one site |

#### Apps and automation

| Goal | How this helps |
|---|---|
| Power a rise/set feature | Feed clean almanac records to your app |
| Run a daily snapshot | Schedule one location per day |

### 🔌 Automating USNO Astronomical Almanac Scraper

Connect runs to the tools you already use:

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

### 🌟 Beyond business use cases

- **Research:** build multi-year almanac datasets for a study site.
- **Personal:** plan a stargazing night or a sunrise hike.
- **Non-profit:** power a community observatory's event calendar.
- **Experimentation:** prototype an astronomy app without writing the math.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to find the best shooting window, chart daylight length over a month, or compare twilight across cities.

### ❓ Frequently Asked Questions

**Do I need a USNO account or API key?**
No. The Actor reads the public US Naval Observatory rise/set/transit API, which needs no login.

**What locations are supported?**
Any coordinate on Earth, latitude -90 to 90 and longitude -180 to 180. Pass them as `latitude,longitude` strings.

**Can I fetch a date range?**
Yes. Set `startDate` and `endDate`. One record is produced for every day in the range, for every location.

**What time zone are the times in?**
Whatever you set with `tz` (hours from UTC). Use `0` for UTC. Turn on `dst` to shift one hour forward for daylight saving.

**What happens at high latitudes?**
When the sun or moon never rises or sets, the time fields are null and the reason is reported in `sunNote` or `moonNote`.

**What is "solar noon"?**
The sun's upper transit, returned in `sunTransit`. It is the moment the sun is highest in the sky.

**Does it include moon phase?**
Yes. Every record carries the current phase, the fraction illuminated, and the nearest principal phase with its date and time.

**How fresh is the data?**
Each run computes live from USNO, so it reflects the official almanac at run time.

**How many records will I get?**
Locations × dates, capped by `maxItems`. Free runs are limited to 10.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot any location on any cadence.

### 🔌 Integrate with any app

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

### 🔗 Recommended Actors

- [NASA JPL Horizons Ephemeris Scraper](https://apify.com/parseforge)
- [NOAA CoastWatch ERDDAP Ocean Data Scraper](https://apify.com/parseforge)
- More science and reference data Actors in the [ParseForge collection](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with the US Naval Observatory or the US Navy. Only publicly available data is collected.

# Actor input Schema

## `locations` (type: `array`):

One or more locations as 'latitude,longitude' pairs. Latitude from -90 to 90, longitude from -180 to 180. Example: '38.9,-77.0' for Washington DC. Leave empty to use 38.9,-77.0.

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

First date to fetch, in YYYY-MM-DD form. Defaults to today if left empty.

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

Last date to fetch, in YYYY-MM-DD form. Leave empty to fetch only the start date. A record is produced for every day in the range.

## `tz` (type: `integer`):

Hours offset from UTC for the returned times, from -12 to 14. For example -5 for US Eastern Standard Time. Use 0 for UTC.

## `dst` (type: `boolean`):

When on, times are shifted one hour forward for daylight saving and marked with a DST flag in the output.

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

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

## Actor input object example

```json
{
  "locations": [
    "38.9,-77.0"
  ],
  "startDate": "2026-06-08",
  "tz": 0,
  "dst": false,
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "locations": [
        "38.9,-77.0"
    ],
    "startDate": "2026-06-08",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/usno-astronomical-almanac-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 = {
    "locations": ["38.9,-77.0"],
    "startDate": "2026-06-08",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/usno-astronomical-almanac-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 '{
  "locations": [
    "38.9,-77.0"
  ],
  "startDate": "2026-06-08",
  "maxItems": 10
}' |
apify call parseforge/usno-astronomical-almanac-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USNO Astronomical Almanac Scraper",
        "description": "Pull sun and moon rise, set, and transit times from the US Naval Observatory for any date and place. Returns moon phase, fraction illuminated, nearest phase date, civil twilight, and solar noon by latitude and longitude. Handy for photography planning, sailing, and field research.",
        "version": "0.1",
        "x-build-id": "cJUc3g3sX4U6a6fEJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~usno-astronomical-almanac-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-usno-astronomical-almanac-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~usno-astronomical-almanac-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-usno-astronomical-almanac-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~usno-astronomical-almanac-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-usno-astronomical-almanac-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": {
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "One or more locations as 'latitude,longitude' pairs. Latitude from -90 to 90, longitude from -180 to 180. Example: '38.9,-77.0' for Washington DC. Leave empty to use 38.9,-77.0.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "First date to fetch, in YYYY-MM-DD form. Defaults to today if left empty."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Last date to fetch, in YYYY-MM-DD form. Leave empty to fetch only the start date. A record is produced for every day in the range."
                    },
                    "tz": {
                        "title": "Time zone offset",
                        "minimum": -12,
                        "maximum": 14,
                        "type": "integer",
                        "description": "Hours offset from UTC for the returned times, from -12 to 14. For example -5 for US Eastern Standard Time. Use 0 for UTC.",
                        "default": 0
                    },
                    "dst": {
                        "title": "Apply daylight saving time",
                        "type": "boolean",
                        "description": "When on, times are shifted one hour forward for daylight saving and marked with a DST flag in the output.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```