# Paleobiology Database Fossils Scraper (`parseforge/paleobiology-fossils-scraper`) Actor

Search the Paleobiology Database by taxon name and pull every fossil occurrence beneath it. Returns taxon, rank, occurrence and collection IDs, geologic interval, early and late age in millions of years, country, coordinates, and formation. Filter by interval or country.

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

## Pricing

from $6.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)

## 🦴 Paleobiology Database Fossils Scraper

> 🚀 **Pull fossil occurrence records in seconds.** Search any taxon and get back where it was found, how old it is, and which collection it came from, straight from the Paleobiology Database (PBDB).

> 🕒 **Last updated:** 2026-06-05 · **📊 24 fields** per record · Global coverage · Keyless public data service

The Paleobiology Database is a public, scientist-curated archive of the fossil record, holding millions of occurrence records contributed by paleontologists worldwide. This Actor queries the PBDB data service by taxonomic name and returns clean, structured fossil occurrence records ready for analysis.

**Coverage:** Every taxonomic level is searchable, from a single genus like *Tyrannosaurus* up to an entire class like *Mammalia*. Each occurrence carries its taxon identification, geologic age in millions of years, country and coordinates, and the rock formation it was recovered from. Filter by geologic interval (period, epoch, or age) and by country to focus a query.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Paleontologists and geologists | Build occurrence datasets for a taxon or clade |
| Researchers and students | Map fossil distribution across time and place |
| Data scientists and educators | Feed biodiversity and macroevolution models |
| Museum and collection staff | Cross-reference specimens with literature |

### 📋 What the Paleobiology Database Fossils Scraper does

It calls the PBDB occurrences endpoint for a taxon name you provide and walks the returned records, returning one row per fossil occurrence. For every occurrence it captures the taxon name and rank, the occurrence and collection identifiers, the geologic interval and early/late age in millions of years (Ma), the reference identifier, the country, latitude and longitude, and the rock formation. Optional interval and country filters narrow the search.

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

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `baseName` | string | No (defaults to `Tyrannosaurus`) | Taxonomic name to search. Hierarchical, so a genus, family, or class returns every occurrence beneath it. |
| `interval` | string | No | Named geologic interval such as `Cretaceous`, `Maastrichtian`, or `Miocene`. |
| `country` | select | No | Restrict to one country by ISO code (for example `US`, `CA`, `MN`). |
| `maxItems` | integer | No | Free users limited to 10. Paid users up to 1,000,000. |

**Example 1 — all Tyrannosaurus occurrences:**

