# Food.com Scraper | Recipes Reviews and Ratings (`parseforge/food-com-scraper`) Actor

Collect recipes from Food.com with full ingredients, step instructions, cook and prep times, servings, nutrition, ratings, and user reviews. Filter by category, cuisine, or ingredient to build recipe apps, food blogs, meal planners, and machine learning datasets at scale.

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

## 🍳 Food.com Recipe Scraper

> 🚀 **Export Food.com recipes in seconds.** Search by keyword and download structured recipe data - ingredients, directions, nutrition, ratings, and more - without writing a single line of code.

> 🕒 **Last updated:** 2026-05-21 · **📊 18 fields** per record · **13,000+ recipes per keyword** · **Global coverage**

The Food.com Recipe Scraper lets you search Food.com by any keyword and export the results as clean, structured JSON, CSV, or Excel. Every record includes the full ingredient list, step-by-step directions, nutrition facts (calories), prep/cook times, author, rating, review count, servings, and tags - directly from Food.com's internal search API and recipe pages.

Food.com hosts over 500,000 community-contributed recipes, making it one of the largest recipe databases on the internet. This scraper surfaces all of that data through a simple keyword search interface.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Food bloggers & recipe developers | Building recipe databases and comparison tools |
| Nutritionists & dietitians | Analyzing calorie and macro distributions across recipe categories |
| Meal-planning app developers | Powering search and recommendation engines |
| Data scientists & researchers | Training food NLP models, studying recipe trends |
| Cooking content creators | Finding inspiration and trending recipes by keyword |
| E-commerce & affiliate marketers | Discovering popular ingredients and products |

### 📋 What the Food.com Scraper does

- Searches Food.com by any keyword (e.g. "pasta", "vegan tacos", "low carb chicken")
- Fetches full recipe details from each result: ingredients, step-by-step directions, nutrition info
- Exports structured data ready for download in JSON, CSV, Excel, or XML
- Supports sorting by Relevance, Highest Rating, or Newest
- Optionally filters by maximum prep time
- Respects rate limits to avoid bans - no login or API key required

### 🎬 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 users capped at 10) |
| `sortBy` | select | No | Relevance | Sort order: Relevance, Highest Rating, or Newest |
| `maxPrepTime` | integer | No | - | Filter to recipes with prep time at or below N minutes |

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

**Example 2 - Fast weeknight dinners:**

```json
{
  "searchQuery": "chicken dinner",
  "maxItems": 100,
  "sortBy": "RATING",
  "maxPrepTime": 15
}
```

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

### 📊 Output

Each recipe record contains 18 fields:

| Field | Type | Description |
|---|---|---|
| 🖼 `imageUrl` | string | High-resolution recipe photo URL |
| 📌 `title` | string | Recipe title |
| 🔗 `url` | string | Full Food.com recipe URL |
| 🆔 `id` | string | Food.com recipe ID |
| 👤 `author` | string | Recipe author username |
| ⭐ `rating` | number | Average star rating (1-5) |
| 💬 `reviewCount` | integer | Number of community reviews |
| 🍽 `servings` | string | Number of servings |
| ⏱ `prepTime` | integer | Prep time in minutes |
| 🍳 `cookTime` | integer | Cook time in minutes |
| ⏰ `totalTime` | integer | Total time in minutes |
| 🔥 `calories` | number | Calories per serving |
| 🧂 `ingredients` | array | Full ingredient list with measurements |
| 📋 `directions` | array | Step-by-step cooking instructions |
| 🏷 `tags` | array | Recipe keywords and category tags |
| 📝 `description` | string | Short recipe description |
| 🕒 `scrapedAt` | string | ISO timestamp of when the record was scraped |
| ❌ `error` | string | Error message if the record failed (null on success) |

**Sample record 1:**

