# GBIF Biodiversity Data Scraper (`parseforge/gbif-biodiversity-scraper`) Actor

Export species records and occurrence data from GBIF, the Global Biodiversity Information Facility. 2.5B+ occurrences across every species on Earth. Search by scientific name or fetch occurrences by location, taxon, or collector. Pull taxonomy, coordinates, and dataset metadata.

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

## Pricing

from $7.49 / 1,000 result items

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

![ParseForge Banner](https://apify-uploads-prod.s3.us-east-1.amazonaws.com/5U8OIL8SpS9PcjP84Vg0QjrH6JFY1DUA_image.png)

## 🚀 GBIF Biodiversity Data Scraper

> 🚀 **Export 2.5B+ biodiversity occurrences from GBIF - every species on Earth. Filter by taxon, location, collector**.

> 🕒 **Last updated:** 2026-04-24 · **📊 13+ fields** per record · **🔍 7 filters** · **🚫 No auth** required

Export species records and occurrence data from GBIF, the Global Biodiversity Information Facility. 2.5B+ occurrences across every species on Earth. Search by scientific name or fetch occurrences by location, taxon, or collector.

Every run fetches live data from the source. You get a fresh snapshot per run, not a stale dump. The actor is designed for repeatable automation, scheduled pulls, and integration with downstream tools.

---

### 📋 What the GBIF Biodiversity Data Scraper does

- 🎯 **Targeted filtering.** Use the input schema to narrow results to what you need.
- 📦 **Structured output.** Clean, typed records with every field documented.
- 🔄 **Live data.** Every run fetches fresh data at runtime, no cached responses.
- 🔌 **Easy integration.** Consume via Apify API, webhooks, or direct dataset export.
- 📊 **Scale on demand.** Run once or run on a schedule, the same way.

> 💡 **Why it matters:** teams that rely on this source no longer need to babysit a custom crawler. Set up your filters once, get updated data on demand.

---

### ⚙️ Input

Send a JSON body with any of the documented input fields. All fields are optional unless the schema marks them required.

| Field | Type | Name | Description |
|---|---|---|---|
| `maxItems` | integer | Max Items | Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000 |
| `mode` | string | Mode | Species: search taxonomic records. Occurrences: fetch individual observations or specimens. |
| `scientificName` | string | Scientific Name | Binomial or higher-taxa name (e.g. 'Panthera leo', 'Orchidaceae'). |
| `taxonKey` | integer | GBIF Taxon Key | Occurrences only. Restrict to a specific taxon key from the species backbone. |
| `country` | string | Country Code | Occurrences only. ISO 3166-1 alpha-2 (e.g. US, KE, BR). |
| `year` | integer | Year | Occurrences only. Restrict to a specific observation year (use with a range in mode if needed). |
| `hasCoordinate` | boolean | Has Coordinates Only | Occurrences only. Limit to records with verified latitude/longitude. |
| `basisOfRecord` | string | Basis of Record | Occurrences only. |

> ⚠️ **Good to Know:** free users are limited to 10 items per run for preview purposes. Upgrade to Apify paid plans for higher limits.

---

### 📊 Output

The dataset returns one structured record per item. Each record includes identifiers, descriptive fields, and a link back to the source. Consume the dataset as JSON, CSV, Excel, XML, or RSS via the Apify console or API.

---

### 💼 Business use cases

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

#### 📊 Analysts and researchers
- Build longitudinal datasets for trend analysis
- Benchmark across sources and regions
- Feed BI tools and custom dashboards
- Enrich existing pipelines with fresh data

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

#### 🛠️ Engineers and operators
- Power internal APIs without building your own crawler
- Schedule weekly deltas to a database
- Plug into existing ETL stacks via Apify webhooks
- Skip the infra work, get clean structured output

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

#### 🎯 Growth and sales teams
- Discover new leads and accounts at scale
- Monitor competitor coverage and positioning
- Build outbound lists keyed to real signals
- Prioritize outreach with structured context

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

#### 🧪 Product and data teams
- Prototype features against live data
- A/B test ranking or matching logic
- Train or evaluate domain-specific models
- Validate hypotheses before committing engineering

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

---

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

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

#### 🎓 Research and academia
- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

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

#### 🎨 Personal and creative
- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

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

#### 🤝 Non-profit and civic
- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

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

#### 🧪 Experimentation
- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

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

---

### 🚀 How to use

1. 📝 **Create a free account.** Sign up at [console.apify.com](https://console.apify.com/sign-up?fpr=vmoqkp) to get $5 in credits.
2. 🔍 **Open the actor.** Paste your filters into the input schema in the Apify console.
3. ▶️ **Click Start.** Wait a few seconds for the first records to land.
4. 📤 **Export the data.** Download JSON/CSV or pipe to webhooks, Google Sheets, or Zapier.
5. 🔄 **Schedule it.** Apify Schedules let you rerun on a cron cadence for free.

> ⏱️ Total time to first data: about 60 seconds.

---

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

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

---

### ❓ Frequently Asked Questions

<details>
<summary><strong>🔍 What does the GBIF Biodiversity Data do?</strong></summary>

Export species records and occurrence data from GBIF, the Global Biodiversity Information Facility. 2.5B+ occurrences across every species on Earth. Search by scientific name or fetch occurrences by location, taxon, or collector.. Pass your filters via the input schema and run the actor.

</details>

<details>
<summary><strong>🛠️ How do I get started?</strong></summary>

Open the actor in Apify, fill in the input fields, and click Start. The dataset appears on your run page within seconds.

</details>

<details>
<summary><strong>💰 How much does it cost?</strong></summary>

Free Apify users can run the actor and preview up to 10 records. Paid plans remove the preview cap. See the Apify pricing page for details.

</details>

<details>
<summary><strong>📅 How fresh is the data?</strong></summary>

Every run scrapes live from the source at runtime. No cached responses, no pre-loaded dumps. You get the snapshot visible to the source when the actor starts.

</details>

<details>
<summary><strong>🗂️ What filters are supported?</strong></summary>

The input schema exposes mode, scientificName, taxonKey, country, year. Combine them to narrow results. If a filter is empty, the default ordering from the source is used.

</details>

<details>
<summary><strong>🔐 Do I need an API key, account, or authentication?</strong></summary>

No. The actor runs against public endpoints using Apify residential proxies. You just need your Apify account to launch the run.

</details>

<details>
<summary><strong>🧾 What fields are returned per record?</strong></summary>

Each record includes the primary identifiers, descriptive fields, URLs to the source page, and any structured data the source exposes. Exact fields depend on the source and are documented in the output schema.

</details>

<details>
<summary><strong>⚡ How fast is a run?</strong></summary>

Most runs return a first batch of records within a minute. Throughput depends on source rate limits and the number of filters stacked, not on Apify.

</details>

<details>
<summary><strong>📤 Can I export the dataset?</strong></summary>

Yes. Apify exposes the dataset as JSON, CSV, XML, Excel, or RSS via the UI or API. You can also stream new records into webhooks, Google Sheets, Airtable, and more.

</details>

<details>
<summary><strong>🧭 Can I schedule recurring runs?</strong></summary>

Yes. Apify Schedules let you run this actor on a cron cadence and deliver fresh data to your destination. No extra code is required.

</details>

<details>
<summary><strong>🛡️ Is scraping this source legal for commercial use?</strong></summary>

This actor only retrieves publicly available information. You are responsible for complying with the source website terms and any applicable privacy and competition rules in your jurisdiction.

</details>

<details>
<summary><strong>🤝 What if a run fails or returns fewer items than expected?</strong></summary>

Open the run log for the exact error. Most failures come from source rate limits or filter combinations with no matches. Retry with a broader filter or contact support via the Tally form below.

</details>

---

### 🔌 Integrate with any app

Connect the GBIF Biodiversity Data Scraper to cloud services via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - visual automation builder
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - 5000+ app connectors
- [**Google Sheets**](https://docs.apify.com/platform/integrations/drive) - pipe rows directly
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - ingest into data warehouses
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - receive run alerts
- [**HTTP webhooks**](https://docs.apify.com/platform/integrations/webhooks) - custom downstream

---

### 🔗 Recommended Actors

Pair the GBIF Biodiversity Data Scraper with related actors:

- [**🌐 Website Content Crawler**](https://apify.com/parseforge/website-content-crawler) - crawl any page at scale
- [**🔍 Google Search Scraper**](https://apify.com/parseforge/google-search-scraper) - harvest SERPs
- [**📄 Article Extractor**](https://apify.com/parseforge/article-extractor) - extract clean article text
- [**📊 Google Trends Scraper**](https://apify.com/parseforge/google-trends-scraper) - capture demand signals
- [**📸 Screenshot URL**](https://apify.com/parseforge/screenshot-url) - render any page to image

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

---

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

---

> ⚠️ **Disclaimer:** This actor retrieves data from publicly available sources. You are responsible for complying with the source website's terms of service and applicable laws in your jurisdiction. ParseForge is not affiliated with the data source.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000
## `mode` (type: `string`):

Species: search taxonomic records. Occurrences: fetch individual observations or specimens.
## `scientificName` (type: `string`):

Binomial or higher-taxa name (e.g. 'Panthera leo', 'Orchidaceae').
## `taxonKey` (type: `integer`):

Occurrences only. Restrict to a specific taxon key from the species backbone.
## `country` (type: `string`):

Occurrences only. ISO 3166-1 alpha-2 (e.g. US, KE, BR).
## `year` (type: `integer`):

Occurrences only. Restrict to a specific observation year (use with a range in mode if needed).
## `hasCoordinate` (type: `boolean`):

Occurrences only. Limit to records with verified latitude/longitude.
## `basisOfRecord` (type: `string`):

Occurrences only.

## Actor input object example

```json
{
  "maxItems": 10,
  "mode": "occurrences",
  "scientificName": "Panthera leo",
  "hasCoordinate": true,
  "basisOfRecord": ""
}
````

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "maxItems": 10,
    "mode": "occurrences",
    "scientificName": "Panthera leo"
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "maxItems": 10,
    "mode": "occurrences",
    "scientificName": "Panthera leo",
}

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

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10,
  "mode": "occurrences",
  "scientificName": "Panthera leo"
}' |
apify call parseforge/gbif-biodiversity-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GBIF Biodiversity Data Scraper",
        "description": "Export species records and occurrence data from GBIF, the Global Biodiversity Information Facility. 2.5B+ occurrences across every species on Earth. Search by scientific name or fetch occurrences by location, taxon, or collector. Pull taxonomy, coordinates, and dataset metadata.",
        "version": "1.0",
        "x-build-id": "CVQSxJg3mbQripu9o"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~gbif-biodiversity-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-gbif-biodiversity-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~gbif-biodiversity-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-gbif-biodiversity-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~gbif-biodiversity-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-gbif-biodiversity-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "species",
                            "occurrences"
                        ],
                        "type": "string",
                        "description": "Species: search taxonomic records. Occurrences: fetch individual observations or specimens."
                    },
                    "scientificName": {
                        "title": "Scientific Name",
                        "type": "string",
                        "description": "Binomial or higher-taxa name (e.g. 'Panthera leo', 'Orchidaceae')."
                    },
                    "taxonKey": {
                        "title": "GBIF Taxon Key",
                        "type": "integer",
                        "description": "Occurrences only. Restrict to a specific taxon key from the species backbone."
                    },
                    "country": {
                        "title": "Country Code",
                        "type": "string",
                        "description": "Occurrences only. ISO 3166-1 alpha-2 (e.g. US, KE, BR)."
                    },
                    "year": {
                        "title": "Year",
                        "type": "integer",
                        "description": "Occurrences only. Restrict to a specific observation year (use with a range in mode if needed)."
                    },
                    "hasCoordinate": {
                        "title": "Has Coordinates Only",
                        "type": "boolean",
                        "description": "Occurrences only. Limit to records with verified latitude/longitude.",
                        "default": true
                    },
                    "basisOfRecord": {
                        "title": "Basis of Record",
                        "enum": [
                            "",
                            "PRESERVED_SPECIMEN",
                            "HUMAN_OBSERVATION",
                            "MACHINE_OBSERVATION",
                            "FOSSIL_SPECIMEN",
                            "LIVING_SPECIMEN",
                            "MATERIAL_SAMPLE",
                            "OBSERVATION",
                            "OCCURRENCE"
                        ],
                        "type": "string",
                        "description": "Occurrences only.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
