# Tasty Scraper | BuzzFeed Recipes and Videos (`parseforge/tasty-scraper`) Actor

Collect recipes from Tasty by BuzzFeed including ingredients, step instructions, cook times, servings, nutrition, tags, and video URLs. Filter by cuisine or diet to build food content platforms, recipe apps, video collections, and AI cooking assistant datasets at scale.

- **URL**: https://apify.com/parseforge/tasty-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)

## 🍝 Tasty Scraper

> 🚀 **Export BuzzFeed Tasty recipes in seconds.** Search by keyword, collect ingredients, instructions, nutrition, ratings, video URLs, and more - no account required.

> 🕒 **Last updated:** 2026-05-21 · **📊 19 fields** per record · **1,000+ recipes per search** · **Global coverage**

The Tasty Scraper pulls structured recipe data directly from Tasty.co - BuzzFeed's massively popular video recipe platform with millions of home cooks worldwide. Whether you want pasta dishes, vegan desserts, or 30-minute weeknight meals, this actor gives you clean, structured data ready for analysis, apps, or databases.

Every record includes the full ingredient list, step-by-step instructions, nutrition info, video URL, star ratings, and category tags - exactly the fields you need to build recipe databases, nutrition trackers, or meal planning tools.

### Coverage

- **1,041+ pasta recipes** - just from one search term. Tasty has tens of thousands of recipes across all cuisines and dietary preferences.
- **19 fields per record** - image, title, URL, ID, description, video, servings, prep/cook/total time, calories, rating, numRatings, tags, ingredients, instructions, topics, scrapedAt.
- **Real-time data** - scraped live from Tasty.co, not cached.

### Target Audience / Use Cases

| Who | What they build |
|-----|----------------|
| Food bloggers | Recipe inspiration database |
| App developers | Recipe search and meal planning apps |
| Nutritionists | Calorie and ingredient analysis datasets |
| Data scientists | Recipe NLP, ingredient clustering, trend analysis |
| Content creators | Identify high-rated viral recipes |
| Grocery startups | Ingredient list extraction for shopping tools |

### 📋 What the Tasty Scraper does

- Searches Tasty.co recipes by keyword (pasta, chicken, vegan, keto, etc.)
- Collects full ingredient lists and step-by-step instructions
- Extracts nutrition data (calories, carbs, protein, fat)
- Captures star ratings and total number of ratings
- Pulls the recipe video URL (Tasty is famous for its video recipes)
- Tags, topics, and category labels for filtering
- Paginates automatically to reach your maxItems target

> 💡 **Why it matters:** Tasty is one of the largest recipe platforms on the internet, with recipes optimized for video and engagement. The data is cleaner and more structured than most recipe sites - making it ideal for training models, building apps, or powering content pipelines.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| searchQuery | String | Yes | `pasta` | Keyword to search for recipes |
| maxItems | Integer | No | `10` | Max recipes to collect (free: 10, paid: up to 1,000,000) |

