# HelloFresh Scraper — Belgian Meal Kit Recipes & Nutrition (`studio-amba/hellofresh-scraper`) Actor

Scrape recipe data from HelloFresh Belgium — ingredients, nutrition info, prep times, allergens, and tags from the meal kit delivery service.

- **URL**: https://apify.com/studio-amba/hellofresh-scraper.md
- **Developed by:** [Jelle Desramaults](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## HelloFresh Belgium Scraper -- Weekly Recipes, Ingredients, Nutrition & Meal Plans

Extract recipe data from [HelloFresh Belgium](https://www.hellofresh.be) -- the meal kit delivery service offering weekly menus with full ingredient lists, nutritional information, preparation times, allergens, and dietary tags for the Belgian market.

### What is HelloFresh Scraper?

HelloFresh is the world's largest meal kit company, and their Belgian operation delivers pre-portioned ingredient boxes with step-by-step recipes to households across the country. Their recipe database is a goldmine of structured food data: every recipe has precise ingredients, nutritional breakdowns, allergen declarations, difficulty ratings, and categorisation tags -- all localised for the Belgian market (Dutch-language, nl-BE locale).

This actor authenticates against the HelloFresh Belgium API and paginate through their recipe search endpoint, returning rich structured data. What you can build with it:

- **Nutritional analysis** -- dietitians and health tech companies analyse HelloFresh's meal compositions to understand commercial meal kit nutrition profiles and create comparison reports.
- **Recipe aggregation** -- food platforms and cooking apps integrate HelloFresh recipes to expand their Belgian recipe databases with professionally developed, tested recipes.
- **Competitive intelligence** -- rival meal kit services and food retailers monitor HelloFresh's weekly menu strategy, ingredient choices, pricing signals, and dietary trend adoption.
- **Ingredient demand forecasting** -- food suppliers and grocery chains track which ingredients HelloFresh features to predict demand shifts in the Belgian market.
- **Content creation** -- food bloggers and media companies use recipe metadata (tags, difficulty, prep time) to generate content ideas and trend pieces about Belgian meal preferences.

### What data does HelloFresh Scraper extract?

Each recipe contains:

- :cook: **Recipe name** -- the dish title
- :scroll: **Description** -- detailed recipe description
- :carrot: **Ingredients** -- full ingredient list with individual items
- :chart_with_upwards_trend: **Nutrition info** -- calories, protein, fat, carbs, fibre, salt as key-value pairs
- :timer_clock: **Prep time** -- total cooking time (e.g., "35 min")
- :muscle: **Difficulty** -- Easy, Medium, or Hard
- :moneybag: **Servings** -- number of portions
- :camera: **Image** -- high-quality recipe photo from HelloFresh's CDN
- :label: **Tags** -- dietary and cuisine tags (Vegetarisch, Snel klaar, Gezinsrecept, etc.)
- :warning: **Allergens** -- declared allergens (gluten, lactose, noten, etc.)
- :link: **URL** -- direct link to the recipe on hellofresh.be
- :date: **Week** -- which weekly menu the recipe belongs to

### How to scrape HelloFresh Belgium

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `week` | String | No | Week in YYYY-Www format: `"2026-W14"`. Default: current week. Use `"current"` or leave empty. |
| `maxResults` | Integer | No | Maximum recipes to return (default: 100, max: 500) |
| `proxyConfiguration` | Object | No | Proxy settings (API is public but rate-limited) |

**Tips:**

- Leave `week` empty to get the current week's recipes -- the most common use case.
- Set a high `maxResults` to capture the full recipe archive, not just the current menu.
- The actor extracts an authentication token from the HelloFresh Belgium website automatically. No API key needed from your side.
- Recipes are ordered by date (newest first), so the first results are always the most recent offerings.

### Output

```json
{
    "recipeName": "Romige pasta met champignons en spinazie",
    "description": "Een heerlijke romige pasta met verse champignons, babyspinazie en Parmezaanse kaas. Klaar in 30 minuten.",
    "ingredients": [
        "Penne",
        "Champignons",
        "Babyspinazie",
        "Kookroom",
        "Parmezaanse kaas",
        "Knoflook",
        "Sjalot",
        "Olijfolie",
        "Peper en zout"
    ],
    "nutritionInfo": {
        "Energy (kcal)": "685kcal",
        "Fat": "28g",
        "Saturated Fat": "14g",
        "Carbohydrate": "78g",
        "Sugar": "6g",
        "Protein": "25g",
        "Salt": "1.8g"
    },
    "prepTime": "30 min",
    "difficulty": "Easy",
    "price": "2 servings",
    "imageUrl": "https://img.hellofresh.com/f_auto,fl_lossy,q_auto,w_800/hellofresh_s3/romige-pasta-champignons.jpg",
    "tags": ["Snel klaar", "Vegetarisch", "Klassiek"],
    "allergens": ["Gluten", "Melk", "Eieren"],
    "url": "https://www.hellofresh.be/recipes/romige-pasta-champignons-abc123",
    "weekStartDate": "2026-W14",
    "scrapedAt": "2026-04-03T14:00:00.000Z"
}
````

### How much does it cost?

HelloFresh Scraper makes direct API calls (no browser rendering):

| Volume | Estimated CUs | Estimated Cost |
|--------|--------------|----------------|
| 20 recipes (1 week) | ~0.01 | ~$0.005 |
| 100 recipes | ~0.03 | ~$0.015 |
| 500 recipes (full archive) | ~0.10 | ~$0.05 |

Very efficient because it queries a structured JSON API.

### Can I integrate?

Feed HelloFresh recipe data into your nutrition and food tools:

- **Google Sheets** -- build a weekly meal planning spreadsheet with nutrition data auto-updated
- **Slack** -- share this week's HelloFresh menu with your team or household
- **Zapier / Make** -- trigger grocery ordering workflows based on ingredient lists
- **Webhooks** -- stream recipe data to your meal planning app or nutrition tracker
- **PostgreSQL / MongoDB** -- build a searchable recipe database for your food tech product
- **Airtable** -- visual recipe catalogue with filtering by difficulty, prep time, and allergens

### Can I use it as an API?

Yes. Integrate Belgian meal kit data into your application:

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/hellofresh-scraper").call(run_input={
    "week": "current",
    "maxResults": 30,
})

for recipe in client.dataset(run["defaultDatasetId"]).iterate_items():
    kcal = recipe.get("nutritionInfo", {}).get("Energy (kcal)", "?")
    print(f"{recipe['recipeName']} | {recipe['prepTime']} | {kcal} | {recipe['difficulty']}")
```

**JavaScript:**

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("studio-amba/hellofresh-scraper").call({
    week: "current",
    maxResults: 30,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const veggie = items.filter((r) => r.tags.some((t) => t.toLowerCase().includes("vegetarisch")));
console.log(`${veggie.length} vegetarian recipes this week:`);
veggie.forEach((r) => console.log(`  ${r.recipeName} (${r.prepTime})`));
```

### FAQ

**Does this scrape only Belgian HelloFresh or other countries too?**
Only HelloFresh Belgium (hellofresh.be). The actor uses the Belgian locale (nl-BE) and the .be domain for authentication.

**Are the ingredient quantities included?**
The ingredient names are extracted. Exact quantities per portion depend on the API's response depth and may not always be present in the search results endpoint.

**How many recipes does HelloFresh Belgium offer per week?**
Typically 20-30 recipes per weekly menu, with variations for different plan types (veggie, family, classic).

**Can I get step-by-step cooking instructions?**
The current actor extracts recipe metadata from the search API. Detailed cooking steps would require visiting individual recipe pages, which is not implemented yet.

**Does it include pricing per recipe?**
HelloFresh does not expose per-recipe pricing in their search API. The `price` field shows the serving count instead. Subscription pricing depends on the plan and delivery frequency.

**Are allergens reliable?**
Allergen data comes directly from HelloFresh's structured recipe data and should be as accurate as what they display on their website. Always verify allergens for medical dietary needs.

**Can I compare HelloFresh Belgium with other countries?**
This actor targets HelloFresh.be specifically. HelloFresh operates in many countries with different menus. For cross-country recipe analysis, you would need separate actors for each country.

**What tags does HelloFresh use?**
Common Belgian HelloFresh tags include: Snel klaar (Quick), Vegetarisch (Vegetarian), Gezinsrecept (Family recipe), Calorie Smart, Premium, Klassiek (Classic), and various cuisine tags like Aziatisch, Italiaans, Mexicaans.

**How are nutrition values calculated?**
HelloFresh provides nutrition per serving based on their own dietary analysis. Values include calories (kcal), fat, saturated fat, carbohydrates, sugar, protein, fibre, and salt -- all extracted as key-value pairs.

### Limitations

- Authentication token is extracted from the HelloFresh website SSR payload. If HelloFresh changes their authentication flow, the actor may need updates.
- The recipe search API may not return the same recipes visible in the weekly menu selector (which requires login and plan selection).
- Per-recipe pricing is not available through the search endpoint. Only serving counts are extracted.
- Detailed cooking steps are not extracted -- only metadata, ingredients, and nutrition.
- The API may rate-limit requests. The actor handles pagination with reasonable delays, but very large requests could be throttled.

### Related food and Belgian scrapers

- [Resto.be Scraper](https://apify.com/studio-amba/resto-scraper) -- Belgian restaurant guide with Michelin stars and Gault Millau scores
- [UiTinVlaanderen Scraper](https://apify.com/studio-amba/uitinvlaanderen-scraper) -- Flemish cultural events including food festivals
- [Norauto Scraper](https://apify.com/studio-amba/norauto-scraper) -- French retail products (for when you need to drive to pick up groceries)

### Your feedback

Want cooking step extraction, multi-country support, or specific dietary filters? Open an issue on GitHub or contact us through the Apify platform. We build what users need most.

# Actor input Schema

## `week` (type: `string`):

Week to scrape in YYYY-Www format (e.g. '2026-W11'). Defaults to current week. Use 'current' or leave empty for this week.

## `maxResults` (type: `integer`):

Maximum number of recipes to return.

## `proxyConfiguration` (type: `object`):

Proxy settings. HelloFresh API is public but rate-limited.

## Actor input object example

```json
{
  "maxResults": 100
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/hellofresh-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/hellofresh-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 '{}' |
apify call studio-amba/hellofresh-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HelloFresh Scraper — Belgian Meal Kit Recipes & Nutrition",
        "description": "Scrape recipe data from HelloFresh Belgium — ingredients, nutrition info, prep times, allergens, and tags from the meal kit delivery service.",
        "version": "0.1",
        "x-build-id": "gKGuXfIj7ys8OcWEb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~hellofresh-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-hellofresh-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/studio-amba~hellofresh-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-hellofresh-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/studio-amba~hellofresh-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-hellofresh-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "week": {
                        "title": "Week",
                        "type": "string",
                        "description": "Week to scrape in YYYY-Www format (e.g. '2026-W11'). Defaults to current week. Use 'current' or leave empty for this week."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of recipes to return.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. HelloFresh API is public but rate-limited."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```