# James Beard Awards Scraper - Chef & Restaurant Winners (`growth-installations/james-beard-scraper`) Actor

Scrape the complete James Beard Foundation Awards archive (1990-present): every winner, nominee and semifinalist across Restaurant & Chef, Book, Journalism, Broadcast Media, Leadership and Achievement categories. 16,000+ records. Refresh annually or on semifinalist announcement.

- **URL**: https://apify.com/growth-installations/james-beard-scraper.md
- **Developed by:** [Growth Installations](https://apify.com/growth-installations) (community)
- **Categories:** Lead generation, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 award records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## James Beard Awards Scraper - Chef & Restaurant Winners

Scrape the complete James Beard Foundation Awards archive (1990-present): every winner, nominee and semifinalist across Restaurant & Chef, Book, Journalism, Broadcast Media, Leadership and Achievement categories. 16,000+ records. Refresh annually or on semifinalist announcement.

Built for restaurant PR firms, hospitality investors, chef recruiters, food media journalists, culinary schools, restaurant lead-gen platforms.

### What this jamesbeard.org scraper extracts

Every run produces one row per record, with change annotations against your last snapshot, with the following fields:

- **object_id** (string), Algolia record id (Salesforce origin)
- **year** (integer)
- **parent_category** (string), Restaurant & Chef, Book, Journalism, Broadcast Media, Leadership, Achievement
- **category** (string), Specific award category (e.g. Emerging Chef, Outstanding Restaurateur)
- **status** (string), Winner, Nominee, or Semifinalist
- **name** (string), Honoree or entity name
- **restaurant** (string)
- **city** (string)
- **state** (string)
- **type** (string), individual or organization
- **summary** (string), Pre-formatted nomination display string


### Quick start

1. Click **Try for free**.
2. Leave the input at defaults, or paste the recommended input from lower on this page.
3. Click **Start**. The default run finishes in under a minute with a small sample.
4. Open the **Dataset** tab to inspect the shape.
5. Once you like the output, click **Schedule** and pick a cadence. Daily is typical.

### How a run works

1. **Scan**, walks jamesbeard.org from the seed URL.
2. **Fetch**, visits each detail page and extracts the fields listed above.
3. **Diff**, compares each record against the snapshot in your named key-value store, labelling it `new`, `changed` or `unchanged`.
4. **Persist**, the new snapshot is saved for the next run.

#### What is a delta feed and why does it save money?

A delta feed only pays for what changed since your last run. Instead of re-scraping every record each night, this scraper compares against your stored snapshot and only fully processes rows that added, changed or first appeared. Enable `onlyChanged` to skip unchanged rows entirely (they are billed at a discounted rate).

#### What differentiates this scraper?

Definitive US culinary award archive with 30+ years of history and zero direct competitors on the Apify Store. Uses the same public Algolia index that powers the JBF search UI, so records are always in sync with what appears on jamesbeard.org.

### Common use cases

- Annual monitoring of new winners + semifinalist announcements
- Historical status-progression analysis (semifinalist to finalist to winner)
- Restaurant PR firm prospecting by award category and geography
- Chef recruiter shortlists by category and year
- Regional culinary trend analysis (which cities/states rack up which categories)


### How to interpret the fields

#### What does Award status mean?

The James Beard Awards work in three tiers: Semifinalist (about 20-30 per category, announced January), Nominee/Finalist (5 per category, announced March), Winner (1 per category, announced June). This scraper's `status` field reflects the current level.

#### What does Parent category vs category mean?

Parent categories are the top-level buckets (Restaurant & Chef, Book, Journalism, Broadcast Media, Leadership, Achievement). Category is the specific award within (e.g. Emerging Chef, Outstanding Restaurateur, Best Chef Northeast). Filter on parent_category first, then category, for cleanest slice.



### How this compares to alternative scrapers

#### James Beard scraper vs Michelin Guide scraper

Different signals. Michelin is European/international with star ratings and Bib Gourmand tiers. James Beard is US-centric with a chef-industry-jury lens. PR firms and investors typically track both; feed the winner lists into your CRM as separate cohorts.

#### James Beard scraper vs Eater 38 scraper

Eater 38 tracks essential-restaurant lists per city, refreshed by local editors. JBF is national/regional and jury-selected. Complementary: Eater signals current-year buzz; JBF signals sustained excellence.

#### James Beard scraper vs the JBF site's own search

The jamesbeard.org search UI is fine for one-off lookups but rate-limited, non-exportable, and hard to snapshot. This scraper hits the same Algolia index that powers that UI, returns structured JSON at scale, and supports delta mode so you can track status progression year over year.

#### James Beard scraper vs a Michelin + Zagat + Eater combo

Each of these is a different lens. Michelin = European-style star rating (data-driven for a European buyer). Zagat = crowd rating (US mainstream). Eater = editorial buzz. JBF = industry jury. Enterprise CRM cohorts typically merge two or three signals; JBF is the "sustained-excellence" lens.



### How much does it cost to scrape jamesbeard.org?

Pay-per-event pricing:

- **Actor start**: $0.00500 per GB of memory, one event per run.
- **Award record**: $0.00200 per record delivered to the dataset.
- **Award checked, unchanged**: $0.00050 per row when `onlyChanged` is on and the row was unchanged. Roughly 25% the cost of a full record.

There are no per-request charges and no page-count charges. Costs come only from records you actually receive. A scheduled monitor in delta mode typically costs cents per day; a first-time full crawl is the expensive case that the delta model is designed to avoid on subsequent runs.

#### Concrete cost examples

Rule-of-thumb cost per run (assumes primary event only, no delta discount):

- **100 records** = about $0.20 in records + one actor-start fee
- **500 records** = about $1.00
- **1,000 records** = about $2.00
- **10,000 records** = about $20.00

With delta mode + `onlyChanged: true`, a daily monitor of 1,000 properties where 5% change costs roughly **$0.58 per run** (50 full charges + 950 delta-priced skips).

### Common questions

#### Does this scraper need a James Beard account?

No. All records are pulled from the public Algolia index that powers the awards search on jamesbeard.org.

#### How often does the archive update?

New records land on the semifinalist announcement (typically January) and the winner ceremony (typically June). A monthly schedule catches both cycles; weekly is sufficient for real-time coverage during award season.

#### What is the status progression?

Semifinalist to Nominee (finalist) to Winner. This scraper returns the current status; run on a schedule to track which nominees advance each year.

#### Are chef bios and photos included?

No. The public Algolia index does not carry bio text or photo URLs. Only structured award metadata (year, category, name, restaurant, city, state, status).

#### How many total records?

About 16,240 records spanning 1990-2026. Restaurant & Chef is the largest bucket at 10,939 records; Book, Journalism and Broadcast are each about 1,700-1,800.

#### How do I use JBF winner data for restaurant PR pitching?

Pull the annual Winner cohort, filter by parent_category = 'Restaurant & Chef', then split by state/city. PR firms typically pitch trade press and local dailies within two weeks of the June ceremony. Semifinalist announcements (January) and Finalist announcements (March) are separate pitching windows.

#### Can I track the same restaurant across multiple years?

Yes. Restaurants often appear as Semifinalists for several years before winning, or win multiple categories over their history. Group records by the restaurant field, sort by year ascending, to see the full arc.

#### Are semifinalist announcement dates predictable?

Yes. Semifinalists are announced in late January, Finalists in late March, Winners at the June ceremony. Run the scraper on a schedule around each of those three windows for real-time coverage.

#### What's the difference between the JBF Awards and the JBF Cookbook Awards?

The Book category (parent_category='Book') covers cookbooks, food writing, and reference works. Winners and finalists are announced on the same June date but the shortlist logic is separate from the restaurant-chef side.

#### Can I detect newly-added award categories year-over-year?

Yes. Group by year + parent_category + category, diff against the prior snapshot. JBF occasionally introduces new categories (Emerging Chef, Best New Restaurant, Outstanding Bakery, etc.) which show up as brand-new category values for a given year.

#### Does the scraper cover the JBF Impact Awards and Leadership Awards?

Yes. Both Impact Awards (organizational recognition for humane immigrant rights, food workers, etc.) and Leadership Awards (individual honorees for lifetime advocacy) are in the Achievement / Leadership parent categories.

#### How much does it cost to scrape the full 16,240-record archive?

Under $1 in most cases — Algolia is fast, memory footprint is tiny, and there is no proxy cost because the endpoint is public. A weekly incremental refresh with delta mode enabled costs pennies per run.

#### Does this scraper need an account with jamesbeard.org?

No. The scraper reads only public pages. You do not need credentials.

#### Why do I need to enable Apify Proxy?

Most sites at scale trigger rate limits or challenges against datacenter IPs. Apify Proxy (residential recommended) handles this. The default input keeps `useApifyProxy: true`.

#### Why does the state store need a name?

Delta mode compares each run against the previous snapshot. Apify wipes the default (unnamed) key-value store on every run, which would erase the snapshot. A NAMED store (`stateStoreName: "james-beard-scraper-state"`) persists across runs.

#### Can I run in delta mode without paying for unchanged rows?

Yes. Set `onlyChanged: true`. Unchanged rows are billed at the discounted `record-checked` rate; changed rows at the full `award` rate. New rows are always full price.

### Recommended daily-schedule input

```json
{
  "yearFrom": 2024,
  "yearTo": 2026,
  "parentCategories": [],
  "statuses": [],
  "maxItems": 5
}
````

For a full-catalogue first run, raise `maxItems` to `0` (no cap) and leave `onlyChanged: false`. For daily monitoring, set `onlyChanged: true` and keep `maxItems` at `0`.

### Turn it into a live alert with Schedules and Webhooks

Combine this scraper with an Apify **Schedule** and a **Webhook** to get "new listing in my buy box" alerts without writing code.

1. Configure the input with your buy-box filters (yield floor, price ceiling, markets, etc).
2. Create a Schedule (Actor page, right rail, Schedule) at your cadence. Daily 06:00 UTC is typical.
3. Add a Webhook (Integrations tab on this actor):
   - Event: `ACTOR.RUN.SUCCEEDED`
   - URL: your Slack / Discord / Zapier / n8n endpoint
   - Payload template: pass `resource.defaultDatasetId` so the receiver can pull only the delta rows

For Slack, wrap the payload in a `text` field and push through an [incoming webhook](https://api.slack.com/messaging/webhooks). For Zapier or n8n, use the "Webhook by Apify" trigger and map dataset fields to your downstream tool of choice.

Pair this with `onlyChanged: true` and the actor becomes a pure alert feed. Delta-priced rows keep the bill flat on quiet days.

### Related scrapers from this publisher

See other actors under [growth-installations](https://apify.com/growth-installations) for related consumer-intelligence scrapers.

### Video walkthrough

Video walkthrough placeholder. Add a YouTube URL to `readme.video_url` in the yaml to auto-embed once one is published.

### Notes and limits

- Keep concurrency modest to stay polite to jamesbeard.org. Default is 5.
- Field schemas can shift when the target site restyles. If a field starts returning `null`, report it and it will be patched.
- The default input is engineered to complete in under 5 minutes so the platform's daily automated test passes and the actor does not get flagged for maintenance.

### Legal

Data is pulled from the public Algolia index that powers jamesbeard.org's awards search. No login or scraping of gated content. You are responsible for compliance with applicable law and JBF's terms of service.

# Actor input Schema

## `yearFrom` (type: `integer`):

Year from (inclusive)

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

Year to (inclusive)

## `parentCategories` (type: `array`):

Restrict to specific top-level buckets. Empty = all.

## `statuses` (type: `array`):

e.g. \["Winner"], or empty for all (Winner, Nominee, Semifinalist).

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

0 = no cap (crawl all years selected).

## `hitsPerPage` (type: `integer`):

Algolia hits per page

## `onlyChanged` (type: `boolean`):

Delta mode (skip unchanged records)

## `stateStoreName` (type: `string`):

State store name

## `maxRequestRetries` (type: `integer`):

Max Algolia retries

## Actor input object example

```json
{
  "yearFrom": 1990,
  "yearTo": 2026,
  "parentCategories": [],
  "statuses": [],
  "maxItems": 5,
  "hitsPerPage": 500,
  "onlyChanged": false,
  "stateStoreName": "james-beard-state",
  "maxRequestRetries": 3
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("growth-installations/james-beard-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("growth-installations/james-beard-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 '{}' |
apify call growth-installations/james-beard-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "James Beard Awards Scraper - Chef & Restaurant Winners",
        "description": "Scrape the complete James Beard Foundation Awards archive (1990-present): every winner, nominee and semifinalist across Restaurant & Chef, Book, Journalism, Broadcast Media, Leadership and Achievement categories. 16,000+ records. Refresh annually or on semifinalist announcement.",
        "version": "0.0",
        "x-build-id": "qYMWpLHYoVqyvyPuv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/growth-installations~james-beard-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-growth-installations-james-beard-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/growth-installations~james-beard-scraper/runs": {
            "post": {
                "operationId": "runs-sync-growth-installations-james-beard-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/growth-installations~james-beard-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-growth-installations-james-beard-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": {
                    "yearFrom": {
                        "title": "Year from (inclusive)",
                        "minimum": 1990,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Year from (inclusive)",
                        "default": 1990
                    },
                    "yearTo": {
                        "title": "Year to (inclusive)",
                        "minimum": 1990,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Year to (inclusive)",
                        "default": 2026
                    },
                    "parentCategories": {
                        "title": "Parent categories filter",
                        "type": "array",
                        "description": "Restrict to specific top-level buckets. Empty = all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "statuses": {
                        "title": "Award statuses filter",
                        "type": "array",
                        "description": "e.g. [\"Winner\"], or empty for all (Winner, Nominee, Semifinalist).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "0 = no cap (crawl all years selected).",
                        "default": 5
                    },
                    "hitsPerPage": {
                        "title": "Algolia hits per page",
                        "minimum": 20,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Algolia hits per page",
                        "default": 500
                    },
                    "onlyChanged": {
                        "title": "Delta mode (skip unchanged records)",
                        "type": "boolean",
                        "description": "Delta mode (skip unchanged records)",
                        "default": false
                    },
                    "stateStoreName": {
                        "title": "State store name",
                        "type": "string",
                        "description": "State store name",
                        "default": "james-beard-state"
                    },
                    "maxRequestRetries": {
                        "title": "Max Algolia retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Max Algolia retries",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
