# Open Food Facts Scraper (`crawlerbros/open-food-facts-scraper`) Actor

Scrape Open Food Facts - 3M+ grocery products worldwide. Search by keyword, look up by EAN barcode, or browse by category. Returns nutrition facts, Nutri-Score, NOVA group, Eco-Score, ingredients, allergens, images, and more.

- **URL**: https://apify.com/crawlerbros/open-food-facts-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Automation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Open Food Facts Scraper

Extract food product data from [Open Food Facts](https://world.openfoodfacts.org/) — the world's largest open food product database with 3 million+ products from 200+ countries. No API key, no login, no proxy required.

### What can this scraper do?

- **Search by keyword** — find any food product by name, ingredient, or brand (e.g. "chocolate", "oat milk", "avocado")
- **Browse by category** — list products within a named food category (beverages, dairy, snacks, meats, and 25+ others)
- **Lookup by EAN barcode** — retrieve specific products using EAN-8 or EAN-13 barcodes
- **Filter results** — narrow down by brand, country, Nutri-Score grade, NOVA processing level, and boolean flags (must have image / ingredients / nutrition data)

### Output Fields

Each product record contains:

| Field | Description |
|---|---|
| `productId` | Unique product identifier (barcode) |
| `barcode` | EAN-8 or EAN-13 barcode |
| `name` | Product name (English preferred) |
| `brands` | All brands (list) |
| `brand` | Primary brand |
| `categories` | Product categories (list) |
| `countries` | Countries where sold (list) |
| `ingredients` | Full ingredients text |
| `nutrimentEnergy` | Energy per 100 g in kcal |
| `nutrimentFat` | Fat per 100 g in g |
| `nutrimentSaturatedFat` | Saturated fat per 100 g in g |
| `nutrimentCarbohydrates` | Carbohydrates per 100 g in g |
| `nutrimentSugars` | Sugars per 100 g in g |
| `nutrimentProteins` | Proteins per 100 g in g |
| `nutrimentSalt` | Salt per 100 g in g |
| `nutriscore` | Nutri-Score grade (A–E) |
| `nutriscoreScore` | Numeric Nutri-Score points (lower is healthier) |
| `novaGroup` | NOVA food processing group (1=unprocessed, 4=ultra-processed) |
| `ecoscore` | Eco-Score grade (A–E) |
| `ecoscoreScore` | Numeric Eco-Score (0–100; higher is better) |
| `foodGroup` | Food group classification (e.g. `sweets`, `sweetened-beverages`) |
| `additivesCount` | Number of food additives detected |
| `ingredientsCount` | Number of ingredients |
| `manufacturerUrl` | Manufacturer's official product page URL (when available) |
| `scansCount` | Number of times the barcode was scanned in the mobile apps (popularity) |
| `uniqueScansCount` | Number of unique users who scanned the barcode |
| `nutrientLevels` | Traffic-light levels (`low`/`moderate`/`high`) for fat, saturated fat, sugars, and salt |
| `veganStatus` | `vegan` / `non-vegan` / `maybe-vegan`, from Open Food Facts' ingredient analysis |
| `vegetarianStatus` | `vegetarian` / `non-vegetarian` / `maybe-vegetarian` |
| `palmOilStatus` | `palm-oil-free` / `palm-oil` / `may-contain-palm-oil` |
| `traces` | Allergens the product "may contain" (distinct from confirmed `allergens`) |
| `servingQuantity` | Serving size in grams (numeric) |
| `allergens` | Declared allergens (list) |
| `labels` | Quality labels e.g. Organic, Fair Trade, Vegan (list) |
| `imageUrl` | Front product image URL |
| `imageNutritionUrl` | Nutrition label image URL |
| `imageIngredientsUrl` | Ingredients label image URL |
| `productUrl` | Open Food Facts product page URL |
| `sourceUrl` | Source URL (same as productUrl) |
| `scrapedAt` | ISO 8601 timestamp of scrape |
| `recordType` | Always `"product"` |
| `productName` | Alias of `name` |
| `genericName` | Generic/common product name |
| `allBrands` | Alias of `brands` (all brands as a list) |
| `quantity` | Net quantity as sold (e.g. `500 g`, `1 L`) |
| `servingSize` | Serving size text (e.g. `1 square (10 g)`) |
| `packaging` | Packaging materials/format (list) |
| `additives` | Detected food additives (list of E-numbers/names) |
| `origins` | Declared origin of ingredients |
| `manufacturingPlaces` | Where the product is manufactured |
| `stores` | Stores where the product is sold (list) |
| `language` | Primary product language code |
| `nutritionGrade` | Alias of `nutriscore` grade (A–E) |
| `ecoScore` | Alias of `ecoscore` grade (A–E) |
| `imageFrontUrl` | Front-of-pack image URL |
| `ingredientsText` | Alias of `ingredients` |
| `completeness` | Open Food Facts data-completeness score (0–1) |

Convenience flat nutrition fields (per 100 g, same values as the `nutriment*` fields) are also included when available: `calories`, `fat`, `saturatedFat`, `carbohydrates`, `sugar`, `protein`, `salt`, `sodium`, `fiber`.

Fields not available for a product are omitted from the output (no null values).

### Input Options

| Field | Description |
|---|---|
| `mode` | `search`, `byCategory`, or `byBarcode` |
| `searchQuery` | Keyword to search (mode=search) |
| `barcodes` | List of EAN barcodes (mode=byBarcode) |
| `categorySlug` | Food category to browse (mode=byCategory) |
| `brand` | Filter by brand name |
| `country` | Filter by country of sale |
| `language` | Preferred language for product name/ingredients |
| `hasIngredients` | Only include products with ingredients text |
| `hasImage` | Only include products with a product image |
| `hasNutrition` | Only include products with nutrition data |
| `nutriscore` | Filter by Nutri-Score grade (A–E) |
| `novaGroup` | Filter by NOVA processing level (1–4) |
| `dietaryPreference` | Only include products confirmed `vegan`, `vegetarian`, or `palmOilFree` |
| `maxItems` | Maximum number of products to return (1–1000) |

### Supported Categories

Beverages, Dairy Products, Breads, Cereals, Snacks, Confectioneries, Meats, Fish & Seafood, Fruits & Vegetables, Condiments, Oils & Fats, Frozen Foods, Baby Foods, Alcoholic Beverages, Water, Chocolates, Biscuits & Cakes, Breakfast Cereals, Yogurts, Cheeses, Ice Cream, Sodas, Fruit Juices, Coffees, Teas, Nuts, Sauces, Soups, Ready Meals, Plant-Based Foods.

### Example Use Cases

- **Nutrition research** — collect nutrition data for a specific food category for analysis
- **Allergen monitoring** — find products that are gluten-free, vegan, or halal certified
- **Brand product catalog** — retrieve all products from a specific brand
- **Barcode lookup API** — look up product details from EAN barcodes in bulk
- **Eco-Score analysis** — find products with the best/worst environmental scores
- **Country-specific products** — compare products sold in different markets

### FAQs

**Do I need an API key?**
No. Open Food Facts is fully open and requires no authentication.

**Is proxying required?**
No. The Open Food Facts API has no geographic restrictions and works from any IP.

**How many products are available?**
Open Food Facts has over 3 million products from 200+ countries as of 2026.

**What is the Nutri-Score?**
Nutri-Score is a 5-letter nutritional quality grade (A=best, E=worst) used on food packaging in many European countries.

**What is the NOVA group?**
NOVA classifies foods by degree of processing: 1=unprocessed, 2=culinary ingredients, 3=processed, 4=ultra-processed.

**What is the Eco-Score?**
The Eco-Score (A–E) measures the environmental impact of a food product, considering carbon footprint, packaging, biodiversity impact, and more.

**Are all output fields always present?**
No — only fields with actual data are included. For example, if a product has no registered allergens, the `allergens` field is omitted rather than set to null or empty.

**What barcode formats are supported?**
EAN-8, EAN-13, and UPC-A barcodes (4–14 digits).

### Data Source

All data is sourced from [Open Food Facts](https://world.openfoodfacts.org/), which is published under the [Open Database License (ODbL)](https://opendatacommons.org/licenses/odbl/1-0/).

# Actor input Schema

## `mode` (type: `string`):

What to fetch: search by keyword, barcode lookup, or category browse.
## `searchQuery` (type: `string`):

Free-text search query, e.g. `chocolate`, `avocado`, `oat milk`. Searches across product name, brand, and ingredients.
## `barcodes` (type: `array`):

List of EAN-8 or EAN-13 barcodes to look up, e.g. `3017620422003` (Nutella), `5000159407236` (Mars bar).
## `categorySlug` (type: `string`):

Open Food Facts category slug to browse.
## `brand` (type: `string`):

Filter results to a specific brand, e.g. `Ferrero`, `Nestlé`, `Danone`.
## `country` (type: `string`):

Restrict results to products sold in a specific country.
## `language` (type: `string`):

Preferred language for product name and ingredients text (ISO 639-1). Defaults to English.
## `hasIngredients` (type: `boolean`):

When enabled, only include products that have a populated ingredients text.
## `hasImage` (type: `boolean`):

When enabled, only include products that have a product image.
## `hasNutrition` (type: `boolean`):

When enabled, only include products that have at least one nutriment value (calories, fat, protein, etc.).
## `nutriscore` (type: `array`):

Filter by Nutri-Score letter grade (A best → E worst). Leave empty to include all grades.
## `novaGroup` (type: `array`):

Filter by NOVA food-processing group (1=unprocessed → 4=ultra-processed). Multi-select.
## `dietaryPreference` (type: `string`):

Only include products confirmed (not just 'maybe') to match this dietary preference, based on Open Food Facts' own ingredient analysis.
## `maxItems` (type: `integer`):

Maximum number of products to return.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "chocolate",
  "barcodes": [],
  "categorySlug": "chocolates",
  "country": "any",
  "language": "any",
  "hasIngredients": false,
  "hasImage": false,
  "hasNutrition": false,
  "nutriscore": [],
  "novaGroup": [],
  "dietaryPreference": "any",
  "maxItems": 20
}
````

# Actor output Schema

## `products` (type: `string`):

Dataset containing all scraped Open Food Facts food product records with nutrition, labels, allergens, and images.

# 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 = {
    "mode": "search",
    "searchQuery": "chocolate",
    "barcodes": [],
    "hasIngredients": false,
    "hasImage": false,
    "hasNutrition": false,
    "dietaryPreference": "any",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/open-food-facts-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 = {
    "mode": "search",
    "searchQuery": "chocolate",
    "barcodes": [],
    "hasIngredients": False,
    "hasImage": False,
    "hasNutrition": False,
    "dietaryPreference": "any",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/open-food-facts-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 '{
  "mode": "search",
  "searchQuery": "chocolate",
  "barcodes": [],
  "hasIngredients": false,
  "hasImage": false,
  "hasNutrition": false,
  "dietaryPreference": "any",
  "maxItems": 20
}' |
apify call crawlerbros/open-food-facts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Open Food Facts Scraper",
        "description": "Scrape Open Food Facts - 3M+ grocery products worldwide. Search by keyword, look up by EAN barcode, or browse by category. Returns nutrition facts, Nutri-Score, NOVA group, Eco-Score, ingredients, allergens, images, and more.",
        "version": "1.0",
        "x-build-id": "DeascLA6OcpI2KD3H"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~open-food-facts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-open-food-facts-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/crawlerbros~open-food-facts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-open-food-facts-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/crawlerbros~open-food-facts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-open-food-facts-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "byBarcode"
                        ],
                        "type": "string",
                        "description": "What to fetch: search by keyword, barcode lookup, or category browse.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text search query, e.g. `chocolate`, `avocado`, `oat milk`. Searches across product name, brand, and ingredients.",
                        "default": "chocolate"
                    },
                    "barcodes": {
                        "title": "EAN barcodes (mode=byBarcode)",
                        "type": "array",
                        "description": "List of EAN-8 or EAN-13 barcodes to look up, e.g. `3017620422003` (Nutella), `5000159407236` (Mars bar).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categorySlug": {
                        "title": "Food category (mode=byCategory)",
                        "enum": [
                            "beverages",
                            "dairy-products",
                            "breads",
                            "cereals-and-their-products",
                            "snacks",
                            "confectioneries",
                            "meats",
                            "fish-and-seafood",
                            "fruits-and-vegetables",
                            "condiments",
                            "oils-and-fats",
                            "frozen-foods",
                            "baby-foods",
                            "alcoholic-beverages",
                            "water",
                            "chocolates",
                            "biscuits-and-cakes",
                            "breakfast-cereals",
                            "yogurts",
                            "cheeses",
                            "ice-cream",
                            "sodas",
                            "fruit-juices",
                            "coffees",
                            "teas",
                            "nuts",
                            "sauces",
                            "soups",
                            "ready-meals",
                            "plant-based-foods"
                        ],
                        "type": "string",
                        "description": "Open Food Facts category slug to browse.",
                        "default": "chocolates"
                    },
                    "brand": {
                        "title": "Brand filter",
                        "type": "string",
                        "description": "Filter results to a specific brand, e.g. `Ferrero`, `Nestlé`, `Danone`."
                    },
                    "country": {
                        "title": "Country filter",
                        "enum": [
                            "any",
                            "united-states",
                            "united-kingdom",
                            "france",
                            "germany",
                            "italy",
                            "spain",
                            "belgium",
                            "netherlands",
                            "switzerland",
                            "canada",
                            "australia",
                            "japan",
                            "brazil",
                            "mexico",
                            "india",
                            "poland",
                            "portugal",
                            "sweden",
                            "norway",
                            "denmark",
                            "finland",
                            "ireland",
                            "austria"
                        ],
                        "type": "string",
                        "description": "Restrict results to products sold in a specific country.",
                        "default": "any"
                    },
                    "language": {
                        "title": "Language preference",
                        "enum": [
                            "any",
                            "en",
                            "fr",
                            "de",
                            "it",
                            "es",
                            "pt",
                            "nl",
                            "pl",
                            "ru",
                            "ja",
                            "zh",
                            "ar",
                            "tr",
                            "sv",
                            "da",
                            "no",
                            "fi"
                        ],
                        "type": "string",
                        "description": "Preferred language for product name and ingredients text (ISO 639-1). Defaults to English.",
                        "default": "any"
                    },
                    "hasIngredients": {
                        "title": "Must have ingredients",
                        "type": "boolean",
                        "description": "When enabled, only include products that have a populated ingredients text.",
                        "default": false
                    },
                    "hasImage": {
                        "title": "Must have image",
                        "type": "boolean",
                        "description": "When enabled, only include products that have a product image.",
                        "default": false
                    },
                    "hasNutrition": {
                        "title": "Must have nutrition data",
                        "type": "boolean",
                        "description": "When enabled, only include products that have at least one nutriment value (calories, fat, protein, etc.).",
                        "default": false
                    },
                    "nutriscore": {
                        "title": "Nutri-Score grades",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by Nutri-Score letter grade (A best → E worst). Leave empty to include all grades.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "A",
                                "B",
                                "C",
                                "D",
                                "E"
                            ],
                            "enumTitles": [
                                "A — Very good",
                                "B — Good",
                                "C — Average",
                                "D — Poor",
                                "E — Very poor"
                            ]
                        },
                        "default": []
                    },
                    "novaGroup": {
                        "title": "NOVA processing level",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by NOVA food-processing group (1=unprocessed → 4=ultra-processed). Multi-select.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4"
                            ],
                            "enumTitles": [
                                "1 — Unprocessed / minimally processed",
                                "2 — Processed culinary ingredients",
                                "3 — Processed foods",
                                "4 — Ultra-processed foods"
                            ]
                        },
                        "default": []
                    },
                    "dietaryPreference": {
                        "title": "Dietary preference",
                        "enum": [
                            "any",
                            "vegan",
                            "vegetarian",
                            "palmOilFree"
                        ],
                        "type": "string",
                        "description": "Only include products confirmed (not just 'maybe') to match this dietary preference, based on Open Food Facts' own ingredient analysis.",
                        "default": "any"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of products to return.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
