# Food Network Scraper | Celebrity Chef Recipes (`parseforge/food-network-scraper`) Actor

Scrape Food Network recipes from top chefs with ingredients, instructions, prep and cook times, servings, ratings, reviews, show references, and tags. Build recipe apps, meal planners, food blogs, and AI cooking datasets with content from famous celebrity chefs and TV shows.

- **URL**: https://apify.com/parseforge/food-network-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Videos, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🍳 Food Network Scraper

> 🚀 **Export Food Network celebrity chef recipes to CSV, JSON, or Excel in seconds.** No API key, no login, no code required.

> 🕒 **Last updated:** 2026-05-22 · **📊 19 fields** per record · **Thousands of recipes** · **US & global cuisine coverage**

Food Network is one of the world's most trusted culinary media brands, home to recipes from celebrity chefs like Ina Garten, Bobby Flay, Giada De Laurentiis, Tyler Florence, Alton Brown, and hundreds more. This actor scrapes recipes directly from foodnetwork.com using structured data - giving you clean, production-ready recipe data including ingredients, step-by-step instructions, star ratings, cook times, difficulty level, and more. No account or API access required.

The data is extracted in real-time from Food Network's own structured JSON-LD markup, ensuring accuracy and completeness across every recipe field.

**Coverage:** Chicken, pasta, beef, seafood, vegetarian, desserts, holiday recipes, quick weeknight dinners, grilled dishes, slow-cooker recipes - searched by any keyword or filtered by chef name.

### Target Audience / Use Cases

| Who | What they build |
|-----|----------------|
| Food bloggers | Celebrity chef trend research and recipe inspiration |
| Nutrition researchers | Large-scale ingredient and calorie datasets |
| Meal planning apps | Recipe database population with curated chef content |
| AI / ML teams | Training data for recipe and culinary language models |
| Grocery / retail | Ingredient demand forecasting based on trending recipes |
| Content marketers | Recipe gap analysis and content calendar research |

### 📋 What the Food Network Scraper does

- Search any keyword (e.g. "chicken pasta", "chocolate cake", "beef stew")
- Filter by celebrity chef name (e.g. "Ina Garten", "Bobby Flay", "Giada De Laurentiis")
- Paginate through search results to collect as many recipes as needed
- Extract full structured data from each recipe page: ingredients, step-by-step instructions, ratings, times, difficulty level
- Export to CSV, Excel, JSON, or XML with one click
- Works without login or API key

> 💡 **Why it matters:** Food Network hosts thousands of recipes from the world's most recognized culinary personalities. This dataset is essential for recipe apps, nutrition tools, AI training pipelines, and anyone building food-related products with trusted, chef-developed content.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | string | No | Search term to find recipes (e.g. "chicken pasta", "chocolate cake"). Default: "chicken" |
| `maxItems` | integer | No | Max recipes to collect. Free users limited to 10. |
| `chef` | string | No | Optional celebrity chef filter (e.g. "Ina Garten", "Bobby Flay") |

