# eBird Bird Observations Scraper (`parseforge/ebird-scraper`) Actor

Scrape recent and notable bird observation data from the Cornell Lab eBird public API. Export species, location, count, and checklist data by region.

- **URL**: https://apify.com/parseforge/ebird-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 $19.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)

## 🐦 eBird Bird Observations Scraper

> 🚀 **Export real-time bird observation data in seconds.** Pull **recent and notable sightings** from the Cornell Lab eBird public API by region code. No browser, no scraping - direct API access to one of the world's largest citizen science datasets.

> 🕒 **Last updated:** 2026-05-21 · **📊 16 fields** per record · **🌍 Global coverage** · **🦅 700+ species** · **📡 Real-time data**

The **eBird Scraper** connects to the Cornell Lab of Ornithology's eBird API and returns structured bird observation records with **16 fields per record**, including species codes, common and scientific names, GPS coordinates, observation counts, checklist links, and validation status. The eBird dataset is the world's largest biodiversity-related citizen science project, with over 100 million bird observations submitted annually from birders across every country.

This Actor covers **recent and notable (rare) observations** in any eBird region, from country level (US, GB, MX) down to state/province (US-NY, CA-ON, GB-ENG) and county level. Results are available as CSV, Excel, JSON, or XML in seconds.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Ornithologists, citizen science researchers, wildlife conservationists, data scientists, nature app developers, birding enthusiasts, environmental agencies | Migration tracking, rare species alerts, biodiversity mapping, research datasets, birding app feeds, conservation monitoring |

---

### 📋 What the eBird Scraper does

Two observation workflows in a single run:

- 🦅 **Recent observations.** All bird sightings reported in a region within the last 30 days, up to 10,000 per region.
- 🌟 **Notable (rare) observations.** Unusual or rare sightings flagged by the eBird review system for any region.
- 📍 **Region filtering.** Target any eBird region by code: country (`US`), state/province (`US-NY`, `CA-ON`), or county (`US-NY-109`).
- 📊 **Rich observation data.** Species code, common name, scientific name, GPS location, bird count, checklist ID, and observation validity.
- 🔗 **Direct checklist links.** Each record includes a URL to the full eBird checklist for verification and deeper context.

> 💡 **Why it matters:** eBird data powers migration models, climate impact studies, and conservation planning worldwide. Building a direct integration means no more manual CSV exports, no stale data, and full control over which regions and observation types you monitor.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to configure a region, run the Actor, and download your dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>regionCode</td><td>string</td><td>"US-NY"</td><td>eBird region code. Examples: US, US-NY, GB, MX, CA-ON, AU.</td></tr>
<tr><td>observationType</td><td>string</td><td>"recent"</td><td>recent = all sightings, notable = rare/unusual species only.</td></tr>
<tr><td>apiKey</td><td>string</td><td><em>demo key</em></td><td>Your free eBird API key. Get one at ebird.org/api/keygen. Defaults to a demo key.</td></tr>
</tbody>
</table>

**Example input - recent observations (New York):**