```json
{
  "baseName": "Tyrannosaurus",
  "maxItems": 50
}
````

**Example 2 — Cretaceous dinosaurs from the United States:**

```json
{
  "baseName": "Dinosauria",
  "interval": "Cretaceous",
  "country": "US",
  "maxItems": 200
}
```

> ⚠️ **Good to Know:** PBDB queries are hierarchical. A broad name like `Mammalia` or `Trilobita` can match tens of thousands of occurrences, so set `maxItems` to keep runs focused. Geographic fields such as formation, group, member, and county are filled only when the original collection recorded them, so they may be empty on some occurrences.

### 📊 Output

| 🏷 Field | Description |
|---|---|
| 🦴 `taxonName` | Accepted taxonomic name of the occurrence |
| 🏷 `taxonRank` | Rank of the name (species, genus, family, and so on) |
| 🔎 `identifiedName` | Name as originally identified, when it differs |
| 🆔 `occurrenceId` | PBDB occurrence identifier |
| 🗂 `collectionId` | PBDB collection identifier |
| 🧬 `taxonId` | PBDB taxon identifier |
| 🧫 `phylum` | Phylum classification |
| 🐾 `class` | Class classification |
| 📚 `order` | Order classification |
| 👪 `family` | Family classification |
| 🦕 `genus` | Genus classification |
| ⏳ `earlyInterval` | Earliest geologic interval for the occurrence |
| ⌛ `lateInterval` | Latest geologic interval, when bounded |
| ⬆ `earlyAgeMa` | Early age boundary in millions of years |
| ⬇ `lateAgeMa` | Late age boundary in millions of years |
| 🌍 `country` | Country code where the fossil was found |
| 🗺 `state` | State or province |
| 🏘 `county` | County, when recorded |
| 📍 `lat` | Latitude in decimal degrees |
| 📍 `lng` | Longitude in decimal degrees |
| 🪨 `formation` | Geologic formation |
| 🗻 `geologicGroup` | Geologic group, when recorded |
| 🧱 `member` | Geologic member, when recorded |
| 📖 `referenceId` | PBDB bibliographic reference identifier |
| 🕒 `scrapedAt` | Timestamp the record was collected |

**Real sample records:**

```json
[
  {
    "taxonName": "Tyrannosaurus rex",
    "taxonRank": "species",
    "occurrenceId": "occ:139292",
    "collectionId": "col:11917",
    "phylum": "Chordata",
    "class": "Reptilia",
    "family": "Tyrannosauridae",
    "earlyInterval": "Late Maastrichtian",
    "earlyAgeMa": 72.2,
    "lateAgeMa": 66,
    "country": "CA",
    "state": "Alberta",
    "formation": "Scollard",
    "lat": 51.906399,
    "lng": -113.0289,
    "referenceId": "ref:4218"
  },
  {
    "taxonName": "Tyrannosaurus rex",
    "taxonRank": "species",
    "occurrenceId": "occ:139293",
    "collectionId": "col:11918",
    "phylum": "Chordata",
    "class": "Reptilia",
    "family": "Tyrannosauridae",
    "earlyInterval": "Late Maastrichtian",
    "earlyAgeMa": 72.2,
    "lateAgeMa": 66,
    "country": "CA",
    "state": "Alberta",
    "formation": "Scollard",
    "lat": 51.933334,
    "lng": -113.23333,
    "referenceId": "ref:4205"
  },
  {
    "taxonName": "Tyrannosaurus rex",
    "taxonRank": "species",
    "occurrenceId": "occ:220009",
    "collectionId": "col:22657",
    "phylum": "Chordata",
    "class": "Reptilia",
    "family": "Tyrannosauridae",
    "earlyInterval": "Late Campanian",
    "earlyAgeMa": 83.6,
    "lateAgeMa": 72.2,
    "country": "CA",
    "state": "Alberta",
    "formation": "Dinosaur Park",
    "lat": 50.727234,
    "lng": -111.524582,
    "referenceId": "ref:5721"
  }
]
```

### ✨ Why choose this Actor

- Direct line to the PBDB data service, the reference archive for the fossil record.
- One clean row per occurrence, with classification, age, location, and formation already separated into fields.
- Hierarchical taxon search, so one query can pull a genus or an entire class.
- Interval and country filters to scope a study without post-processing.
- Ages returned numerically in millions of years, ready for plotting and modeling.

### 📈 How it compares to alternatives

| Approach | Effort | Structured output | Filters |
|---|---|---|---|
| This Actor | Enter a taxon name | Yes, 24 fields | Interval and country |
| Manual PBDB web download | Build query strings by hand | Partial | Manual |
| Copying from publications | Very high | No | None |

### 🚀 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 Paleobiology Database Fossils Scraper.
3. Enter a taxon name in `baseName`, for example `Triceratops`, `Canis`, or `Trilobita`.
4. Optionally set an `interval` and a `country`, then choose `maxItems`.
5. Run the Actor and collect your fossil occurrence dataset.

### 💼 Business use cases

#### Research and academia

| Need | How it helps |
|---|---|
| Build a taxon occurrence dataset | Pull every record for a clade in one run |
| Study diversity over time | Age fields support range and turnover analysis |

#### Education

| Need | How it helps |
|---|---|
| Teach the fossil record | Real occurrences with ages and locations |
| Student projects | Ready data for maps and timelines |

#### Collections and museums

| Need | How it helps |
|---|---|
| Cross-reference holdings | Match specimens to PBDB collections |
| Trace literature | Reference identifiers link back to sources |

#### Data and analytics

| Need | How it helps |
|---|---|
| Feed biodiversity models | Clean, typed fields per occurrence |
| Build dashboards | Coordinates and ages drive maps and charts |

### 🔌 Automating Paleobiology Database Fossils Scraper

Connect runs to Make, Zapier, Slack, Airbyte, GitHub Actions, or Google Drive through the Apify API and integrations to schedule queries and route fresh occurrence data wherever your team works.

### 🌟 Beyond business use cases

- **Research:** assemble occurrence sets for macroevolution and biogeography studies.
- **Personal:** explore where your favorite prehistoric animals once lived.
- **Non-profit:** support science outreach and museum education programs.
- **Experimentation:** prototype paleo data visualizations and maps.

### 🤖 Ask an AI assistant

Paste your dataset 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 summarize age ranges, cluster occurrences by formation, or draft a methods paragraph.

### ❓ Frequently Asked Questions

**Is the data official?** Yes, it comes from the Paleobiology Database public data service, curated by paleontologists.

**Do I need an API key?** No. The PBDB data service is public and keyless.

**What does `baseName` accept?** Any taxonomic name. The search is hierarchical and includes everything below the name.

**How do the age fields work?** `earlyAgeMa` and `lateAgeMa` give the older and younger boundaries of the occurrence in millions of years.

**Why are some location fields empty?** Formation, group, member, and county appear only when the original collection recorded them.

**Can I filter by time?** Yes, set `interval` to a period, epoch, or age such as `Jurassic` or `Maastrichtian`.

**Can I filter by place?** Yes, set `country` to an ISO code such as `US`, `CN`, or `MN`.

**How many records can I get?** Free runs return up to 10 records. Paid plans return up to 1,000,000.

**What if a taxon has no occurrences?** The run finishes with no records and a note to broaden the search.

**Can I run it on a schedule?** Yes, use Apify scheduling or any connected automation platform.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and native integrations to push occurrence data into your own pipelines, databases, and notebooks.

### 🔗 Recommended Actors

- [Macrostrat Geology Units Scraper](https://apify.com/parseforge) for stratigraphic units by location.
- [GAIA Star Catalog Scraper](https://apify.com/parseforge) for astronomical catalog data.
- [JPL Small-Body Database Scraper](https://apify.com/parseforge) for asteroid and comet records.

> 💡 **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 Paleobiology Database. Only publicly available data is collected.

# Actor input Schema

## `baseName` (type: `string`):

Taxonomic name to search. Returns all fossil occurrences for this taxon and everything below it in the tree (e.g. 'Tyrannosaurus', 'Canis', 'Trilobita', 'Mammalia'). Defaults to Tyrannosaurus (>=5 occurrences).

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

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

## `interval` (type: `string`):

Optional. Restrict results to a named geologic time interval such as a period, epoch or age (e.g. 'Cretaceous', 'Maastrichtian', 'Jurassic', 'Miocene'). Leave empty to return all ages.

## `country` (type: `string`):

Optional. Restrict results to fossils found in one country.

## Actor input object example

```json
{
  "baseName": "Tyrannosaurus",
  "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 = {
    "baseName": "Tyrannosaurus",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/paleobiology-fossils-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 = {
    "baseName": "Tyrannosaurus",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/paleobiology-fossils-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 '{
  "baseName": "Tyrannosaurus",
  "maxItems": 10
}' |
apify call parseforge/paleobiology-fossils-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Paleobiology Database Fossils Scraper",
        "description": "Search the Paleobiology Database by taxon name and pull every fossil occurrence beneath it. Returns taxon, rank, occurrence and collection IDs, geologic interval, early and late age in millions of years, country, coordinates, and formation. Filter by interval or country.",
        "version": "0.1",
        "x-build-id": "wXMnVIPVLYMdmtNJa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~paleobiology-fossils-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-paleobiology-fossils-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~paleobiology-fossils-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-paleobiology-fossils-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~paleobiology-fossils-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-paleobiology-fossils-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": {
                    "baseName": {
                        "title": "Taxon name",
                        "type": "string",
                        "description": "Taxonomic name to search. Returns all fossil occurrences for this taxon and everything below it in the tree (e.g. 'Tyrannosaurus', 'Canis', 'Trilobita', 'Mammalia'). Defaults to Tyrannosaurus (>=5 occurrences)."
                    },
                    "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"
                    },
                    "interval": {
                        "title": "Geologic interval (optional)",
                        "type": "string",
                        "description": "Optional. Restrict results to a named geologic time interval such as a period, epoch or age (e.g. 'Cretaceous', 'Maastrichtian', 'Jurassic', 'Miocene'). Leave empty to return all ages."
                    },
                    "country": {
                        "title": "Country (optional)",
                        "enum": [
                            "",
                            "US",
                            "CA",
                            "MX",
                            "AR",
                            "BR",
                            "GB",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "PL",
                            "RU",
                            "CN",
                            "MN",
                            "IN",
                            "AU",
                            "ZA",
                            "MA",
                            "EG",
                            "TZ",
                            "KE"
                        ],
                        "type": "string",
                        "description": "Optional. Restrict results to fossils found in one country."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```