# Open Food Facts Scraper (`crawlerbros/openfoodfacts-scraper`) Actor

Scrape Open Food Facts (3M+ grocery products). Search or filter by barcode, brand, category, store, label, country, manufacturer, URL. Returns nutrition, Nutri-Score, Eco-Score, NOVA group, ingredients, allergens, packaging, images

- **URL**: https://apify.com/crawlerbros/openfoodfacts-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** E-commerce, Developer tools, Other
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 7 bookmarks
- **User rating**: 5.00 out of 5 stars

## 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

Scrape the open Open Food Facts catalog — 3+ million grocery and packaged-food products worldwide, contributed by users and brands. Search by text or filter by barcode, brand, category, country, store (retailer), label, manufacturer, or product URL. Returns per-product nutrition facts (per 100 g), Nutri-Score, Eco-Score, NOVA processing classification, ingredients, allergens, packaging tags, and high-quality product images. HTTP-only via the public `openfoodfacts.org` JSON API. No auth, no cookies, no proxy required.

### What this actor does

- **Nine modes:** `search`, `byBarcodes`, `byCategory`, `byBrand`, `byCountry`, `byStore`, `byLabel`, `byManufacturer`, `byUrls`
- **Universal IDs:** EAN-13 / EAN-8 / UPC-A barcodes
- **Filters:** country, language, NOVA group (multi-select), Nutri-Score (multi-select), Eco-Score (multi-select), `containsLabels` (organic / vegan / fair-trade / etc.), `excludesAllergens` (milk / gluten / peanuts / etc.), `minProductCompleteness` (0-100%), free-text `containsKeyword`
- **Per-100 g nutriments:** energy, fat, saturated fat, carbohydrates, sugars, added sugars, fiber, proteins, salt, sodium, cholesterol, iron, calcium, vitamins A/C/D
- **Multi-region:** the actor automatically routes country-filtered queries to the per-country API host (`us.openfoodfacts.org`, `fr.openfoodfacts.org`, etc.) for the freshest, most localized data
- **Empty fields are always omitted** — no null clutter

### Output per product

- `code` — barcode (EAN-13 / EAN-8 / UPC-A)
- `productName`, `primaryBrand`, `brands[]`, `brandsTags[]`
- `quantity`, `packaging`, `packagingTags[]`
- `manufacturingPlaces`
- `stores[]`, `storesTags[]`
- `countries[]`, `countriesTags[]`
- `language` — ISO 639-1
- `categoryHierarchy[]`, `categoriesTags[]`, `mainCategory`
- `nutriments` — per-100 g object: `energyKcal`, `energyKj`, `fat`, `saturatedFat`, `carbohydrates`, `sugars`, `addedSugars`, `fiber`, `proteins`, `salt`, `sodium`, `transFat`, `cholesterol`, `iron`, `calcium`, `vitaminA`, `vitaminC`, `vitaminD`, `alcohol`
- `servingSize`, `servingQuantity`
- `nutriscore` — A / B / C / D / E / unknown
- `ecoscore` — A / B / C / D / E / unknown
- `novaGroup` — 1 (unprocessed) → 4 (ultra-processed)
- `additivesTags[]`, `allergensTags[]`, `labelsTags[]`, `ingredientsTags[]`, `tracesTags[]`
- `ingredientsText`
- `ingredientsAnalysis` — `palmOilStatus`, `veganStatus`, `vegetarianStatus`
- `imageUrls` — `front`, `ingredients`, `nutrition`
- `productCompleteness` — 0.0–1.0
- `createdAt`, `lastModifiedAt`
- `productUrl`
- `recordType: "product"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | One of `search`, `byBarcodes`, `byCategory`, `byBrand`, `byCountry`, `byStore`, `byLabel`, `byManufacturer`, `byUrls` |
| `searchQuery` | string | `chocolate` | Free-text query — name, brand, or ingredient |
| `barcodes` | array | – | Barcodes (mode=byBarcodes) — EAN-13 / EAN-8 / UPC-A; dashes are stripped |
| `categorySlug` | string | – | Category slug (mode=byCategory) — pick from dropdown or enter custom |
| `brandSlug` | string | – | Brand slug (mode=byBrand) — e.g. `nutella`, `coca-cola` |
| `storeSlug` | string | – | Retailer slug (mode=byStore) — `carrefour`, `walmart`, `aldi`, etc. |
| `labelSlug` | string | – | Label slug (mode=byLabel) — `organic`, `vegan`, `fair-trade`, etc. |
| `manufacturerSlug` | string | – | Manufacturer / manufacturing-place slug (mode=byManufacturer) |
| `productUrls` | array | – | Direct product URLs (mode=byUrls) |
| `country` | string | `any` | Restrict results + drive country API host (United States, France, Germany, …) |
| `language` | string | `any` | Preferred display language (ISO 639-1) |
| `novaGroup` | array | – | Multi-select 1–4 (food-processing level) |
| `nutriscore` | array | – | Multi-select A / B / C / D / E / unknown |
| `ecoscore` | array | – | Multi-select A / B / C / D / E / unknown |
| `containsLabels` | array | – | Require selected labels (organic, vegan, gluten-free, …) |
| `excludesAllergens` | array | – | Drop products containing selected allergens (milk, gluten, peanuts, …) |
| `minProductCompleteness` | int | `0` | Drop products below this completeness % (0–100) |
| `containsKeyword` | string | – | Post-fetch substring filter on name / brand / ingredients |
| `maxItems` | int | `50` | Hard cap on emitted records (1–1000) |

#### Example: search for chocolate, US market

```json
{
  "mode": "search",
  "searchQuery": "chocolate",
  "country": "united-states",
  "maxItems": 15
}
````

