# HelloFresh Belgium Scraper — Weekly Recipes & Menus (`studio-amba/hellofresh-scraper`) Actor

Scrape HelloFresh Belgium recipes and weekly menus — ingredients, nutrition, prep time, allergens, and pricing.

- **URL**: https://apify.com/studio-amba/hellofresh-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 result scrapeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# 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

### 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,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BE"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "BE"
    }
};

// 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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "BE",
    } }

# 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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BE"
  }
}' |
apify call studio-amba/hellofresh-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/hellofresh-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/NnS1yVIHJQmWLWa75/builds/0ewZQ3s97OmW5ec6b/openapi.json