How to Scrape Marktplaats NL Classifieds in 2026

Marktplaats is the Netherlands’ dominant classifieds marketplace — the Dutch equivalent of Craigslist plus eBay, where cars, electronics, furniture, and bikes change hands by the millions of listings. For anyone doing price monitoring, resale arbitrage, or market research in the Dutch market, it’s the single richest source of asking-price and supply data. But it’s a consumer marketplace built for one person browsing one category, and it doesn’t hand you a bulk export. This guide covers what each listing exposes, how to pull it efficiently by reading the site’s own embedded JSON instead of rendering pages, and what to watch when you turn it into a dataset.

What’s worth extracting

For each listing, Marktplaats exposes a consistent structured payload:

• Title and description — the listing headline and body text.
• Price and price type — the amount, plus the type: fixed price, auction/bidding, on-request, or free (“gratis”). The type matters enormously and is easy to miss.
• Location — town/region, often with coordinates.
• Seller — the seller’s identity / display name.
• Listing date and category — when posted and where it sits in the category tree.
• Item attributes — category-specific structured fields: for vehicles, construction year, mileage, fuel type; for electronics, model, storage, condition.
• Primary image URL — the main photo.
• Listing URL and ID — the canonical link and a stable identifier.

For most use cases — price tracking, arbitrage, dealer intelligence — price (with its type), location, date, and the category-specific attributes are the core. The attributes are what make Marktplaats data analytically valuable: you can’t build a used-car pricing model without year and mileage on each row.

The smart approach: read the embedded JSON

Marktplaats, like most modern marketplaces, renders its listing pages from structured JSON embedded in the page rather than from server-side HTML you’d have to parse selector-by-selector. That’s the key to scraping it efficiently:

1. No browser needed. You can fetch the page over plain HTTP and read the embedded JSON payload directly — no headless Chrome, no JavaScript execution. That’s an order of magnitude cheaper and faster than rendering.
2. Structured data, not DOM scraping. Pulling fields from the embedded JSON is far more stable than chasing CSS selectors that change with every redesign. The JSON schema shifts less often than the visible layout.
3. Attributes come pre-structured. The category-specific attributes (year, mileage, model, storage) are already typed in the JSON — you don’t have to regex them out of free-text descriptions.

What you still have to get right:

• Pagination. A keyword search or category sweep spans many pages; you walk them all.
• De-duplication. The same listing can surface across multiple pages or overlapping searches — collapse on the listing ID.
• Politeness. Even reading JSON over HTTP, you pace requests so you’re a well-behaved client and don’t trip rate limiting. Marktplaats isn’t a fortress like a flights site, but it isn’t a free-for-all either.

This embedded-JSON-via-HTTP approach is the difference between a cheap, reliable scraper and a brittle browser farm. A managed actor builds the JSON-reading, pagination, and de-dup once so you reuse it.

▶ Run the Marktplaats Scraper — bulk listings by keyword or category: price and price type, location with coordinates, seller, date, photos and item attributes. Reads embedded JSON over HTTP, auto-paginated and de-duplicated. Clean JSON, CSV, or Excel.

How the search structure works

You drive it with keywords and/or category sweeps; pagination and de-dup happen underneath:

keywords:    ["iphone 15", "racefiets"]      # keyword search
categories:  ["auto-s", "telefoons"]          # full category sweep
mode:        walk all pages, de-dup on listing ID
output:      one row per unique listing with typed attributes

A keyword search is precise; a category sweep is broad — for a price index or supply analysis you sweep a whole category, while for arbitrage you watch tight keyword queries frequently. Either way the run pages to the end and returns a de-duplicated, attribute-rich table.

Schema design for downstream use

A clean per-listing schema, keeping the category attributes as a nested object so you don’t have to flatten across heterogeneous categories:

