# Nobel Prize Laureates Scraper (`parseforge/nobel-prize-laureates-scraper`) Actor

Pull every Nobel Prize laureate from the official Nobel Prize API. Search by name, filter by category and award year, or sweep a full range. Returns award motivation, prize share, birth country, affiliations, and biography. Great for research, journalism, and trivia builders.

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

## Pricing

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

## 🏅 Nobel Prize Laureates Scraper

> 🚀 **Export every Nobel Prize laureate in seconds.** Pull the full roster of 1,000+ laureates from the official Nobel Prize API, complete with category, award year, motivation, prize share, and biography.

> 🕒 **Last updated:** 2026-06-04 · **📊 22 fields** per record · 1,018 laureates from 1901 to today · 6 prize categories

The Nobel Prize Laureates Scraper turns the official Nobel Prize API into a clean, structured feed of award winners. Search by name, filter by category and year, sweep an entire decade with a year range, or browse the complete list. Every record carries the laureate identity, the prize that made them famous, and the full biography behind it.

Coverage spans all six categories (Chemistry, Economic Sciences, Literature, Peace, Physics, and Physiology or Medicine) for every year prizes were awarded since 1901. Each laureate includes their award motivation, prize share, prize amount, awarding institution, birth and death details, and links to their official Nobel page, Wikipedia, and Wikidata entries.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Researchers and academics | Building datasets on scientific and cultural achievement |
| Journalists and educators | Fact checking, timelines, and classroom material |
| Data scientists and analysts | Trend analysis across categories, countries, and decades |
| Trivia and content creators | Quiz banks, articles, and reference pages |
| Developers and app builders | Powering apps with structured laureate data |

### 📋 What the Nobel Prize Laureates Scraper does

This Actor connects to the official Nobel Prize API and returns structured laureate records. It auto detects the right mode from your input:

- **Name search** finds laureates whose full, given, or family name matches your text.
- **Category and year** narrows to one category in one year.
- **Year range** sweeps every laureate awarded between two years.
- **Browse all** walks the complete list of 1,018 laureates when no filter is set.

For each laureate it returns identity fields, a flattened headline prize, birth and death biography, official links, and a full array of every prize that person won (some laureates won more than once).

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

### ⚙️ Input

| Field | Key | Type | Description |
|---|---|---|---|
| Name Search | `searchName` | string | Find laureates by name. Takes priority over other filters. |
| Prize Category | `nobelPrizeCategory` | select | One of Chemistry, Economic Sciences, Literature, Peace, Physics, Physiology or Medicine. |
| Prize Year (from) | `nobelPrizeYear` | integer | Single award year, or the lower bound of a range. |
| Year To | `yearTo` | integer | Upper bound of a year range. Requires Prize Year (from). |
| Max Items | `maxItems` | integer | How many laureates to collect. Free plan caps at 10. |

**Example 1 — every laureate from 2018 to 2020:**