```json
{
  "imageUrl": "https://img.sndimg.com/food/image/upload/q_92,fl_progressive,w_1200,c_scale/v1/img/recipes/39/08/7/VPeSMiYHRce4BWsyj7Nl_0S9A5582.jpg",
  "title": "Creamy Cajun Chicken Pasta",
  "url": "https://www.food.com/recipe/creamy-cajun-chicken-pasta-39087",
  "id": "39087",
  "author": "Lorac",
  "rating": 4.84,
  "reviewCount": 1608,
  "servings": "2 serving(s)",
  "prepTime": 10,
  "cookTime": 15,
  "totalTime": 25,
  "calories": 719.1,
  "ingredients": [
    "2 boneless skinless chicken breast halves, cut into thin strips",
    "4 ounces linguine, cooked al dente",
    "2 teaspoons cajun seasoning",
    "2 tablespoons butter",
    "1/2 cup heavy whipping cream",
    "1/4 cup grated parmesan cheese"
  ],
  "directions": [
    "Place chicken and Cajun seasoning in a bowl and toss to coat.",
    "In a large skillet over medium heat, saute chicken in butter until tender, about 5 to 7 minutes.",
    "Reduce heat add green onion, heavy cream, tomatoes, basil, salt, garlic powder, black pepper and heat through.",
    "Pour over hot linguine and toss with Parmesan cheese."
  ],
  "tags": ["Chicken", "Cajun", "Kid Friendly", "Spicy", "< 30 Mins", "Easy"],
  "description": "N'awlin's style of chicken with an updated Alfredo sauce.",
  "scrapedAt": "2026-05-22T00:51:22.264Z",
  "error": null
}
```

**Sample record 2:**

```json
{
  "imageUrl": "https://img.sndimg.com/food/image/upload/q_92,fl_progressive,w_1200,c_scale/v1/img/recipes/22/78/2/xy39o2sOTtudkgyDgZtv_spaghettisauce.jpg",
  "title": "Jo Mama's World Famous Spaghetti",
  "url": "https://www.food.com/recipe/jo-mamas-world-famous-spaghetti-22782",
  "id": "22782",
  "author": "Sharlene~W",
  "rating": 4.73,
  "reviewCount": 1364,
  "servings": "4 quarts, 10-14 serving(s)",
  "prepTime": 20,
  "cookTime": 60,
  "totalTime": 80,
  "calories": 555.9,
  "ingredients": ["2 lbs Italian sausage", "3-4 garlic cloves, minced", "1 cup red wine", "..."],
  "directions": ["Brown Italian sausage in stockpot.", "Add onions and cook until softened.", "..."],
  "tags": ["Pork", "European", "Kid Friendly", "Weeknight", "Easy"],
  "description": "My kids will give up a steak dinner for this spaghetti.",
  "scrapedAt": "2026-05-22T00:51:22.718Z",
  "error": null
}
```

**Sample record 3:**

```json
{
  "imageUrl": "https://img.sndimg.com/food/image/upload/q_92,fl_progressive,w_1200,c_scale/v1/img/recipes/32/84/4/XOh9RKyES6dIOho2A6ps_DSC05063-2.jpg",
  "title": "Pasta with Sausage, Tomatoes, and Cream",
  "url": "https://www.food.com/recipe/pasta-with-sausage-tomatoes-and-cream-32844",
  "id": "32844",
  "author": "GinnyP",
  "rating": 4.75,
  "reviewCount": 461,
  "servings": "2 serving(s)",
  "prepTime": 10,
  "cookTime": 15,
  "totalTime": 25,
  "calories": 1124.7,
  "ingredients": ["1 tablespoon olive oil", "1/2 lb sweet Italian sausage", "..."],
  "directions": ["Heat oil in skillet over medium heat.", "Add sausage and cook until browned.", "..."],
  "tags": ["Pork", "European", "< 30 Mins", "Easy"],
  "description": "Delicious and satisfying - a real crowd pleaser! Easily doubled.",
  "scrapedAt": "2026-05-22T00:51:23.326Z",
  "error": null
}
```

### ✨ Why choose this Actor