```json
{
    "maxItems": 100,
    "regionCode": "US-NY",
    "observationType": "recent",
    "apiKey": "your_ebird_api_key"
}
````

**Example input - notable rare sightings (United Kingdom):**

```json
{
    "maxItems": 50,
    "regionCode": "GB",
    "observationType": "notable",
    "apiKey": "your_ebird_api_key"
}
```

> ⚠️ **Good to Know:** eBird requires a free API key for production use. Get yours at <https://ebird.org/api/keygen> in under 2 minutes. A demo key is used if none is provided, but may have rate limits. Free Apify plan users are limited to 10 items per run.

***

### 📊 Output

Each record contains 16 fields:

| Field | Type | Description |
|---|---|---|
| 🔬 `speciesCode` | string | eBird species code (e.g. `mallar3` for Mallard) |
| 🐦 `comName` | string | Common English name of the species |
| 🔭 `sciName` | string | Scientific (Latin) name of the species |
| 📍 `locId` | string | eBird location identifier (e.g. `L123456`) |
| 🗺️ `locName` | string | Name of the observation location |
| 📅 `obsDt` | string | Observation date and time (YYYY-MM-DD HH:MM) |
| 🔢 `howMany` | number | Count of individuals observed (null if unspecified) |
| 🌐 `lat` | number | Latitude of the observation location |
| 🌐 `lng` | number | Longitude of the observation location |
| ✅ `obsValid` | boolean | Whether the observation passed eBird validation |
| 👁️ `obsReviewed` | boolean | Whether the observation has been reviewed by experts |
| 🔒 `locationPrivate` | boolean | Whether the observer marked the location as private |
| 📋 `subId` | string | eBird checklist submission ID |
| 🔗 `url` | string | Direct URL to the eBird checklist |
| ⏱️ `scrapedAt` | string | ISO 8601 timestamp of data collection |
| ❌ `error` | string | Error message if the record failed (null on success) |

**Sample records:**

```json
[
  {
    "speciesCode": "bkpwar",
    "comName": "Blackpoll Warbler",
    "sciName": "Setophaga striata",
    "locId": "L36830373",
    "locName": "Riverside Park, New York US-NY 40.81094, -73.96441",
    "obsDt": "2026-05-21 13:51",
    "howMany": 1,
    "lat": 40.810938,
    "lng": -73.964411,
    "obsValid": true,
    "obsReviewed": false,
    "locationPrivate": true,
    "subId": "S343476966",
    "url": "https://ebird.org/checklist/S343476966",
    "scrapedAt": "2026-05-21T23:35:16.624Z",
    "error": null
  },
  {
    "speciesCode": "houfin",
    "comName": "House Finch",
    "sciName": "Haemorhous mexicanus",
    "locId": "L36830373",
    "locName": "Riverside Park, New York US-NY 40.81094, -73.96441",
    "obsDt": "2026-05-21 13:51",
    "howMany": 3,
    "lat": 40.810938,
    "lng": -73.964411,
    "obsValid": true,
    "obsReviewed": false,
    "locationPrivate": true,
    "subId": "S343476966",
    "url": "https://ebird.org/checklist/S343476966",
    "scrapedAt": "2026-05-21T23:35:16.624Z",
    "error": null
  }
]
```

***

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 🚀 Direct API integration | Real-time data, no HTML parsing fragility |
| 🌍 Global region support | Any country, state, province, or county code |
| 🦅 Two observation modes | Recent sightings or rare/notable species only |
| 🔗 Checklist URLs included | Deep-link directly to the original eBird report |
| 📐 GPS coordinates | Lat/lng on every record for mapping workflows |
| ✅ Validation status | Know if observations are confirmed or under review |
| 🆓 No mandatory API key | Demo key included for quick testing |
| 📦 Clean JSON output | Consistent schema, null-safe, export-ready |

***

### 📈 How it compares to alternatives

| Approach | Speed | Data freshness | Region flexibility | Setup time |
|---|---|---|---|---|
| **This Actor** | Fast (API) | Real-time | Any eBird code | Under 1 min |
| Manual eBird export | Slow (UI) | On-demand | Limited | 10-15 min |
| Building your own | Medium | Your schedule | Full | Days |
| eBird mobile app | N/A | Real-time | Visual only | N/A |

***

### 🚀 How to use

1. [Create a free account](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify (includes $5 credit).
2. Open the **eBird Bird Observations Scraper** on the Apify Store.
3. Get a free eBird API key at <https://ebird.org/api/keygen>.
4. Enter your region code (e.g. `US-NY`, `GB`, `MX`), observation type, and API key.
5. Set `maxItems` to control how many records you want.
6. Click **Start** and wait for the run to finish (typically under 10 seconds).
7. Download your dataset as JSON, CSV, Excel, or XML from the **Storage** tab.

***

### 💼 Business use cases

#### 🔬 Ecological Research and Conservation

Track species presence and abundance across regions over time. Monitor migratory patterns as birds move through specific corridors. Build longitudinal datasets for population trend analysis. Alert systems for rare or endangered species appearing in new regions.

#### 📱 Birding Apps and Nature Platforms

Power mobile apps with live "what's being seen nearby" feeds. Build species checklists for specific parks, reserves, or regions. Enable notification systems for notable or rare bird alerts. Feed species-range maps with verified observation data.

#### 🌍 Environmental Monitoring and Reporting

Generate biodiversity reports for environmental impact assessments. Monitor indicator species for climate or habitat change studies. Support land management decisions with data on species distribution. Satisfy regulatory reporting requirements for protected species.

#### 📊 Data Science and Machine Learning

Train bird identification models with georeferenced species labels. Correlate bird activity with weather, land use, or pollution data. Build predictive models for migration timing and routing. Combine with satellite imagery for habitat modeling at scale.

***

### 🔌 Automating eBird Scraper

Connect this Actor to your favorite automation platforms:

- **Make (formerly Integromat):** Schedule daily region sweeps, push new notable sightings to a Slack channel, or log records to Google Sheets automatically.
- **Zapier:** Trigger workflows when new rare species are detected in your region. Post alerts to email, SMS, or team channels.
- **Slack:** Build a daily bird report bot that posts the day's top observations to a team channel.
- **Google Sheets:** Append each run's records to a sheet for ongoing monitoring dashboards.
- **Webhooks:** Any system that accepts HTTP POST can receive run results the moment the Actor finishes.

***

### 🌟 Beyond business use cases

#### 🎓 Academic Research

Ecology students and professors use eBird data to illustrate distribution modeling, species-area relationships, and phenological shifts. This Actor makes it trivial to pull a fresh snapshot for any region and semester.

#### 🖼️ Creative and Artistic Projects

Wildlife photographers, nature bloggers, and illustrators use observation feeds to know which species are active in a location before a shoot. Notable sightings data helps plan expeditions for rare species documentation.

#### 🤝 Non-Profit and Citizen Science

Land trusts, birding clubs, and conservation non-profits use observation data to report on biodiversity at their preserves, advocate for habitat protection, and engage community volunteers with real data.

#### 🧪 Experimentation and Prototyping

Developers and data enthusiasts build personal bird-alert apps, experiment with species distribution visualizations, or prototype conservation tools using this Actor as a fast, reliable data source.

***

### 🤖 Ask an AI assistant about this scraper

Have questions about eBird data, region codes, or how to use this Actor in your project? Use the AI assistant on the Actor page to get instant answers. You can ask things like:

- "What region code should I use for Ontario, Canada?"
- "How do I filter to only confirmed, reviewed observations?"
- "Can I get observations for a specific species?"
- "What's the difference between recent and notable observations?"

***

### ❓ Frequently Asked Questions

**❓ Do I need an eBird API key?**
A demo key is included for quick testing. For production use and higher rate limits, get your own free key at <https://ebird.org/api/keygen>. Registration is free.

**❓ What are eBird region codes?**
Region codes follow a hierarchical format. Countries use ISO codes like `US`, `GB`, `MX`, `CA`, `AU`. States and provinces use `US-NY`, `CA-ON`, `GB-ENG`. Find valid codes at <https://ebird.org/region>.

**❓ How recent are the observations?**
The API returns observations from the last 30 days by default. Data reflects reports as they are submitted by eBird users globally.

**❓ What is a "notable" observation?**
Notable observations are sightings of rare or unusual species that trigger the eBird review system. These are birds that are unexpected for a given region and time of year, flagged for expert verification.

**❓ What does `obsValid` mean?**
A `true` value means the observation passed automated validation. `obsReviewed: true` means a human expert has reviewed and confirmed the sighting. Both can be false for very recent submissions still awaiting review.

**❓ Why is `howMany` null for some records?**
Some observers submit observations without specifying a count, only noting that the species was present. This results in a null `howMany` field - this is normal eBird behavior.

**❓ What is `locationPrivate`?**
eBird allows observers to mark locations as private (personal gardens, private land). When `true`, the exact coordinates may be obscured slightly for privacy. The observation data itself is still real.

**❓ How many observations can I retrieve per run?**
Free Apify plan: up to 10. Paid plan: up to 1,000,000. The eBird API itself returns up to 10,000 observations per region request.

**❓ Can I get observations for a specific species?**
The current Actor returns all species for a region. Species-level filtering can be applied to the output dataset after download. A future version may include species-level filtering.

**❓ Is this Actor maintained?**
Yes. ParseForge maintains this Actor and updates it when the eBird API changes. The Last Updated date in this README reflects the most recent maintenance.

***

### 🔌 Integrate with any app

Export your bird observation dataset in multiple formats and connect to hundreds of apps:

| Integration | How to use |
|---|---|
| **Google Sheets** | Download CSV, import directly, or use Make to auto-sync |
| **Excel / Power BI** | Download XLSX for immediate analysis |
| **ArcGIS / QGIS** | Export JSON with lat/lng for immediate map layer import |
| **Airtable** | Import CSV or connect via Make/Zapier automation |
| **Notion** | Import CSV database for research note-taking |
| **Slack** | Send notable sighting alerts via Make or Zapier |
| **Custom apps** | Hit the Apify API directly for programmatic access |
| **Python / R** | Load JSON or CSV into pandas, tidyverse, or any data workflow |
| **Webhooks** | POST results to any endpoint when a run completes |

***

### 🔗 Recommended Actors

Complement your eBird data with these related ParseForge Actors:

| Actor | What it does |
|---|---|
| [OurAirports Global Airport Database Scraper](https://apify.com/parseforge/ourairports-scraper) | Export 85,000+ airports worldwide with GPS, ICAO, IATA codes |
| [USGS Earthquake Scraper](https://apify.com/parseforge/usgs-earthquake-scraper) | Real-time earthquake events from the USGS public API |
| [EPA AQS Air Quality Scraper](https://apify.com/parseforge/epa-aqs-air-quality-scraper) | US air quality monitoring data from EPA public API |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for dozens of free public-data Actors covering science, finance, government, and more.

***

**Disclaimer:** This Actor uses the Cornell Lab eBird public API, which is freely available for non-commercial and research use under eBird's terms of service. All data belongs to the Cornell Lab of Ornithology and the eBird contributors. Always review [eBird's data use policy](https://www.birds.cornell.edu/home/ebird-data-access-terms-of-use/) before using observation data in commercial applications. ParseForge is not affiliated with Cornell Lab of Ornithology or eBird.

# Actor input Schema

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

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

## `regionCode` (type: `string`):

eBird region code. Examples: US (USA), US-NY (New York), GB (UK), MX (Mexico), CA-ON (Ontario). See https://ebird.org/region for valid codes.

## `observationType` (type: `string`):

Type of observations to retrieve: 'recent' for all recent sightings, 'notable' for rare or unusual sightings.

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

Your free eBird API key. Get one at https://ebird.org/api/keygen (free account required). Required to access the API.

## Actor input object example

```json
{
  "maxItems": 10,
  "regionCode": "US-NY",
  "observationType": "recent"
}
```

# 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 = {
    "maxItems": 10,
    "regionCode": "US-NY",
    "observationType": "recent"
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "regionCode": "US-NY",
    "observationType": "recent",
}

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

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "regionCode": "US-NY",
  "observationType": "recent"
}' |
apify call parseforge/ebird-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBird Bird Observations Scraper",
        "description": "Scrape recent and notable bird observation data from the Cornell Lab eBird public API. Export species, location, count, and checklist data by region.",
        "version": "1.0",
        "x-build-id": "lOWTToUendHKFMvq5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~ebird-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-ebird-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~ebird-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-ebird-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~ebird-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-ebird-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "regionCode": {
                        "title": "Region Code",
                        "type": "string",
                        "description": "eBird region code. Examples: US (USA), US-NY (New York), GB (UK), MX (Mexico), CA-ON (Ontario). See https://ebird.org/region for valid codes."
                    },
                    "observationType": {
                        "title": "Observation Type",
                        "enum": [
                            "recent",
                            "notable"
                        ],
                        "type": "string",
                        "description": "Type of observations to retrieve: 'recent' for all recent sightings, 'notable' for rare or unusual sightings."
                    },
                    "apiKey": {
                        "title": "eBird API Key",
                        "type": "string",
                        "description": "Your free eBird API key. Get one at https://ebird.org/api/keygen (free account required). Required to access the API."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