```json
{
    "nobelPrizeYear": 2018,
    "yearTo": 2020,
    "maxItems": 50
}
````

**Example 2 — search by name:**

```json
{
    "searchName": "curie",
    "maxItems": 10
}
```

> ⚠️ **Good to Know:** When a name search is provided, category and year filters are ignored so the search stays focused. To filter by category, leave the name field empty. A year range needs both Prize Year (from) and Year To, where Year To is greater than or equal to the start year.

### 📊 Output

| Field | Key | Description |
|---|---|---|
| 👤 Full Name | `fullName` | Laureate full name in English. |
| 🆔 ID | `id` | Official Nobel Prize laureate ID. |
| ⚧ Gender | `gender` | Recorded gender of the laureate. |
| 🏅 Category | `category` | Category of the headline prize. |
| 📅 Award Year | `awardYear` | Year the headline prize was awarded. |
| 📜 Motivation | `motivation` | Official reason for the award. |
| 🍰 Prize Share | `prizeShare` | Portion of the prize, such as 1/3 or 1. |
| 🗓 Date Awarded | `dateAwarded` | Date the prize was announced. |
| 🎂 Birth Date | `birthDate` | Date of birth. |
| 🌍 Birth Country | `birthCountry` | Country of birth. |
| ⚰️ Death Date | `deathDate` | Date of death, when applicable. |
| 🔗 Nobel Page | `nobelUrl` | Official Nobel Prize facts page. |
| 📚 Wikipedia | `wikipediaUrl` | English Wikipedia article. |
| 🏛 Prizes | `prizes` | Full array of every prize won, with motivation, amount, and affiliations. |
| 🕒 Scraped At | `scrapedAt` | Timestamp of collection. |

**Sample record 1 — 2019 Chemistry laureate:**

```json
{
    "id": "978",
    "fullName": "Akira Yoshino",
    "gender": "male",
    "category": "Chemistry",
    "awardYear": 2019,
    "motivation": "for the development of lithium-ion batteries",
    "prizeShare": "1/3",
    "dateAwarded": "2019-10-09",
    "birthDate": "1948-01-30",
    "birthCountry": "Japan",
    "wikipediaUrl": "https://en.wikipedia.org/wiki/Akira_Yoshino",
    "nobelUrl": "https://www.nobelprize.org/laureate/978",
    "prizes": [
        {
            "awardYear": 2019,
            "category": "Chemistry",
            "motivation": "for the development of lithium-ion batteries",
            "prizeShare": "1/3",
            "prizeAmount": 9000000,
            "affiliations": [
                { "name": "Asahi Kasei Corporation", "city": "Tokyo", "country": "Japan" },
                { "name": "Meijo University", "city": "Nagoya", "country": "Japan" }
            ]
        }
    ],
    "scrapedAt": "2026-06-04T19:28:48.275Z",
    "error": null
}
```

**Sample record 2 — 2019 Economic Sciences laureate:**

```json
{
    "id": "982",
    "fullName": "Abhijit Banerjee",
    "gender": "male",
    "category": "Economic Sciences",
    "awardYear": 2019,
    "motivation": "for their experimental approach to alleviating global poverty",
    "prizeShare": "1/3",
    "birthCountry": "India",
    "nobelUrl": "https://www.nobelprize.org/laureate/982",
    "scrapedAt": "2026-06-04T19:28:48.275Z",
    "error": null
}
```

**Sample record 3 — 2019 Peace laureate:**

```json
{
    "id": "981",
    "fullName": "Abiy Ahmed Ali",
    "gender": "male",
    "category": "Peace",
    "awardYear": 2019,
    "motivation": "for his efforts to achieve peace and international cooperation, and in particular for his decisive initiative to resolve the border conflict with neighbouring Eritrea",
    "prizeShare": "1",
    "birthCountry": "Ethiopia",
    "nobelUrl": "https://www.nobelprize.org/laureate/981",
    "scrapedAt": "2026-06-04T19:28:48.275Z",
    "error": null
}
```

### ✨ Why choose this Actor

- **Official source.** Data comes straight from the Nobel Prize API, not a scraped mirror.
- **Four search modes in one.** Name, category, year, year range, or browse all, auto detected from your input.
- **Complete biography.** Birth and death places, affiliations, motivation, and prize amount in every record.
- **Multi prize aware.** Laureates who won more than once carry all their prizes in one array.
- **Clean, flat fields.** Headline category and year are surfaced for instant sorting and filtering.

### 📈 How it compares to alternatives

| Approach | Setup | Structured output | Full biography | Multi prize | Maintenance |
|---|---|---|---|---|---|
| This Actor | None | Yes, 22 fields | Yes | Yes | Handled for you |
| Manual API calls | Write your own client | Raw nested data | Manual flattening | Manual | You own it |
| Copy from Wikipedia | Hours of editing | No | Inconsistent | Easy to miss | Constant |

### 🚀 How to use

1. **Sign up for a free Apify account** using [this link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Nobel Prize Laureates Scraper from your Apify console.
3. Choose a mode. Enter a name, or pick a category and year, or set a year range, or leave everything empty to browse all.
4. Set Max Items and click Start.
5. When the run finishes, download your results or pull them from the dataset endpoint into your own tools.

### 💼 Business use cases

#### Media and publishing

| Goal | How |
|---|---|
| Build award timelines | Pull a year range and sort by category. |
| Fact check articles | Search a name and read the official motivation. |

#### Education

| Goal | How |
|---|---|
| Classroom datasets | Browse all laureates for a teaching exercise. |
| Quiz and trivia banks | Filter by category for themed question sets. |

#### Research and analytics

| Goal | How |
|---|---|
| Country level analysis | Use birth country across decades of laureates. |
| Institution tracking | Read affiliations to map prizes to universities. |

#### Apps and products

| Goal | How |
|---|---|
| Power a reference app | Feed structured records into your own database. |
| Enrich profiles | Match a person to their Nobel page and Wikipedia link. |

### 🔌 Automating Nobel Prize Laureates Scraper

Connect this Actor to the tools you already use:

- **Make** and **Zapier** for no code workflows.
- **Slack** alerts when a run completes.
- **Airbyte** to sync results into a warehouse.
- **GitHub Actions** to schedule recurring runs.
- **Google Drive** to archive each run automatically.

### 🌟 Beyond business use cases

- **Research.** Study patterns in who wins, where, and for what.
- **Personal.** Build a reading list from Literature laureates.
- **Non profit.** Support education and outreach with verified data.
- **Experimentation.** Train and test models on a clean, well known dataset.

### 🤖 Ask an AI assistant

Drop your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask questions like which country produced the most Physics laureates, or summarize every Peace prize motivation from the last decade.

### ❓ Frequently Asked Questions

**Is this affiliated with the Nobel Foundation?**
No. This is an independent tool that reads the public Nobel Prize API.

**How many laureates are available?**
The API currently lists 1,018 laureates across all categories and years.

**Which years are covered?**
Every year prizes were awarded, starting in 1901.

**What categories can I filter by?**
Chemistry, Economic Sciences, Literature, Peace, Physics, and Physiology or Medicine.

**Can I search by name?**
Yes. The name search matches full, given, and family names.

**Do some laureates have more than one prize?**
Yes. Those laureates carry every prize in the prizes array.

**What is prize share?**
The portion of the prize the laureate received, such as 1/3 or 1.

**Does it include affiliations?**
Yes, when the API records them, including the awarding institution and its city and country.

**Are death details included?**
Yes for laureates who have died. Living laureates have empty death fields.

**Is there a free tier?**
Yes. Free runs are capped at 10 laureates per run. Paid plans go up to 1,000,000.

**How current is the data?**
It reflects the official Nobel Prize API at the time of each run.

**Can I run it on a schedule?**
Yes. Use Apify schedules or any external trigger to refresh after each annual announcement.

### 🔌 Integrate with any app

Pull results straight from the dataset endpoint into your own stack, or wire the Actor into Make, Zapier, or a custom webhook to push data wherever you need it.

### 🔗 Recommended Actors

- [OpenAQ Air Quality Scraper](https://apify.com/parseforge) for open environmental data.
- [UK Postcodes IO Scraper](https://apify.com/parseforge) for geographic lookups.
- [Libraries.io Scraper](https://apify.com/parseforge) for open source package data.
- [OpenChargeMap Scraper](https://apify.com/parseforge) for global EV charging points.
- [DBnomics Economic Series Scraper](https://apify.com/parseforge) for macroeconomic time series.

> 💡 **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 Nobel Foundation or NobelPrize.org. Only publicly available data from the official Nobel Prize API is collected.

# Actor input Schema

## `searchName` (type: `string`):

Search laureates by name (full, given, or family name). Example: curie, einstein, mandela. Leave empty to browse by category, year, or all laureates.

## `nobelPrizeCategory` (type: `string`):

Filter by Nobel Prize category. Combine with a year or year range to narrow results.

## `nobelPrizeYear` (type: `integer`):

Filter by the year a prize was awarded. Use alone for a single year, or together with Year To for a range. Nobel Prizes have been awarded since 1901.

## `yearTo` (type: `integer`):

Upper bound for a year range. Requires Prize Year (from). Example: from 2018 to 2020 returns every laureate awarded in those three years.

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

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

## Actor input object example

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

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nobel-prize-laureates-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 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/nobel-prize-laureates-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
}' |
apify call parseforge/nobel-prize-laureates-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Nobel Prize Laureates Scraper",
        "description": "Pull every Nobel Prize laureate from the official Nobel Prize API. Search by name, filter by category and award year, or sweep a full range. Returns award motivation, prize share, birth country, affiliations, and biography. Great for research, journalism, and trivia builders.",
        "version": "0.1",
        "x-build-id": "VLRw0RNbA6gHSb3p7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~nobel-prize-laureates-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-nobel-prize-laureates-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~nobel-prize-laureates-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-nobel-prize-laureates-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~nobel-prize-laureates-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-nobel-prize-laureates-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": {
                    "searchName": {
                        "title": "Name Search",
                        "type": "string",
                        "description": "Search laureates by name (full, given, or family name). Example: curie, einstein, mandela. Leave empty to browse by category, year, or all laureates."
                    },
                    "nobelPrizeCategory": {
                        "title": "Prize Category",
                        "enum": [
                            "che",
                            "eco",
                            "lit",
                            "pea",
                            "phy",
                            "med"
                        ],
                        "type": "string",
                        "description": "Filter by Nobel Prize category. Combine with a year or year range to narrow results."
                    },
                    "nobelPrizeYear": {
                        "title": "Prize Year (from)",
                        "minimum": 1901,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Filter by the year a prize was awarded. Use alone for a single year, or together with Year To for a range. Nobel Prizes have been awarded since 1901."
                    },
                    "yearTo": {
                        "title": "Year To",
                        "minimum": 1901,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Upper bound for a year range. Requires Prize Year (from). Example: from 2018 to 2020 returns every laureate awarded in those three years."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