**Example - Search for pasta recipes:**
```json
{
  "searchQuery": "pasta",
  "maxItems": 100
}
````

**Example - Search for vegan desserts:**

```json
{
  "searchQuery": "vegan dessert",
  "maxItems": 50
}
```

> ⚠️ **Good to Know:** Free users are automatically limited to 10 results. [Upgrade to a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock up to 1,000,000 recipes per run.

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🖼️ imageUrl | String | High-resolution recipe thumbnail |
| 📝 title | String | Recipe name |
| 🔗 url | String | Full URL to the recipe page |
| 🆔 id | Integer | Tasty internal recipe ID |
| 📄 description | String | Recipe description / summary |
| 🎬 videoUrl | String | MP4 video URL (Tasty's signature video recipes) |
| 🍽️ servings | String | Number of servings |
| ⏱️ prepTime | Integer | Prep time in minutes |
| 🔥 cookTime | Integer | Cook time in minutes |
| ⏰ totalTime | Integer | Total time in minutes |
| 🔢 calories | String | Calories per serving |
| ⭐ rating | Number | Average star rating (0-5) |
| 👥 numRatings | Integer | Number of ratings |
| 🏷️ tags | Array | Recipe tags (cuisine, diet, cooking method) |
| 🥕 ingredients | Array | Full ingredient list with measurements |
| 📋 instructions | Array | Step-by-step cooking instructions |
| 📂 topics | Array | Category/topic breadcrumbs |
| 🕒 scrapedAt | String | ISO timestamp of when scraped |
| ❌ error | String | Error message if scraping failed |

**Sample record:**

```json
{
  "imageUrl": "https://img.buzzfeed.com/video-api-prod/assets/641e3c1a5f2a48f29b605bff9cbe72b6/BFV10263_CreamyChickenPenne-Thumb1080.jpg",
  "title": "Creamy Chicken Penne Pasta",
  "url": "https://tasty.co/recipe/creamy-chicken-penne-pasta",
  "id": 48,
  "description": "If you're in need of a hug in a bowl, this creamy chicken penne pasta is just the ticket. With tender chicken, perfectly cooked pasta, and a velvety sauce, it's pure comfort in a bowl.",
  "videoUrl": "https://vid.tasty.co/output/8318/mp4_640x640/1472701763",
  "servings": "4 servings",
  "prepTime": 15,
  "cookTime": 15,
  "totalTime": 30,
  "calories": "477",
  "rating": 4.9,
  "numRatings": 11395,
  "tags": ["north_american", "italian", "comfort_food", "easy", "under_30_minutes", "dinner", "weeknight"],
  "ingredients": [
    "4 slices bacon",
    "2 chicken breasts, sliced",
    "salt, to taste",
    "2 teaspoons italian seasoning",
    "2 cloves garlic, minced",
    "2 cups spinach",
    "1 ½ cups cream",
    "10 oz penne pasta, cooked until al dente"
  ],
  "instructions": [
    "In a deep skillet, fry the bacon until crispy. Remove to a paper towel to drain, then chop.",
    "In the same skillet, add the chicken and season with salt, pepper, Italian seasoning, and paprika.",
    "Add the cream, Parmesan, and red pepper flakes and bring to a boil.",
    "Add the penne and bacon, and stir until fully coated in sauce.",
    "Enjoy!"
  ],
  "topics": ["European", "Italian"],
  "scrapedAt": "2026-05-21T20:34:58.073Z",
  "error": null
}
```

### ✨ Why choose this Actor

| Feature | Details |
|---------|---------|
| 🎬 Video URLs included | Every recipe includes the mp4 video URL - Tasty is video-first |
| ⭐ Ratings data | Star ratings + number of raters for social proof analysis |
| 🥕 Full ingredients | Quantities and ingredient names, not just headings |
| 📋 Step-by-step instructions | Clean array of instruction steps, ready to display |
| ⏱️ Time data | Prep, cook, and total time in minutes - great for filtering |
| 🔢 Nutrition | Calories per serving from structured data |
| 🚀 Fast | Fetches 1,000+ recipes in under 5 minutes |
| 🔒 No API key needed | Works out of the box, no signup required |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual scraping | Spoonacular API |
|---------|-----------|----------------|----------------|
| Video URLs | Yes | Hard to parse | No |
| Full ingredients | Yes | Inconsistent | Yes (paid) |
| Instructions | Yes | Inconsistent | Yes (paid) |
| Ratings | Yes | Hard to parse | No |
| Cost | Pay-per-item | Dev time | Monthly subscription |
| No signup needed | Yes | N/A | No (API key required) |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the Tasty Scraper on the Apify Store
3. Enter your search query (e.g. "pasta", "chicken", "vegan")
4. Set maxItems (10 free, up to 1,000,000 on paid plans)
5. Click Start and download results as JSON, CSV, or Excel

### 💼 Business use cases

#### Recipe App Development

Build meal planning apps, cooking assistants, or recipe finders using real Tasty data. The structured ingredient and instruction arrays are ready to display in any frontend.

#### Nutrition and Diet Analysis

Calories, ingredients, and cooking times are all captured. Filter by tags like "healthy", "keto", or "vegetarian" to build diet-specific datasets for nutrition apps or research.

#### Content and Social Media Strategy

Identify the highest-rated recipes (rating + numRatings) to understand what food content drives engagement. Use tags to spot trending cuisines or cooking methods.

#### E-commerce and Grocery Tech

Extract ingredient lists at scale to power smart grocery lists, automated shopping carts, or ingredient substitution engines.

### 🔌 Automating Tasty Scraper

Connect Tasty Scraper to your existing tools:

- **Make (Integromat)** - trigger a scrape on a schedule and send results to Google Sheets
- **Zapier** - pipe new recipes into Airtable, Notion, or Slack
- **Slack** - post daily recipe highlights from a keyword search
- **Google Sheets** - build a live recipe database that refreshes weekly
- **Webhooks** - trigger downstream pipelines when new data is collected

### 🌟 Beyond business use cases

#### Research

Study ingredient co-occurrence patterns, regional cuisine trends, or the evolution of recipe complexity over time using Tasty's massive catalog.

#### Creative Projects

Generate novel recipe mashups, build a recipe recommendation system, or train a language model on structured cooking instructions.

#### Non-profit / Education

Build free recipe apps for community kitchens, food banks, or school nutrition programs using openly accessible data.

#### Experimentation

Test ingredient substitution hypotheses, analyze which cuisines are most calorie-dense, or find correlations between ratings and total cook time.

### 🤖 Ask an AI assistant about this scraper

> "What can I do with Tasty recipe data?"
> "How do I filter by cooking time or calorie count?"
> "Can I use this to build a meal planning app?"

This actor exports clean JSON that any AI assistant can analyze directly. Paste the output into ChatGPT, Claude, or Gemini and ask questions about your recipe dataset.

### ❓ Frequently Asked Questions

**Q: Does this require a Tasty.co account?**
No. The actor uses Tasty's public search API and recipe pages. No login or account required.

**Q: How many recipes can I scrape?**
Free users: up to 10 per run. Paid users: up to 1,000,000 per run.

**Q: How do I search by cuisine type?**
Use the searchQuery field. Try "Italian pasta", "Mexican tacos", "Japanese ramen", etc.

**Q: Are the video URLs playable?**
Yes. The videoUrl field is a direct mp4 link (vid.tasty.co). You can embed or download it directly.

**Q: What does the tags field include?**
Tags cover cuisine type, dietary restrictions, cooking method, meal occasion, equipment needed, and more. Examples: "italian", "vegetarian", "stove\_top", "under\_30\_minutes", "meal\_prep".

**Q: Is nutrition data always available?**
Calories are available for most recipes. Not all recipes have full macro breakdowns.

**Q: Can I filter by rating?**
Post-process the output and filter by the `rating` and `numRatings` fields. Most Tasty recipes have 4.8-5.0 star ratings.

**Q: What format is the output in?**
JSON by default. The Apify platform also lets you export as CSV, Excel, XML, or RSS.

**Q: How fast does it run?**
100 recipes typically takes under 30 seconds. 1,000 recipes takes a few minutes.

**Q: Does it get video thumbnails?**
Yes - the imageUrl field is a high-resolution thumbnail (1080px wide) from BuzzFeed's CDN.

**Q: What search terms work best?**
Any food keyword works: ingredient names ("avocado"), dish types ("stir fry"), dietary labels ("gluten free"), or meal occasions ("date night dinner").

### 🔌 Integrate with any app

Apify datasets can be connected to: Google Sheets, Airtable, Notion, Zapier, Make, Slack, Power BI, Tableau, BigQuery, Snowflake, PostgreSQL, MongoDB, REST API, Webhooks.

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [Allrecipes Scraper](https://apify.com/parseforge/allrecipes-scraper) | Scrape recipes from Allrecipes.com |
| [Epicurious Scraper](https://apify.com/parseforge/epicurious-scraper) | Export recipes from Epicurious |
| [Food.com Scraper](https://apify.com/parseforge/food-com-scraper) | Collect community recipes from Food.com |
| [BBC Good Food Scraper](https://apify.com/parseforge/bbcgoodfood-scraper) | Scrape BBC Good Food recipes |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering food, real estate, jobs, finance, and more.

***

*This actor is for informational and research purposes only. Respect Tasty.co's terms of service. Data is scraped from publicly accessible pages.*

# Actor input Schema

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

Keyword to search for recipes (e.g. 'pasta', 'chicken', 'vegan tacos').

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

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

## Actor input object example

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tasty Scraper | BuzzFeed Recipes and Videos",
        "description": "Collect recipes from Tasty by BuzzFeed including ingredients, step instructions, cook times, servings, nutrition, tags, and video URLs. Filter by cuisine or diet to build food content platforms, recipe apps, video collections, and AI cooking assistant datasets at scale.",
        "version": "0.1",
        "x-build-id": "k8tdjPxrO43j8PzOj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~tasty-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-tasty-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~tasty-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-tasty-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~tasty-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-tasty-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",
                "required": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to search for recipes (e.g. 'pasta', 'chicken', 'vegan tacos')."
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