**Example 1 - Basic search:**
```json
{
  "searchQuery": "chicken pasta",
  "maxItems": 50
}
````

**Example 2 - Chef-specific search:**

```json
{
  "searchQuery": "chicken",
  "chef": "Ina Garten",
  "maxItems": 100
}
```

> ⚠️ **Good to Know:** Free users are limited to 10 recipes per run. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock up to 1,000,000 recipes per run.

### 📊 Output

Each recipe record contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| 🖼 `imageUrl` | string | Main recipe photo URL |
| 📌 `title` | string | Recipe name |
| 📝 `description` | string | Recipe summary / intro text |
| 👤 `author` | string | Celebrity chef or recipe creator |
| ⭐ `rating` | number | Aggregate star rating (1-5) |
| 💬 `reviewCount` | number | Total number of user reviews |
| 🥕 `ingredients` | array | Full ingredient list with quantities |
| 📋 `instructions` | array | Step-by-step cooking instructions |
| ⏱ `prepTime` | string | Preparation time (e.g. "15 min") |
| 🍳 `cookTime` | string | Cook time (e.g. "25 min") |
| ⏰ `totalTime` | string | Total time from start to finish |
| 🍽 `servings` | string | Number of servings (e.g. "4 servings") |
| 📊 `level` | string | Difficulty level (Easy / Medium / Advanced) |
| 🏷 `tags` | array | Recipe tags and keywords |
| 📁 `category` | string | Recipe category (e.g. "main-dish", "dessert") |
| 🔗 `url` | string | Source URL on foodnetwork.com |
| 📅 `publishedAt` | string | Original publish date (ISO 8601) |
| 🕒 `scrapedAt` | string | Timestamp when the record was scraped |
| ❌ `error` | string | Error message if scraping failed for this URL |

**Sample record:**

```json
{
  "imageUrl": "https://food.fnr.sndimg.com/content/dam/images/food/fullset/2009/6/11/0/EI1A09_22307_s4x3.jpg.rend.hgtvcom.1280.1280.suffix/1382538921946.webp",
  "title": "Chicken Piccata",
  "description": "For dinner this week, make Giada De Laurentiis' famous Chicken Piccata recipe, a comforting Italian classic made with lemon, butter and capers.",
  "author": "Giada De Laurentiis",
  "rating": 4.7,
  "reviewCount": 2931,
  "ingredients": [
    "2 skinless and boneless chicken breasts, butterflied and then cut in half",
    "Sea salt and freshly ground black pepper",
    "All-purpose flour, for dredging",
    "6 tablespoons unsalted butter",
    "5 tablespoons extra-virgin olive oil",
    "1/3 cup fresh lemon juice",
    "1/2 cup chicken stock",
    "1/4 cup brined capers, rinsed",
    "1/3 cup fresh parsley, chopped"
  ],
  "instructions": [
    "Season chicken with salt and pepper. Dredge chicken in flour and shake off excess.",
    "In a large skillet over medium high heat, melt 2 tablespoons of butter with 3 tablespoons olive oil...",
    "Into the pan add the lemon juice, stock and capers. Return to stove and bring to boil..."
  ],
  "prepTime": "15 min",
  "cookTime": "25 min",
  "totalTime": "40 min",
  "servings": "4 servings",
  "level": "Medium",
  "tags": [],
  "category": "main-dish",
  "url": "https://www.foodnetwork.com/recipes/giada-de-laurentiis/chicken-piccata-recipe2-1913809",
  "publishedAt": "2015-07-22T10:04:09.938-04:00",
  "scrapedAt": "2026-05-22T03:19:48.516Z",
  "error": null
}
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---------|---------|
| 🔑 No API key needed | Just click Run - no account setup |
| 👨‍🍳 Celebrity chef filter | Search by specific chef names like Ina Garten or Bobby Flay |
| 📊 19 structured fields | Ingredients, instructions, times, ratings, difficulty - all in one record |
| ⚡ Fast extraction | Uses JSON-LD structured data for reliable, fast scraping |
| 🌐 Residential proxy | Automatically routes through residential IPs for stable access |
| 📁 Multiple export formats | CSV, Excel, JSON, XML - download instantly |
| 🔄 Real-time data | Every run fetches live data directly from foodnetwork.com |
| 💯 100% field coverage | All key recipe metadata extracted and validated |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual copy-paste | Other scrapers |
|---------|-----------|------------------|----------------|
| Chef name filter | ✅ | ❌ | Rare |
| JSON-LD extraction | ✅ | ❌ | Varies |
| Residential proxy | ✅ | N/A | Sometimes |
| Structured ingredients | ✅ | ❌ | Sometimes |
| Step-by-step instructions | ✅ | Manual | Sometimes |
| Difficulty level | ✅ | Manual | Rare |
| Star ratings | ✅ | Manual | Sometimes |
| Review counts | ✅ | Manual | Sometimes |
| Export to CSV/Excel | ✅ | ❌ | Sometimes |
| No code required | ✅ | ✅ | Varies |