- 🔓 **No login required** - uses Food.com's public API, no account needed
- 🚀 **Fast API-first approach** - fetches data from Food.com's internal JSON API, not slow HTML scraping
- 📦 **Complete recipe data** - ingredients, directions, nutrition, ratings, tags all in one record
- 🔍 **Full keyword search** - search any ingredient, cuisine, or meal type
- 📊 **Ready-to-use output** - JSON, CSV, Excel, XML all available instantly
- ⚡ **Scales to thousands** - collect up to 1,000,000 recipes per run
- 🛡 **Stable & maintained** - built on proven infrastructure, updated regularly

### 📈 How it compares to alternatives

| Feature | This Actor | Manual scraping | Other scrapers |
|---|---|---|---|
| Full ingredients list | ✅ | Manual work | Varies |
| Step-by-step directions | ✅ | Manual work | Varies |
| Calories & nutrition | ✅ | Manual work | Rarely |
| Keyword search | ✅ | Not possible | Sometimes |
| Sort by rating/date | ✅ | Not possible | Rarely |
| Prep time filter | ✅ | Not possible | Rarely |
| No login needed | ✅ | Manual work | Varies |
| CSV/Excel export | ✅ | Manual work | Sometimes |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 in free credits)
2. Open the Food.com Recipe Scraper on Apify Store
3. Enter your search keyword (e.g. "vegan pasta", "keto chicken")
4. Set your desired number of recipes and optional filters
5. Click **Start** and download your dataset as JSON, CSV, or Excel when complete

### 💼 Business use cases

#### Recipe app development

Build or improve recipe apps with real data. Use the scraper to seed your database with thousands of community-verified recipes complete with ingredients, directions, and photos.

#### Nutritional analysis

Nutritionists and dietitians can collect calorie and macro data across recipe categories to analyze nutritional trends, compare meal types, or build educational content.

#### Food trend research

Track what recipes are popular by keyword. Collect top-rated recipes for trending ingredients or dietary patterns (gluten-free, keto, air fryer) and analyze review counts and ratings over time.

#### Content marketing

Food bloggers and content teams can collect top-rated recipes in their niche, analyze what makes a high-performing recipe (tags, ingredients, time), and use that intelligence to guide their own content strategy.

### 🔌 Automating Food.com Scraper

Connect this scraper to your workflow tools using Apify's integrations:

- **Make (formerly Integromat)** - trigger a recipe collection run on a schedule and push results to Google Sheets or Airtable
- **Zapier** - send newly scraped recipes to Slack, Notion, or any webhook
- **Apify API** - call the actor programmatically from your own app using the REST API
- **Webhooks** - get notified when a run completes and automatically process results

### 🌟 Beyond business use cases

#### Recipe research & education

Academics studying food culture, ingredient trends, or recipe language can use this scraper to build large-scale datasets for NLP research, anthropological studies, or culinary education.

#### Personal meal planning

Home cooks can collect dozens of recipes for a specific diet or ingredient, export to Excel, and build their own personal recipe book with calorie counts already included.

#### Community cookbooks

Food communities and non-profits can gather and curate recipes for community cookbooks, fundraiser publications, or cultural preservation projects.

#### AI & machine learning experiments

Train recipe recommendation models, ingredient-to-recipe systems, or flavor pairing algorithms using thousands of real, structured recipe records.

### 🤖 Ask an AI assistant about this scraper

Not sure which inputs to use? Ask your AI assistant:

> "I want to scrape 500 high-rated chicken recipes from Food.com with under 30 minutes prep time. What input should I use for the Food.com Scraper on Apify?"

### ❓ Frequently Asked Questions

**❓ Does this require a Food.com account?**
No. The scraper uses Food.com's public search API. No login or account is needed.

**❓ How many recipes can I collect?**
Free users are limited to 10 recipes per run. Paid users can collect up to 1,000,000 recipes per run.

**❓ What search terms work best?**
Any keyword that Food.com supports - ingredients ("garlic", "salmon"), meal types ("breakfast", "dinner"), cuisines ("Italian", "Thai"), dietary labels ("vegan", "gluten-free"), or dish names ("lasagna", "pad thai").