{
  "listing_id": "m2098441223",
  "title": "Volkswagen Golf 1.4 TSI 2019",
  "price": 14950,
  "price_type": "fixed",
  "currency": "EUR",
  "location": "Utrecht",
  "lat": 52.0907,
  "lon": 5.1214,
  "seller": "AutoHandel Jansen",
  "posted_date": "2026-05-26",
  "category": "auto-s",
  "attributes": {
    "construction_year": 2019,
    "mileage_km": 78000,
    "fuel": "Benzine"
  },
  "main_image_url": "https://images.marktplaats.com/...",
  "url": "https://www.marktplaats.nl/v/...",
  "scraped_at": "2026-05-27T12:00:00Z"
}

Schema choices worth making early:

• Always store price_type next to price. A “€1” on-request or a “free” listing is not a real €1 sale — without the type your price stats are garbage.
• Keep attributes nested. Categories have wildly different fields; a flat schema either explodes into hundreds of mostly-null columns or loses data. Nest it.
• Use listing_id as the de-dup key. Titles and prices repeat; the ID is the only stable join.
• Store coordinates when present. Regional price differences are real in the Dutch market; lat/lon lets you map supply and price by region.
• Log scraped_at and posted_date separately. Asking prices change over a listing’s life; you need both to track price movements and listing age.

Typical use cases

What people actually do with Marktplaats data:

• Price monitoring — track asking prices across a category over time to spot trends.
• Resale and arbitrage — detect underpriced listings as they appear and flag below-median prices for a quick flip.
• Market and pricing research — analyze supply, demand, and price distribution by category or region in the Netherlands.
• Dealer and inventory intelligence — for cars, electronics, furniture, and bikes, understand what’s on the market and at what price.
• Used-car pricing models — sweep vehicle listings and correlate price against construction year and mileage.
• Electronics price index — track phones, consoles, and laptops over time.
• Seller lead generation — collect active sellers in a niche for B2B outreach or partnership development.

The common thread: the value is in freshness and the structured attributes. A static dump is a snapshot; a frequently-refreshed sweep with year/mileage/condition on every row is the foundation of a pricing model or an arbitrage bot.

Cost math for the managed approach

Because this reads embedded JSON over HTTP — no browser, no residential-proxy bandwidth — it’s cheap. Pricing is a trivial per-start charge ($0.00005) with no per-result fee; the listings come back free. A frequent arbitrage sweep of a few categories, or a daily price-index run pulling thousands of listings, costs effectively nothing beyond compute.

Compare to building it yourself:

• The embedded-JSON approach is simple once you find the payload — an MVP is a few hours.
• The ongoing work is pagination edge cases, de-dup, mapping the heterogeneous category attributes into a stable schema, and keeping a frequent schedule healthy. That’s the plumbing a managed actor saves.

There’s no anti-bot arms race here, so the maintenance burden is low — the reason to use a managed run is to skip the JSON-parsing and attribute-mapping plumbing and get a schedule-ready, de-duplicated feed on day one.

Common pitfalls

A few things to know before you build a Marktplaats pipeline:

• Price type is load-bearing. Auction, on-request, and free listings will wreck a naive average. Filter or segment by price_type before computing stats.
• Attributes vary by category. Don’t expect mileage on a furniture listing. Keep the attributes nested and handle missing fields per category.
• Asking price ≠ sold price. Marktplaats shows what sellers want, not what items fetch. It’s a strong demand-side signal, but treat it as asking-price intelligence, not transaction data.
• Listings linger. A listing can stay up after the item sells. Use the posted date and re-scrape to track which listings persist or drop.
• Dutch-language fields. Categories, fuel types, and conditions come in Dutch (Benzine, Diesel, Zo goed als nieuw). Normalize consistently or your group-bys fragment.

Wrapping up

Marktplaats is the richest classifieds source in the Dutch market, and because it renders from embedded JSON you can scrape it cheaply over HTTP without a browser. The hard part isn’t anti-bot — it’s the plumbing: pagination, de-dup, and mapping each category’s attributes into a stable schema. If you need fifty listings once, a quick script does it. If you need a frequently-refreshed, de-duplicated, attribute-rich feed for pricing or arbitrage, let a managed actor handle the plumbing.

▶ Open the Marktplaats Scraper on Apify — bulk NL classifieds by keyword or category, with price type, location and typed item attributes. HTTP-only, schedule-ready. Start with Apify’s free monthly credit.