# Neckermann Scraper — Belgian Holiday Packages & Hotels (`studio-amba/neckermann-scraper`) Actor

Scrape holiday packages, hotels, prices, ratings, and flight details from Neckermann.be. Supports destination filtering, meal plans, and travel dates. No login required.

- **URL**: https://apify.com/studio-amba/neckermann-scraper.md
- **Developed by:** [Studio Amba](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 usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## Neckermann Scraper

Scrape holiday packages, hotels, prices, ratings, and flight details from Neckermann.be. Neckermann is one of Belgium's most popular travel booking platforms, offering package holidays (flights + hotel), bus trips, and accommodation-only deals across 50+ destinations worldwide.

### How it works

Neckermann Scraper calls the internal search API used by Neckermann.be to fetch holiday package data. The API returns structured HTML fragments with hotel details, prices, reviews, and travel information. The scraper parses these fragments and enriches them with structured pricing data when available.

This approach is fast and reliable because it skips browser rendering entirely and directly consumes the backend search endpoint.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `destination` | string | `"Spanje"` | Destination country in Dutch (e.g., `"Griekenland"`, `"Turkije"`, `"Egypte"`) |
| `departureDate` | string | 30 days from now | Earliest departure date in `YYYY-MM-DD` format |
| `duration` | integer | `7` | Trip duration in nights (`7` or `14`) |
| `travelers` | integer | `2` | Number of adult travelers |
| `maxResults` | integer | `50` | Maximum number of packages to return |
| `proxyConfiguration` | object | Belgian residential | Proxy settings |

All fields are optional. If you send an empty input `{}`, the scraper uses sensible defaults (Spain, 7 nights, 2 adults).

#### Supported destinations

The scraper supports all destinations available on Neckermann.be, including:

- **Popular**: Spanje, Griekenland, Turkije, Egypte, Tunesie, Portugal, Italie
- **Exotic**: Dominicaanse Republiek, Curacao, Thailand, Mexico, Jamaica
- **European**: Kroatie, Bulgarije, Malta, Cyprus, Montenegro
- **Winter sports**: Oostenrijk, Zwitserland, Frankrijk

Use Dutch names as shown above. The scraper maps them to the internal geo codes automatically.

### Output

| Field | Type | Example |
|-------|------|---------|
| `title` | string | `"Iberostar Selection Es Trenc"` |
| `destination` | string | `"Spanje > Mallorca > Colonia Sant Jordi"` |
| `country` | string | `"Spanje"` |
| `region` | string | `"Mallorca"` |
| `city` | string | `"Colonia Sant Jordi"` |
| `departureDate` | string | `"2026-06-15"` |
| `returnDate` | string | `"2026-06-22"` |
| `duration` | integer | `7` |
| `price` | number | `574` |
| `currency` | string | `"EUR"` |
| `priceTotal` | number | `1148` |
| `hotel` | string | `"Iberostar Selection Es Trenc"` |
| `stars` | integer | `5` |
| `rating` | number | `9.4` |
| `reviewCount` | integer | `10` |
| `boardType` | string | `"Logies"` |
| `transport` | string | `"Flight"` |
| `departureAirport` | string | `"Brussel"` |
| `tags` | array | `["Aanrader", "Iberostar"]` |
| `url` | string | Full package URL |
| `imageUrl` | string | Hotel image URL |
| `scrapedAt` | string | ISO 8601 timestamp |

#### Board types

Neckermann uses Dutch names for meal plans:

| Dutch | English |
|-------|---------|
| All inclusive | All inclusive |
| Volpension | Full board |
| Halfpension | Half board |
| Logies en ontbijt | Bed & breakfast |
| Logies | Room only |

### Cost

The scraper uses the search API directly (no browser), so it runs fast and cheap. Expect about 1,000 results per $1 on Apify.

### How to scrape Neckermann data

This Actor automates the process of extracting structured holiday package data from Neckermann.be, Belgium's largest travel booking platform. You can run it directly from the Apify console, the Apify API, or any of the official SDKs (JavaScript, Python).

The scraper handles pagination automatically and respects the site's rate limits.

#### Typical workflows

- **Price monitoring**: Track package prices to a destination over time and alert when deals appear
- **Competitive analysis**: Compare Neckermann prices against TUI, Thomas Cook, or Sunweb
- **Market research**: Analyze which destinations, hotels, and board types are most popular
- **Travel aggregation**: Build a holiday comparison tool that includes Neckermann offers
- **Lead generation**: Feed package data into affiliate sites or travel comparison platforms

#### Step-by-step

1. Open the **Input** tab and set your destination (e.g., `"Spanje"`)
2. Optionally set departure date, duration, and traveler count
3. Click **Start** and wait for the run to complete
4. Download results from the **Output** tab in JSON, CSV, Excel, XML, or HTML
5. Schedule recurring runs from the **Schedule** tab for ongoing monitoring

#### Programmatic usage

Trigger runs from your backend via the Apify API and retrieve the dataset when finished. Works with Zapier, Make, n8n, BigQuery, and Google Sheets via webhooks.

### How to use Neckermann Scraper

1. Navigate to the **Input** tab
2. Enter your destination in Dutch (or leave empty for Spain)
3. Adjust travel dates, duration, and number of travelers
4. Set `maxResults` to control how many packages you want
5. Click **Start** to begin the scrape
6. Results appear in the **Output** tab as structured JSON

### Tips for best results

- **Start small**: Run with `maxResults: 10` before launching large jobs
- **Use proxies**: Belgian residential proxies give the best results since Neckermann.be is a Belgian site
- **Check seasonality**: Travel results vary heavily by season. Summer dates return more options than winter
- **Combine destinations**: Run multiple scrapes for different destinations to build a comprehensive dataset
- **Schedule runs**: Daily or weekly runs are ideal for price tracking

### FAQ and support

**Is it legal to scrape Neckermann?** This Actor extracts publicly available travel package data. Always review the website's Terms of Service before scraping at scale.

**Why am I getting fewer results than expected?** Some destination and date combinations have limited availability. Try broadening your search (remove specific dates, try a different destination).

**Can I filter by board type or hotel rating?** The current version returns all available packages for a destination. Filter the results in post-processing for specific board types or star ratings.

**The scraper returns 0 results — what should I do?** Enable Apify Belgian residential proxies in the input. The site may block non-Belgian IPs. Also verify your destination name is in Dutch.

**Prices differ from the website — why?** Neckermann shows personalized pricing based on cookies, departure airports, and dynamic availability. The scraper sees the default prices for a fresh session.

For issues, feature requests, or bug reports, open a ticket in the Issues tab on the Actor page. We monitor every actor and ship fixes quickly when sites change.

# Actor input Schema

## `destination` (type: `string`):

Destination country or region name in Dutch (e.g., 'Spanje', 'Griekenland', 'Turkije'). Leave empty for all destinations.
## `departureDate` (type: `string`):

Earliest departure date in YYYY-MM-DD format. Defaults to 30 days from now if empty.
## `duration` (type: `integer`):

Trip duration in nights (7 or 14).
## `travelers` (type: `integer`):

Number of adult travelers.
## `maxResults` (type: `integer`):

Maximum number of holiday packages to return.
## `proxyConfiguration` (type: `object`):

Proxy settings for better reliability.

## Actor input object example

```json
{
  "destination": "Spanje",
  "duration": 7,
  "travelers": 2,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BE"
  }
}
````

# 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 = {
    "destination": "Spanje",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "BE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/neckermann-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 = {
    "destination": "Spanje",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "BE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/neckermann-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 '{
  "destination": "Spanje",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "BE"
  }
}' |
apify call studio-amba/neckermann-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Neckermann Scraper — Belgian Holiday Packages & Hotels",
        "description": "Scrape holiday packages, hotels, prices, ratings, and flight details from Neckermann.be. Supports destination filtering, meal plans, and travel dates. No login required.",
        "version": "0.1",
        "x-build-id": "7hIvY7bw5iSe908Zw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~neckermann-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-neckermann-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~neckermann-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-neckermann-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~neckermann-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-neckermann-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": {
                    "destination": {
                        "title": "Destination",
                        "type": "string",
                        "description": "Destination country or region name in Dutch (e.g., 'Spanje', 'Griekenland', 'Turkije'). Leave empty for all destinations.",
                        "default": "Spanje"
                    },
                    "departureDate": {
                        "title": "Departure Date",
                        "type": "string",
                        "description": "Earliest departure date in YYYY-MM-DD format. Defaults to 30 days from now if empty."
                    },
                    "duration": {
                        "title": "Duration (nights)",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Trip duration in nights (7 or 14).",
                        "default": 7
                    },
                    "travelers": {
                        "title": "Number of Travelers",
                        "minimum": 1,
                        "maximum": 6,
                        "type": "integer",
                        "description": "Number of adult travelers.",
                        "default": 2
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of holiday packages to return.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for better reliability."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