**❓ Is the data accurate and up to date?**
Yes. Data is scraped in real-time from Food.com's live site on every run. There is no cached or pre-collected data.

**❓ Can I filter by prep time?**
Yes. Use the `maxPrepTime` input field to set a maximum prep time in minutes. Only recipes at or below that threshold will be returned.

**❓ Can I sort results?**
Yes. Choose from Relevance / Popularity (default), Highest Rating, or Newest First.

**❓ What does `servings` look like?**
The servings field comes directly from the recipe author's input on Food.com (e.g., "2 serving(s)", "4 quarts, 10-14 serving(s)"). It is a human-readable string.

**❓ Are calories always available?**
Calories are extracted from the recipe's Schema.org JSON-LD nutrition block. Most recipes on Food.com include this data. When it is not present, the `calories` field will be `null`.

**❓ What format can I download the data in?**
JSON, CSV, Excel (XLSX), and XML are all available through the Apify dataset download UI.

**❓ Can I run this on a schedule?**
Yes. Use Apify's Schedules feature to run this actor automatically on any cron schedule - daily, weekly, or hourly.

**❓ Is there a rate limit?**
The scraper adds a small delay between requests to be polite to Food.com's servers and ensure stable results.

**❓ Can I scrape a specific recipe by URL?**
This scraper is keyword-search-based. To fetch a specific recipe, use the recipe's keyword in the search field - results are sorted by relevance.

### 🔌 Integrate with any app

Connect your Food.com recipe data to 1,000+ apps via Apify integrations:

**Spreadsheets:** Google Sheets, Microsoft Excel, Airtable

**Databases:** PostgreSQL, MySQL, MongoDB, Supabase

**Automation:** Make, Zapier, n8n, Pipedream

**Storage:** Google Drive, Dropbox, Amazon S3

**BI Tools:** Tableau, Power BI, Looker Studio

**Dev tools:** REST API, Webhooks, Python SDK, Node.js SDK

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [AllRecipes Scraper](https://apify.com/parseforge/allrecipes-scraper) | Scrape AllRecipes.com recipes by keyword, category, or URL |
| [Epicurious Scraper](https://apify.com/parseforge/epicurious-scraper) | Export Epicurious recipes with full details and nutrition |
| [BBC Good Food Scraper](https://apify.com/parseforge/bbcgoodfood-scraper) | Collect BBC Good Food recipes by keyword and dietary filter |

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

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

> **⚠️ Disclaimer:** This is an independent tool and is not affiliated with, endorsed by, or associated with Food.com or its parent company. Only publicly available data is collected.

# Actor input Schema

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

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

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

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

## `sortBy` (type: `string`):

How to sort the search results.

## `maxPrepTime` (type: `integer`):

Only return recipes with prep time at or below this value (in minutes). Leave empty for no limit.

## Actor input object example

```json
{
  "searchQuery": "pasta",
  "maxItems": 10,
  "sortBy": "PERFORMANCE"
}
```

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Food.com Scraper | Recipes Reviews and Ratings",
        "description": "Collect recipes from Food.com with full ingredients, step instructions, cook and prep times, servings, nutrition, ratings, and user reviews. Filter by category, cuisine, or ingredient to build recipe apps, food blogs, meal planners, and machine learning datasets at scale.",
        "version": "0.1",
        "x-build-id": "C9TKxqjqvxjun7meO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~food-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-food-com-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-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-food-com-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-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-food-com-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 on Food.com (e.g. 'pasta', 'chicken soup', '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."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "PERFORMANCE",
                            "RATING",
                            "NEWEST"
                        ],
                        "type": "string",
                        "description": "How to sort the search results.",
                        "default": "PERFORMANCE"
                    },
                    "maxPrepTime": {
                        "title": "Max Prep Time (minutes)",
                        "minimum": 1,
                        "maximum": 1440,
                        "type": "integer",
                        "description": "Only return recipes with prep time at or below this value (in minutes). Leave empty for no limit."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
