# Gaspedaal.nl Scraper — Dutch Used Car Listings & Prices (`studio-amba/gaspedaal-scraper`) Actor

Scrape used car listings from Gaspedaal.nl, the Netherlands' largest used car search aggregator (ANWB-owned). Extract prices, mileage, fuel type, year, transmission, dealer and location for any brand/model. No login required.

- **URL**: https://apify.com/studio-amba/gaspedaal-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, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 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.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Gaspedaal.nl Scraper — Dutch Used Car Listings, Prices & Dealer Data

Scrape used car listings from [Gaspedaal.nl](https://www.gaspedaal.nl), the Netherlands' largest used car search aggregator, owned by ANWB (the Dutch automobile association). Extract prices, mileage, fuel type, transmission, year, colour, and dealer details for any brand and model.

### What is Gaspedaal.nl?

Gaspedaal.nl aggregates used car listings from dealers across the Netherlands into a single searchable index — similar in role to AutoScout24 in Germany or AutoTrader in the UK, but focused entirely on the Dutch market. It does not host its own classifieds; it indexes dealer inventory and points buyers to the seller. If a used car is for sale by a Dutch dealer, it is very likely indexed on Gaspedaal.

This actor reads the site's own structured data (embedded JSON-LD `ItemList` blocks) directly from the search-result HTML, so results are exactly what Google sees and exactly what the site itself publishes as the source of truth for each listing. What you can build with it:

- **Market valuation** — estimate fair asking prices for a specific make, model and year by pulling live listings across the Dutch market.
- **Price trend tracking** — schedule weekly runs for a model and compare price/mileage distributions over time.
- **Dealer intelligence** — see which dealers carry the most stock for a given brand, and how their pricing compares.
- **Inventory sourcing** — used car exporters and traders scanning for underpriced or specific-spec vehicles.
- **Insurance / financing calibration** — insurtechs and lenders benchmarking Dutch used car values.

### What data does Gaspedaal Scraper extract?

Each car listing includes:

- **Title** — the full listing headline (trim, engine, notable options)
- **Brand and model** — normalised from the site's own structured data
- **Body type** — Hatchback, SUV, Sedan, Stationwagen, etc.
- **Fuel type** — Benzine, Diesel, Hybride, Elektrisch, LPG
- **Year** — production year
- **Mileage** — kilometres on the odometer
- **Transmission** — Automaat or Handmatig
- **Colour** and **number of doors**
- **Price** and **currency** (always EUR)
- **Stock status** — whether the listing is currently marked available
- **Dealer name, dealer link, city and region**
- **Image URL**
- **Listing URL** — anchor link to the exact listing on the Gaspedaal search-result page

### How to scrape Gaspedaal data

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `brand` | String | No | Car brand slug, e.g. `"volkswagen"`, `"audi"`, `"bmw"` (default: `"volkswagen"`) |
| `model` | String | No | Car model slug, e.g. `"golf"`, `"a3"`, `"x5"` (default: `"golf"`). Leave empty to auto-discover and crawl up to 12 models for the brand |
| `maxResults` | Integer | No | Maximum listings to return (default: 100, max: 5,000) |
| `minYear` / `maxYear` | Integer | No | Restrict to a production-year range |
| `fuelType` | String | No | `benzine`, `diesel`, `hybride`, `elektrisch`, or `lpg` |
| `minPrice` / `maxPrice` | Integer | No | Restrict to a price range (EUR) |
| `maxMileage` | Integer | No | Only return cars at or below this mileage (km) |
| `proxyConfiguration` | Object | No | Proxy settings — optional, the site has no bot protection |

**Tips:**

- Brand and model use the site's own URL slugs. If unsure, browse `gaspedaal.nl/{brand}/{model}` in a browser first — whatever appears in the address bar is the slug to use.
- Leave `model` empty to fan out across a brand's model lineup automatically.
- Combine `minYear`/`maxYear` with a high `maxResults` to pull deep, specific slices (e.g. every 2018-2020 Golf) rather than just the newest 100 listings.
- Setting `fuelType` locks the crawl to that single filtered page (see limitations below) — combine with `maxResults` under 100 for a clean single-request run.

### Output

```json
{
    "listingId": "138767501",
    "listingTitle": "Volkswagen Golf - 1.4 TSI GTE | Trekhaak | Carplay",
    "brand": "Volkswagen",
    "model": "Golf",
    "bodyType": "Hatchback",
    "fuelType": "Hybride",
    "year": 2016,
    "mileage": 121210,
    "transmission": "Automaat",
    "color": "Wit",
    "numberOfDoors": 5,
    "price": 14750,
    "currency": "EUR",
    "inStock": true,
    "dealerName": "Onbekende dealer",
    "dealerUrl": "https://www.gaspedaal.nl/autobedrijven/vakgarage-middenpeel/aanbod",
    "city": "Ysselsteyn",
    "region": "Limburg",
    "imageUrl": "https://cdn.gaspedaal.nl/images/large/645c615d....jpg",
    "url": "https://www.gaspedaal.nl/volkswagen/golf#138767501",
    "searchBrand": "volkswagen",
    "searchModel": "golf",
    "scrapedAt": "2026-08-05T19:39:17.029Z"
}
```

### Coverage & limitations

Gaspedaal.nl's `robots.txt` blocks any URL containing a query string (`Disallow: /*?`) except a small allowlist that does not cover listing pagination (`/{brand}/{model}?page=N`). This actor is robots-compliant and never uses query-string pagination. Instead it slices results using the site's own path-based filters — e.g. `/volkswagen/golf/2016` — which carry no query string and are allowed. Each unique URL still caps at the first 100 listings (page 1), so:

- Runs slice by production year to go beyond 100 results, deduplicating listings that appear in more than one slice.
- Extremely popular single-year slices (e.g. a common recent model year) may have more than 100 listings; only the first 100 per slice are captured.
- Setting `fuelType` uses a single filtered page and does not layer with year-slicing (combined filters like `/golf/2016/diesel` return 404 on the site).
- There is no price- or mileage-based URL filter on the site, so `minPrice`, `maxPrice`, and `maxMileage` are applied after fetching, not as a crawl narrower.
- Gaspedaal itself has no standalone per-listing detail page — clicking a listing redirects to the dealer's own site (a path explicitly disallowed for crawling in `robots.txt`). The `url` field is the listing's anchor on the Gaspedaal search-result page, which is stable and unique per listing.

### How much does it cost?

Cost estimate: roughly **$0.00005 per result** (STANDARD pay-per-result pricing). This actor makes one plain HTTP request per 100 results (or per year-slice once you exceed the first 100 for a model) — no browser rendering, no anti-bot bypass needed.

| Volume | Requests | Estimated cost |
|--------|----------|-----------------|
| 100 cars | 1 | ~$0.005 |
| 500 cars | ~5 | ~$0.025 |
| 1,000 cars | ~10 | ~$0.05 |

Usage cost only settles once a run finishes with status **SUCCEEDED** — a run that fails or is aborted early does not bill for partial results.

### Can I integrate?

Feed Dutch used car data into your systems:

- **Google Sheets** — maintain a live inventory tracker for a specific brand and model
- **Slack** — alert on underpriced listings matching your criteria
- **Zapier / Make** — automate price-monitoring workflows
- **PostgreSQL / BigQuery** — build a historical Dutch used car price database
- **Power BI / Tableau** — visualise market trends and price distributions

### Can I use it as an API?

Yes. Build Dutch car market intelligence into your products:

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("studio-amba/gaspedaal-scraper").call(run_input={
    "brand": "volkswagen",
    "model": "golf",
    "maxResults": 300,
})

for car in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{car['listingTitle']} - EUR {car['price']} | {car.get('mileage', '?')} km | {car.get('year', '?')}")
```

**JavaScript:**

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

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

const run = await client.actor("studio-amba/gaspedaal-scraper").call({
    brand: "volkswagen",
    model: "golf",
    maxResults: 300,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((car) => {
    console.log(`${car.listingTitle} - EUR ${car.price} | ${car.mileage || "?"} km`);
});
```

### FAQ

**Does this cover new cars too?**
No, Gaspedaal.nl (and this actor) covers used/second-hand cars only.

**Can I search by keyword instead of brand/model?**
The site is structured by brand and model URLs rather than free-text search, so this actor takes `brand`/`model` inputs. Leave `model` empty to sweep an entire brand's lineup.

**Why do some runs return fewer than `maxResults`?**
If a brand/model/filter combination has fewer live listings than requested, or the request budget (60 requests/run) is exhausted while filters are excluding most results, the run returns whatever it found. Check the run log for the "listed X total on this slice" lines to see actual site inventory.

**Does it include dealer contact details?**
Dealer name, city and region are extracted. Direct phone/email is not published on the aggregator listing itself — that lives on the dealer's own site, one click away via `dealerUrl`.

**How current are the listings?**
Gaspedaal reflects live dealer inventory. Cars that sell get removed from the index within days. Schedule weekly runs to track market changes.

**Is proxy required?**
No. Gaspedaal.nl has no bot-detection wall. Proxy is available in the input for reliability on larger runs but is not required for normal use.

### Related car and Dutch market scrapers

- [AutoScout24 Scraper](https://apify.com/studio-amba/autoscout24-scraper) — pan-European used car listings, including the Netherlands
- [Marktplaats Scraper](https://apify.com/studio-amba/marktplaats-scraper) — the Netherlands' largest classifieds site, including private-seller cars
- [Funda Scraper](https://apify.com/studio-amba/funda-scraper) — Dutch real estate listings
- [AutoVlan / GoCar Scraper](https://apify.com/studio-amba/autovlan-scraper) — Belgium's largest used car marketplace

### Your feedback

Want support for additional filters, historical price tracking, or found a parsing issue? Open an issue on GitHub or contact us through the Apify platform. Your feedback drives what we build next.

# Actor input Schema

## `brand` (type: `string`):

Car brand to scrape, using the site's own slug (lowercase, e.g. 'volkswagen', 'audi', 'bmw', 'toyota'). Spaces are converted to dashes automatically.

## `model` (type: `string`):

Car model to scrape (e.g. 'golf', 'a3', 'x5'). Leave empty to auto-discover and scrape multiple models for the given brand (up to 12).

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

Maximum number of car listings to return. Gaspedaal.nl's robots.txt blocks query-string pagination (?page=N), so this actor slices results using the site's own path filters (production year, one page of up to 100 listings per year). Very large values may not be reachable for niche brand/model combinations — see the README for details.

## `minYear` (type: `integer`):

Only return cars built in this year or later.

## `maxYear` (type: `integer`):

Only return cars built in this year or earlier.

## `fuelType` (type: `string`):

Restrict to a single fuel type using the site's own filter page (e.g. /volkswagen/golf/diesel). When set, this replaces year-based slicing, so results are capped at the first 100 listings for that fuel type.

## `minPrice` (type: `integer`):

Only return cars priced at this amount or higher.

## `maxPrice` (type: `integer`):

Only return cars priced at this amount or lower.

## `maxMileage` (type: `integer`):

Only return cars with this mileage or lower.

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

Gaspedaal.nl has no bot protection — proxy is optional but recommended for reliability on larger runs.

## Actor input object example

```json
{
  "brand": "volkswagen",
  "model": "golf",
  "maxResults": 100,
  "fuelType": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NL"
  }
}
```

# 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 = {
    "brand": "volkswagen",
    "model": "golf",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "NL"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/gaspedaal-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 = {
    "brand": "volkswagen",
    "model": "golf",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "NL",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/gaspedaal-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 '{
  "brand": "volkswagen",
  "model": "golf",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "NL"
  }
}' |
apify call studio-amba/gaspedaal-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/gaspedaal-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/JlGNfWxOQUmyck3ky/builds/LuCE6IM8pz5yEBd9m/openapi.json