### 🚀 How to use

1. Open the Food Network Scraper on Apify
2. Enter a search query (e.g. "chicken pasta") or chef name (e.g. "Ina Garten")
3. Set `maxItems` to control how many recipes to collect
4. Click **Start** and wait 30-60 seconds
5. Download your dataset in CSV, Excel, JSON, or XML format

### 💼 Business use cases

#### Recipe App Development

Seed your meal planning or recipe app with thousands of chef-developed, professionally tested recipes from Food Network's full catalog. Use the structured ingredients and step-by-step instructions to power smart shopping lists, cook mode UI, and difficulty filtering.

#### Nutrition and Health Research

Analyze ingredient patterns, calorie ranges, and cooking times across thousands of recipes from named chefs. Cross-reference cuisine types, serving sizes, and cooking methods for academic or commercial nutrition research.

#### AI Training Data

Build recipe-aware language models, ingredient substitution systems, or culinary assistant chatbots using structured recipe data from Food Network's chef-curated catalog - complete with ratings and review counts for quality signals.

#### Content Strategy and SEO

Research which recipe categories, chefs, and cuisines drive the most engagement on Food Network. Use rating distributions and review counts to identify high-performing recipe patterns for your own food content strategy.

### 🔌 Automating Food Network Scraper

Connect this actor to your favorite tools using Apify's built-in integrations:

- **Make (Integromat)** - Trigger a run on a schedule, send results to Google Sheets
- **Zapier** - Push new recipes to Airtable, Notion, or your CRM
- **Slack** - Alert your team when a new batch of recipes is ready
- **Google Sheets** - Auto-populate a recipe database sheet daily
- **Webhook** - Push results to your own backend as soon as the run completes

### 🌟 Beyond business use cases

#### Research and Education

Academics studying culinary trends, flavor pairing science, or the history of American television food culture can use this dataset to trace recipe evolution across decades of Food Network programming.

#### Creative Projects

Writers, food stylists, and culinary educators can pull recipe collections by chef or category to build themed cookbooks, class curricula, or content for culinary school training programs.

#### Non-Profit and Community

Food banks, community kitchens, and nutrition non-profits can use structured recipe data to plan balanced menus at scale, matching available ingredients to tested, chef-approved preparations.

#### Personal Experimentation

Home cooks and food enthusiasts can build personal recipe archives, analyze the ingredient overlap across their favorite chefs, or build a custom meal plan generator using real Food Network data.

### 🤖 Ask an AI assistant about this scraper

You can paste this actor's URL or README into ChatGPT, Claude, or Gemini and ask questions like:

- "How do I get the top 100 recipes by Ina Garten?"
- "Can I filter by difficulty level?"
- "How do I connect this to Google Sheets?"
- "What's the best way to use this data for a meal planning app?"

### ❓ Frequently Asked Questions

#### ❓ Does this require a Food Network account?

No. All data is scraped from public recipe pages. No login or account is needed.

#### ❓ Can I filter by specific chef?

Yes. Enter the chef's name in the `chef` field (e.g. "Ina Garten", "Bobby Flay", "Giada De Laurentiis").

#### ❓ How many recipes can I scrape?

Free users are limited to 10 recipes per run. Paid users can collect up to 1,000,000 recipes per run.

#### ❓ What export formats are available?

CSV, Excel (XLSX), JSON, XML, and JSONL are all available directly from the Apify dataset view.

#### ❓ How often is the data updated?

Every run fetches live data in real-time from foodnetwork.com. There is no cached or stale data.

#### ❓ Are ingredients and instructions fully extracted?

Yes. Ingredients come as a structured array with quantities and measurements. Instructions are extracted as an ordered array of steps.

#### ❓ Does the `level` field indicate difficulty?