#### Example: lookup by barcode

```json
{
  "mode": "byBarcodes",
  "barcodes": ["3017620422003", "0037466016450", "5000159484695"]
}
```

#### Example: organic + vegan chocolate spreads with Nutri-Score A or B

```json
{
  "mode": "byCategory",
  "categorySlug": "chocolate-spreads",
  "containsLabels": ["organic", "vegan"],
  "nutriscore": ["A", "B"]
}
```

#### Example: all Nutella products

```json
{
  "mode": "byBrand",
  "brandSlug": "nutella"
}
```

#### Example: products sold at Carrefour, France

```json
{
  "mode": "byStore",
  "storeSlug": "carrefour",
  "country": "france",
  "maxItems": 100
}
```

#### Example: gluten-free products

```json
{
  "mode": "byLabel",
  "labelSlug": "gluten-free",
  "excludesAllergens": ["gluten", "milk"]
}
```

#### Example: products from a country, narrowed by category

```json
{
  "mode": "byCountry",
  "country": "italy",
  "categorySlug": "pastas",
  "maxItems": 50
}
```

#### Example: lookup by product URL

```json
{
  "mode": "byUrls",
  "productUrls": [
    "https://world.openfoodfacts.org/product/3017620422003/nutella"
  ]
}
```

### Use cases

- **CPG market research** — track product launches, brand portfolios, packaging trends, NOVA-classification shifts across markets
- **Retailer / pricing intelligence** — discover the catalog footprint of major retailers (Walmart, Carrefour, Aldi, Lidl, Tesco) in each country
- **Nutrition-app data ingestion** — bulk-import barcode-keyed nutrition facts to power calorie counters, fitness trackers, and recipe scorers
- **Diet & health research** — segment products by Nutri-Score / Eco-Score / NOVA group; quantify additive prevalence by category
- **Labeling compliance** — find products by allergen or label (organic, vegan, gluten-free, fair-trade, kosher, halal)
- **Sustainability research** — Eco-Score and packaging tags surface recyclability, palm-oil status, and origin data
- **E-commerce enrichment** — fill missing brand / nutrition / ingredient gaps on your own catalog using barcode lookups
- **Academic / public-health studies** — bulk-export an entire category for longitudinal analysis

### Data source

