# Delish Scraper | Easy Recipes and Food Trends (`parseforge/delish-scraper`) Actor

Extract recipes and food trend articles from Delish including ingredients, instructions, prep and cook times, servings, ratings, photos, and tags. Perfect for recipe apps, food content sites, meal planners, and culinary AI training datasets featuring viral and trending recipes.

- **URL**: https://apify.com/parseforge/delish-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Marketing, Other
- **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)

## 🍽 Delish Scraper

> 🚀 **Export Delish recipes to CSV, JSON, Excel, or XML in seconds.** No account, no login, no API key required.

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

The **Delish Scraper** extracts rich recipe data directly from [delish.com](https://www.delish.com/) - one of the most popular food and recipe websites in the world. It uses Delish's server-side rendered pages and JSON-LD structured data to collect accurate, complete recipe records including full ingredient lists, step-by-step instructions, nutrition info, ratings, and more.

Delish publishes thousands of original recipes tested in their professional kitchens, covering everything from quick weeknight dinners to elaborate holiday feasts. This scraper lets you collect that data at scale for research, apps, or business use - no web scraping expertise required.

**Coverage:** All publicly accessible recipe content on Delish.com including cooking, baking, drinks, seasonal specials, and trend-driven content. Search by keyword across the full recipe library.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Food bloggers and creators | Research trending recipes and ingredient combinations |
| Nutrition apps | Build searchable recipe databases with calories and macros |
| Meal planning startups | Populate recipe libraries with real, tested content |
| Food researchers | Analyze cooking trends, ingredient frequencies, and cuisine categories |
| Data journalists | Study food culture and recipe evolution over time |
| Developers | Train NLP models on real recipe instruction text |
| Grocery apps | Map ingredients to shopping lists from popular recipes |
| Home cooks | Download personal recipe collections for offline use |

### 📋 What the Delish Scraper does

- Searches Delish.com for recipes matching your query
- Extracts structured data from JSON-LD on each recipe page
- Falls back to page body data for recipes with incomplete structured data
- Returns complete recipe records: ingredients, instructions, timing, servings, calories, tags
- Handles pagination across multiple search result pages
- Respects free/paid usage limits automatically

> 💡 **Why it matters:** Delish is one of the most-visited food sites in the US, published by Hearst. Their recipes are professionally tested and written by trained chefs and food editors. This data is significantly higher quality than crowdsourced recipe sites.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQuery` | string | `chicken` | Keyword to search for recipes (e.g. "pasta", "chocolate cake", "vegan dinner") |
| `maxItems` | integer | `10` | Number of recipes to scrape. Free users: max 10. Paid users: up to 1,000,000. |

**Example 1 - Quick search:**
```json
{
  "searchQuery": "pasta",
  "maxItems": 10
}
````

**Example 2 - Larger dataset:**

```json
{
  "searchQuery": "chicken dinner",
  "maxItems": 100
}
```

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

### 📊 Output

Each item in the dataset contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| 🖼 `imageUrl` | string | Full-size recipe photo URL |
| 📌 `title` | string | Recipe name (e.g. "Pesto Chicken") |
| 📝 `description` | string | Short intro describing the dish |
| 👤 `author` | string | Recipe developer or editor name |
| ⭐ `rating` | number | Aggregate rating (1-5 scale) |
| 💬 `reviewCount` | integer | Number of user reviews |
| 🥄 `ingredients` | array | Full ingredient list with measurements |
| 📋 `instructions` | array | Step-by-step cooking instructions |
| ⏱ `prepTime` | string | Prep time (e.g. "15 min") |
| 🍳 `cookTime` | string | Cook time (null if not specified separately) |
| ⏰ `totalTime` | string | Total time from start to finish |
| 🍽 `servings` | string | Number of servings (e.g. "4 serving(s)") |
| 🔥 `calories` | string | Calorie count (e.g. "722 Calories") |
| 🏷 `tags` | array | Recipe tags (e.g. \["dinner", "weeknight meals"]) |
| 📂 `category` | string | Category string from recipe metadata |
| 🔗 `url` | string | Direct link to the recipe page |
| 📅 `publishedAt` | string | ISO 8601 publication date |
| 🕒 `scrapedAt` | string | ISO 8601 scrape timestamp |
| ❌ `error` | string | Error message if scraping failed (null on success) |

**Sample record:**

```json
{
  "imageUrl": "https://hips.hearstapps.com/hmg-prod/images/pesto-chicken-index-65d6162224dec.jpg?crop=0.5622727272727273xw:1xh;center,top&resize=1200:*",
  "title": "Pesto Chicken",
  "description": "Looking for an easy date night dinner to impress? Look no further than this easy pesto chicken with homemade pesto and plenty of cheese.",
  "author": "Mary Rupp",
  "rating": 5,
  "reviewCount": 1,
  "ingredients": [
    "2 c. tightly packed fresh basil leaves",
    "1/2 c. extra-virgin olive oil",
    "1/4 c. toasted pine nuts",
    "2 cloves garlic, finely chopped",
    "1 1/2 tsp. kosher salt, divided",
    "1 oz. Parmesan, finely grated (about 1/2 c.)",
    "1 tsp. fresh lemon juice",
    "2 lb. boneless, skinless chicken breasts (3-4)",
    "1/2 c. shredded mozzarella"
  ],
  "instructions": [
    "Preheat oven to 400°. In a food processor, process basil, oil, pine nuts, garlic, and 1/2 teaspoon salt until smooth...",
    "Grease an 11\"-by-8\" baking dish with cooking spray. Pat chicken dry...",
    "Bake chicken 20 minutes. Remove from oven and top with mozzarella..."
  ],
  "prepTime": "15 min",
  "cookTime": null,
  "totalTime": "45 min",
  "servings": "4 serving(s)",
  "calories": "722 Calories",
  "tags": ["date night", "easy chicken", "weeknight meals", "dinner", "main dish", "poultry"],
  "category": "date night, easy chicken, weeknight meals, dinner, main dish, poultry",
  "url": "https://www.delish.com/cooking/recipe-ideas/a42476911/best-pesto-chicken-recipe/",
  "publishedAt": "2023-01-12T21:14:45.091949-0500",
  "scrapedAt": "2026-05-22T03:26:51.000Z",
  "error": null
}
```

### ✨ Why choose this Actor

| Feature | Details |
|---------|---------|
| 🎯 Accurate JSON-LD extraction | Uses Delish's own structured data for clean, reliable output |
| 🔁 Smart fallback | Extracts instructions from page body when JSON-LD is incomplete |
| 🚀 Fast | Typically completes 5 recipes in under 10 seconds |
| 🔒 No credentials needed | Works entirely on public pages |
| 📦 19 output fields | Full recipe data including nutrition, tags, timings, and author |
| 💸 Pay-per-result | Only charged for actual recipe records |
| 🆓 Free preview | First 10 items free, no credit card required |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual scraping | Generic scrapers |
|---------|-----------|----------------|-----------------|
| Structured JSON-LD extraction | Yes | Manual work | Rarely |
| Instructions fallback | Yes | Manual work | No |
| Pagination support | Yes | Manual work | Varies |
| Maintained and updated | Yes | Your responsibility | Rarely |
| Free tier | 10 items | - | Varies |
| Pay-per-result pricing | Yes | - | No |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 free credit)
2. Open the [Delish Scraper](https://apify.com/parseforge/delish-scraper) actor page
3. Click **Try for free**
4. Enter your `searchQuery` (e.g. "pasta", "chocolate cake")
5. Set `maxItems` (default: 10)
6. Click **Start** and wait for the run to finish
7. Download results as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Recipe apps and websites

Build a recipe database for a meal planning app, cooking blog, or food delivery platform. Use the full ingredient lists and instructions to power search, filtering, and recommendation features.

#### Nutrition and diet tools

Collect calorie counts, serving sizes, and ingredient data to build meal trackers, macro calculators, or diet planning tools. All nutrition data comes directly from Delish's tested recipes.

#### Food trend analysis

Monitor which ingredients, cuisines, and cooking techniques are trending on one of the most-visited food sites in the US. The `tags`, `category`, and `publishedAt` fields enable time-series analysis.

#### AI training data

Use the structured instruction steps and ingredient lists to fine-tune language models for recipe generation, ingredient substitution suggestions, or cooking chatbots. Real, tested recipe text is significantly better than synthetic data.

### 🔌 Automating Delish Scraper

Connect this actor to your workflows using:

- **Make (Integromat)** - Schedule runs and send results to Google Sheets, Airtable, or any database
- **Zapier** - Trigger recipes export on a schedule and push to Notion, Slack, or email
- **Apify API** - Call the actor programmatically from any codebase
- **Webhooks** - Get notified when a run completes and process results automatically
- **Apify Scheduler** - Run daily or weekly to keep your recipe database fresh

### 🌟 Beyond business use cases

#### Research and academia

Food scientists and nutritionists can use this data to study recipe evolution, regional cooking differences, or the nutritional profiles of popular published recipes.

#### Creative projects

Writers, photographers, and content creators can use recipe data to plan shoots, find seasonal inspiration, or identify gaps in their niche.

#### Non-profit and education

Nutrition educators can build free recipe tools for communities. Culinary schools can create searchable databases for students.

#### Personal projects

Download your own curated recipe collections, build a private recipe box, or power a Raspberry Pi cooking assistant.

### 🤖 Ask an AI assistant about this scraper

You can ask an AI assistant (ChatGPT, Claude, Gemini):

> "I have a JSON dataset of Delish recipes with fields: title, description, author, rating, reviewCount, ingredients, instructions, prepTime, totalTime, servings, calories, tags, category, url, publishedAt. Help me find recipes under 30 minutes with fewer than 10 ingredients."

Or:

> "Analyze these Delish recipe records and identify which categories appear most frequently in the tags field."

### ❓ Frequently Asked Questions

#### 🤔 Does this require a Delish account?

No. All data is scraped from publicly available pages without any login.

#### 🌍 What recipes are available?

All recipes publicly listed on Delish.com. This includes thousands of recipes across all categories.

#### 📄 What formats can I export to?

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

#### 🔄 How fresh is the data?

Data is scraped in real-time each time you run the actor. There is no caching.

#### ⏱ How fast is it?

In testing, 5 recipes complete in about 8-10 seconds. Larger runs scale proportionally.

#### 💰 How much does it cost?

Free users get 10 recipes per run. Paid plans unlock up to 1,000,000 recipes per run with pay-per-result pricing.

#### 🍳 Why is cookTime sometimes null?

Delish often omits a separate cook time in their structured data, providing only total time. When the underlying data reports 0 seconds for cook time, it is stored as null.

#### 🔢 Why does calories show "722 Calories" instead of just 722?

This is the raw format from Delish's JSON-LD data. It preserves the original string including units.

#### 📊 Can I get multiple pages of results?

Yes. The actor automatically paginates through search results to collect your requested number of items.

#### 🔒 Is this legal?

This actor accesses only publicly available web pages. It does not bypass any authentication, rate limits, or terms of service restrictions beyond normal browser behavior.

#### ❓ What if a recipe has no rating?

The `rating` and `reviewCount` fields will be null for recipes that have not yet received reviews.

#### 🔑 Do I need an API key?

No API key is required. The actor runs entirely on Apify's infrastructure using your account.

### 🔌 Integrate with any app

This actor integrates with the full Apify ecosystem:

- **Google Sheets** - Export directly from the dataset
- **Airtable** - Use the Apify API to populate a base
- **Slack** - Get notified when a run completes
- **Notion** - Push recipe records to a database
- **Make / Zapier** - Build no-code automations
- **REST API** - Integrate with any backend
- **Webhooks** - Trigger workflows on completion
- **CSV / Excel** - One-click download for spreadsheet users

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [Allrecipes Scraper](https://apify.com/parseforge/allrecipes-scraper) | Scrape recipes from Allrecipes with ratings, reviews, and full nutrition data |
| [BBC Good Food Scraper](https://apify.com/parseforge/bbcgoodfood-scraper) | Extract recipes from BBC Good Food including method and tips |
| [Bon Appetit Scraper](https://apify.com/parseforge/bonappetit-scraper) | Collect recipes from Bon Appetit magazine's digital archive |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) to find scrapers for dozens of other food, recipe, and data sources.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** Independent tool, not affiliated with, endorsed by, or sponsored by Delish or Hearst. Only publicly available content is collected. Use responsibly and in accordance with Delish's terms of service.

# Actor input Schema

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

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

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

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

## 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/delish-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/delish-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/delish-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Delish Scraper | Easy Recipes and Food Trends",
        "description": "Extract recipes and food trend articles from Delish including ingredients, instructions, prep and cook times, servings, ratings, photos, and tags. Perfect for recipe apps, food content sites, meal planners, and culinary AI training datasets featuring viral and trending recipes.",
        "version": "0.1",
        "x-build-id": "Ez8397JpIZqPT1i1n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~delish-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-delish-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~delish-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-delish-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~delish-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-delish-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 on Delish (e.g. 'pasta', 'chicken', 'chocolate cake')"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