Yes. Food Network labels recipes as Easy, Medium, or Advanced. This scraper extracts that label for every recipe that includes it.

#### ❓ Are ratings from all users or just registered accounts?

Ratings and review counts are from the aggregate displayed on each recipe page, which includes all verified Food Network user reviews.

#### ❓ Can I scrape recipes by category?

Use your search query to target categories (e.g. "dessert", "vegetarian", "grilling"). The scraper will return the most relevant results from Food Network's search.

#### ❓ What happens if a recipe page fails to load?

The scraper includes automatic retry logic with residential proxies. Failed pages are skipped and logged. If no recipes are found, a single error record is pushed to the dataset.

#### ❓ Is this compliant with Food Network's terms of service?

This actor accesses publicly available recipe pages the same way a browser does. Use responsibly and review foodnetwork.com's terms of service for your specific use case.

#### ❓ Can I run this on a schedule?

Yes. Use Apify's built-in scheduler to run this actor daily, weekly, or on any cron schedule to keep your recipe database up to date.

### 🔌 Integrate with any app

This actor integrates with every platform that connects to Apify:

**Spreadsheets:** Google Sheets, Microsoft Excel, Airtable\
**Automation:** Make (Integromat), Zapier, n8n, Activepieces\
**Databases:** PostgreSQL, MySQL, MongoDB, Supabase\
**Storage:** Google Drive, Amazon S3, Dropbox\
**Messaging:** Slack, Microsoft Teams, Discord\
**BI Tools:** Tableau, Power BI, Looker Studio\
**Code:** Python (via Apify Client), Node.js, REST API

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [Allrecipes Scraper](https://apify.com/parseforge/allrecipes-scraper) | Millions of community recipes from Allrecipes with ratings, nutrition, and instructions |
| [Epicurious Scraper](https://apify.com/parseforge/epicurious-scraper) | Bon Appetit and Epicurious professional recipes with chef notes |
| [BBC Good Food Scraper](https://apify.com/parseforge/bbcgoodfood-scraper) | UK's most popular recipe site - thousands of tested recipes by skill level |
| [Simply Recipes Scraper](https://apify.com/parseforge/simplyrecipes-scraper) | Simple, family-friendly recipes with clear instructions and images |
| [Tasty Scraper](https://apify.com/parseforge/tasty-scraper) | BuzzFeed's viral recipe collection with video links and quick prep times |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 100+ ready-to-use data scrapers across food, finance, jobs, real estate, and more.

***

**Disclaimer:** This actor is an independent tool and is not affiliated with, endorsed by, or connected to Food Network, Discovery Inc., or Warner Bros. Discovery. All trademarks and recipe content belong to their respective owners. Use this tool responsibly and in accordance with the target website's terms of service.

# Actor input Schema

## `searchQuery` (type: `string`):

Search term to find recipes (e.g. 'chicken pasta', 'chocolate cake', 'beef stew')

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

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

## `chef` (type: `string`):

Optional celebrity chef filter (e.g. 'Ina Garten', 'Bobby Flay', 'Giada De Laurentiis'). Leave empty to search all chefs.

## Actor input object example

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Food Network Scraper | Celebrity Chef Recipes",
        "description": "Scrape Food Network recipes from top chefs with ingredients, instructions, prep and cook times, servings, ratings, reviews, show references, and tags. Build recipe apps, meal planners, food blogs, and AI cooking datasets with content from famous celebrity chefs and TV shows.",
        "version": "0.1",
        "x-build-id": "yoTCX59vv06fy7lYP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~food-network-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-food-network-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~food-network-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-food-network-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~food-network-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-food-network-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term to find recipes (e.g. 'chicken pasta', 'chocolate cake', 'beef stew')"
                    },
                    "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"
                    },
                    "chef": {
                        "title": "Chef Name",
                        "type": "string",
                        "description": "Optional celebrity chef filter (e.g. 'Ina Garten', 'Bobby Flay', 'Giada De Laurentiis'). Leave empty to search all chefs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