This actor reads data from [Open Food Facts](https://world.openfoodfacts.org/) — a free, open, collaborative catalog of food products from around the world contributed by ~25,000 volunteers and brands under an Open Database License (ODbL). The OFF API is public and no API key is required. All requests are made with a polite User-Agent and a small inter-request delay.

### FAQ

**What's Open Food Facts?**  An open, crowd-sourced food product database with 3+ million products from 150+ countries. Like Wikipedia for groceries — anyone can add or edit a product, with photo evidence of the front, ingredients, and nutrition panels.

**Is there a rate limit?**  No documented hard cap. The actor uses small inter-request delays (≈200 ms) and retries on the temporary `503` throttle that the CDN issues for very-large unbounded queries.

**Why does `mode=byCountry` need a narrowing input on the world API?**  An unfiltered country-wide query against `world.openfoodfacts.org` would scan all 900,000+ US-tagged products (or 1.5M+ French products) — the CDN throttles those. The actor either routes to the per-country host (`us.openfoodfacts.org`, `fr.openfoodfacts.org`) or asks for a `searchQuery` / `categorySlug` to narrow the result.

**What's the difference between Nutri-Score and Eco-Score?**  Nutri-Score (A=best, E=worst) is a French/European front-of-pack nutrition label scored against fat / saturated fat / sugar / salt vs protein / fiber / fruit-veg. Eco-Score combines life-cycle assessment, packaging, transport, and certifications into an A–E environmental rating.

**What does NOVA group mean?**  A food-processing classification developed by the University of São Paulo. Group 1 = unprocessed (apples, rice). Group 2 = processed culinary ingredients (oils, salt). Group 3 = processed foods (canned beans). Group 4 = ultra-processed (sodas, packaged snacks, ready meals).

**Why are some products missing nutrition data?**  Open Food Facts is crowd-sourced — completeness varies by product. Use the `minProductCompleteness` filter to require records that include the most-important fields.

**Can I get historical prices?**  No, Open Food Facts does not store price history. It's a product catalog, not a marketplace tracker. For pricing data, combine these records with retailer-specific scrapers.

**Why are barcodes left-padded with zeros?**  Open Food Facts canonicalizes barcodes as 13-digit strings (UPC-A is left-padded with a leading zero to align with EAN-13). The actor preserves the canonical form.

# Actor input Schema

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

What to fetch.

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

Free-text query — searches name / brand / ingredients.

## `barcodes` (type: `array`):

EAN-13 / EAN-8 / UPC-A barcode strings (digits only after normalization).

## `categorySlug` (type: `string`):

Open Food Facts category slug. Spaces / commas are normalized to hyphens.

## `brandSlug` (type: `string`):

Brand name slug — e.g. `nutella`, `danone`, `coca-cola`, `kelloggs`.

## `storeSlug` (type: `string`):

Retailer slug. Choose a known store or type a custom slug.

## `labelSlug` (type: `string`):

Food label slug (organic, vegan, fair-trade, etc.).

## `manufacturerSlug` (type: `string`):

Manufacturing place / country (e.g. `france`, `italy`, `germany`).

## `productUrls` (type: `array`):

Direct product URLs like `https://world.openfoodfacts.org/product/3017620422003`.

## `country` (type: `string`):

Restrict results to products sold in a specific country (also drives the country API host).

## `language` (type: `string`):

Preferred language for `productName` / `ingredientsText` (ISO 639-1).

## `novaGroup` (type: `array`):

NOVA food-processing classification (1=unprocessed, 4=ultra-processed). Multi-select.

## `nutriscore` (type: `array`):

Filter by Nutri-Score letter (A best → E worst). Multi-select.

## `ecoscore` (type: `array`):

Filter by Eco-Score letter (A best → E worst). Multi-select.

## `containsLabels` (type: `array`):

Require every selected label to appear on the product.

## `excludesAllergens` (type: `array`):

Drop products containing any of the selected allergens.

## `minProductCompleteness` (type: `integer`):

Drop products whose completeness score is below this percentage. 0=any, 100=fully complete.

## `containsKeyword` (type: `string`):

Post-fetch substring match against `productName` / brand / ingredients.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "chocolate",
  "barcodes": [],
  "productUrls": [],
  "country": "any",
  "language": "any",
  "novaGroup": [],
  "nutriscore": [],
  "ecoscore": [],
  "containsLabels": [],
  "excludesAllergens": [],
  "minProductCompleteness": 0,
  "maxItems": 15
}
```

# Actor output Schema

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

Dataset containing all scraped Open Food Facts product records.

# 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": [],
    "productUrls": [],
    "minProductCompleteness": 0,
    "maxItems": 15
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/openfoodfacts-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": [],
    "productUrls": [],
    "minProductCompleteness": 0,
    "maxItems": 15,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/openfoodfacts-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": [],
  "productUrls": [],
  "minProductCompleteness": 0,
  "maxItems": 15
}' |
apify call crawlerbros/openfoodfacts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/openfoodfacts-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). Search or filter by barcode, brand, category, store, label, country, manufacturer, URL. Returns nutrition, Nutri-Score, Eco-Score, NOVA group, ingredients, allergens, packaging, images",
        "version": "1.1",
        "x-build-id": "qcAMBbrPXTzyQCi4g"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~openfoodfacts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-openfoodfacts-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~openfoodfacts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-openfoodfacts-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~openfoodfacts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-openfoodfacts-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",
                            "byBarcodes",
                            "byCategory",
                            "byBrand",
                            "byCountry",
                            "byStore",
                            "byLabel",
                            "byManufacturer",
                            "byUrls"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text query — searches name / brand / ingredients.",
                        "default": "chocolate"
                    },
                    "barcodes": {
                        "title": "Barcodes (mode=byBarcodes)",
                        "type": "array",
                        "description": "EAN-13 / EAN-8 / UPC-A barcode strings (digits only after normalization).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "categorySlug": {
                        "title": "Category slug (mode=byCategory)",
                        "enum": [
                            "beverages",
                            "snacks",
                            "dairies",
                            "cereals-and-potatoes",
                            "fruits-and-vegetables-based-foods",
                            "meats",
                            "fishes",
                            "fats",
                            "sweets",
                            "chocolates",
                            "biscuits-and-cakes",
                            "breads",
                            "pastas",
                            "pizzas",
                            "sauces",
                            "spreads",
                            "frozen-foods",
                            "condiments",
                            "breakfast-cereals",
                            "yogurts",
                            "cheeses",
                            "ice-cream",
                            "milk",
                            "waters",
                            "fruit-juices",
                            "sodas",
                            "alcoholic-beverages",
                            "wines",
                            "beers",
                            "coffees",
                            "teas",
                            "plant-based-foods",
                            "plant-based-foods-and-beverages",
                            "nuts",
                            "dried-fruits",
                            "honeys",
                            "jams",
                            "soups",
                            "canned-foods",
                            "ready-meals",
                            "salty-snacks"
                        ],
                        "type": "string",
                        "description": "Open Food Facts category slug. Spaces / commas are normalized to hyphens."
                    },
                    "brandSlug": {
                        "title": "Brand slug (mode=byBrand)",
                        "type": "string",
                        "description": "Brand name slug — e.g. `nutella`, `danone`, `coca-cola`, `kelloggs`."
                    },
                    "storeSlug": {
                        "title": "Store slug (mode=byStore)",
                        "enum": [
                            "carrefour",
                            "walmart",
                            "tesco",
                            "lidl",
                            "aldi",
                            "auchan",
                            "casino",
                            "intermarche",
                            "leclerc",
                            "monoprix",
                            "kroger",
                            "target",
                            "whole-foods-market",
                            "trader-joe-s",
                            "publix",
                            "costco",
                            "sainsbury-s",
                            "asda",
                            "morrisons",
                            "marks-spencer",
                            "waitrose",
                            "rewe",
                            "edeka",
                            "kaufland",
                            "netto",
                            "penny",
                            "mercadona",
                            "eroski",
                            "dia",
                            "esselunga",
                            "coop",
                            "migros",
                            "iga",
                            "loblaws",
                            "metro",
                            "woolworths",
                            "coles",
                            "7-eleven"
                        ],
                        "type": "string",
                        "description": "Retailer slug. Choose a known store or type a custom slug."
                    },
                    "labelSlug": {
                        "title": "Label slug (mode=byLabel)",
                        "enum": [
                            "organic",
                            "eu-organic",
                            "usda-organic",
                            "vegan",
                            "vegetarian",
                            "no-gluten",
                            "gluten-free",
                            "fair-trade",
                            "kosher",
                            "halal",
                            "no-lactose",
                            "no-palm-oil",
                            "no-added-sugar",
                            "no-preservatives",
                            "no-colorings",
                            "no-artificial-flavors",
                            "made-in-france",
                            "made-in-italy",
                            "ab-agriculture-biologique",
                            "fr-bio-01",
                            "rainforest-alliance",
                            "msc-certified-sustainable-seafood"
                        ],
                        "type": "string",
                        "description": "Food label slug (organic, vegan, fair-trade, etc.)."
                    },
                    "manufacturerSlug": {
                        "title": "Manufacturing place slug (mode=byManufacturer)",
                        "type": "string",
                        "description": "Manufacturing place / country (e.g. `france`, `italy`, `germany`)."
                    },
                    "productUrls": {
                        "title": "Product URLs (mode=byUrls)",
                        "type": "array",
                        "description": "Direct product URLs like `https://world.openfoodfacts.org/product/3017620422003`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "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",
                            "russia",
                            "china",
                            "south-korea",
                            "argentina",
                            "chile",
                            "colombia",
                            "south-africa"
                        ],
                        "type": "string",
                        "description": "Restrict results to products sold in a specific country (also drives the country API host).",
                        "default": "any"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "any",
                            "en",
                            "fr",
                            "de",
                            "it",
                            "es",
                            "pt",
                            "nl",
                            "pl",
                            "ru",
                            "ja",
                            "zh",
                            "ko",
                            "ar",
                            "tr",
                            "sv",
                            "da",
                            "no",
                            "fi",
                            "cs",
                            "el",
                            "he",
                            "th",
                            "vi",
                            "id",
                            "ms",
                            "ro",
                            "hu",
                            "uk",
                            "hi",
                            "bn"
                        ],
                        "type": "string",
                        "description": "Preferred language for `productName` / `ingredientsText` (ISO 639-1).",
                        "default": "any"
                    },
                    "novaGroup": {
                        "title": "NOVA processing levels",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "NOVA food-processing classification (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": []
                    },
                    "nutriscore": {
                        "title": "Nutri-Score grades",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by Nutri-Score letter (A best → E worst). Multi-select.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "A",
                                "B",
                                "C",
                                "D",
                                "E",
                                "unknown"
                            ],
                            "enumTitles": [
                                "A",
                                "B",
                                "C",
                                "D",
                                "E",
                                "Unknown"
                            ]
                        },
                        "default": []
                    },
                    "ecoscore": {
                        "title": "Eco-Score grades",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by Eco-Score letter (A best → E worst). Multi-select.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "A",
                                "B",
                                "C",
                                "D",
                                "E",
                                "unknown"
                            ],
                            "enumTitles": [
                                "A",
                                "B",
                                "C",
                                "D",
                                "E",
                                "Unknown"
                            ]
                        },
                        "default": []
                    },
                    "containsLabels": {
                        "title": "Must contain labels",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Require every selected label to appear on the product.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "organic",
                                "vegan",
                                "vegetarian",
                                "gluten-free",
                                "no-gluten",
                                "fair-trade",
                                "kosher",
                                "halal",
                                "no-lactose",
                                "no-palm-oil",
                                "no-added-sugar",
                                "no-preservatives",
                                "no-colorings"
                            ],
                            "enumTitles": [
                                "Organic",
                                "Vegan",
                                "Vegetarian",
                                "Gluten-free",
                                "No gluten",
                                "Fair trade",
                                "Kosher",
                                "Halal",
                                "No lactose",
                                "No palm oil",
                                "No added sugar",
                                "No preservatives",
                                "No colorings"
                            ]
                        },
                        "default": []
                    },
                    "excludesAllergens": {
                        "title": "Exclude allergens",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Drop products containing any of the selected allergens.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "milk",
                                "eggs",
                                "gluten",
                                "peanuts",
                                "soybeans",
                                "fish",
                                "crustaceans",
                                "molluscs",
                                "tree-nuts",
                                "sesame-seeds",
                                "celery",
                                "mustard",
                                "lupin",
                                "sulphur-dioxide-and-sulphites"
                            ],
                            "enumTitles": [
                                "Milk",
                                "Eggs",
                                "Gluten",
                                "Peanuts",
                                "Soybeans",
                                "Fish",
                                "Crustaceans",
                                "Molluscs",
                                "Tree nuts",
                                "Sesame seeds",
                                "Celery",
                                "Mustard",
                                "Lupin",
                                "Sulphites (SO2)"
                            ]
                        },
                        "default": []
                    },
                    "minProductCompleteness": {
                        "title": "Min product completeness (0-1)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Drop products whose completeness score is below this percentage. 0=any, 100=fully complete.",
                        "default": 0
                    },
                    "containsKeyword": {
                        "title": "Must contain keyword",
                        "type": "string",
                        "description": "Post-fetch substring match against `productName` / brand / ingredients."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
