# Marktplaats Listings Scraper (`fetch_cat/marktplaats-listings-scraper`) Actor

Scrape public Marktplaats.nl listings by keyword or search URL, including prices, sellers, locations, images, descriptions, and attributes.

- **URL**: https://apify.com/fetch\_cat/marktplaats-listings-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Business, Automation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 listing saveds

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

## Marktplaats Listings Scraper

Scrape public Marktplaats.nl marketplace search results and listing pages. The Actor returns Dutch classified listing data such as titles, URLs, prices, seller/location hints, images, descriptions, and listing IDs for ecommerce research, price monitoring, lead generation, and marketplace analysis.

### What you can get

- Search Marktplaats by keyword or by public search URL.
- Limit the number of listings with `maxItems`.
- Optionally visit detail pages with `includeDetails`.
- Export structured dataset rows for every saved public listing.
- Use proxy settings for larger or recurring marketplace monitoring runs.

### Who is it for

This Actor is useful for teams that need a repeatable export from Marktplaats.nl without manually copying listings from the website.

Typical users include:

- Ecommerce teams tracking second-hand product prices.
- Resellers comparing availability across cities or categories.
- Analysts measuring marketplace supply for a product keyword.
- Lead generation teams collecting public listing URLs for follow-up workflows.
- Automation builders who need Marktplaats data in a dataset, spreadsheet, or database.

### Typical use cases

Use the scraper when you need to:

- Monitor prices for phones, bicycles, furniture, cars, tools, or other classifieds categories.
- Build a current list of public offers for a search term.
- Compare search result volume across several keywords.
- Feed public listing data into BI tools or enrichment pipelines.
- Re-run the same Marktplaats URL regularly and compare new rows over time.

### Input

You can start with either keywords or public Marktplaats search URLs. You can also combine both in one run.

Important fields:

- `queries` - search keywords such as `iphone`, `bakfiets`, or `vintage lamp`.
- `startUrls` - full public Marktplaats search URLs.
- `maxItems` - maximum number of listing rows to save.
- `includeDetails` - whether to open detail pages for richer descriptions.
- `proxy` - optional Apify Proxy configuration.

### Examples

Use these example inputs as starting points for common Marktplaats.nl listing exports.

### Input recipes

Keyword search with a small result limit:

```json
{
  "queries": ["iphone"],
  "maxItems": 20,
  "includeDetails": false,
  "proxy": { "useApifyProxy": false }
}
```

Search URL with detail pages enabled:

```json
{
  "startUrls": [{ "url": "https://www.marktplaats.nl/q/bakfiets/" }],
  "maxItems": 50,
  "includeDetails": true,
  "proxy": { "useApifyProxy": true }
}
```

Multiple keywords in one run:

```json
{
  "queries": ["iphone 15", "macbook", "racefiets"],
  "maxItems": 100,
  "includeDetails": false,
  "proxy": { "useApifyProxy": true }
}
```

### Output

Each dataset item includes fields such as:

- `listingId`
- `title`
- `url`
- `searchUrl`
- `query`
- `rank`
- `priceText`
- `priceValue`
- `priceCurrency`
- `location`
- `city`
- `sellerName`
- `description`
- `detailDescription`
- `imageUrls`
- `scrapedAt`

### Output example

```json
{
  "listingId": "1234567890",
  "title": "Apple iPhone",
  "url": "https://www.marktplaats.nl/v/...",
  "searchUrl": "https://www.marktplaats.nl/q/iphone/",
  "query": "iphone",
  "rank": 1,
  "priceText": "€ 250,00",
  "priceValue": 250,
  "priceCurrency": "EUR",
  "location": null,
  "sellerName": null,
  "description": "Public listing description when available.",
  "detailDescription": "Public listing description when detail fetching is enabled.",
  "imageUrls": [],
  "scrapedAt": "2026-07-29T00:00:00.000Z"
}
```

### API usage

You can run the Actor from the Apify API or client libraries by passing the same JSON input shown above. Typical automation sets `queries` or `startUrls`, chooses a `maxItems` limit, and reads results from the default dataset after the run succeeds.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/marktplaats-listings-scraper').call({
  queries: ['iphone'],
  maxItems: 20,
  includeDetails: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/marktplaats-listings-scraper').call(run_input={
    'queries': ['iphone'],
    'maxItems': 20,
    'includeDetails': False,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~marktplaats-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries":["iphone"],"maxItems":20,"includeDetails":false}'
```

### Data quality tips

Use specific keywords for cleaner results, for example `iphone 15 pro` instead of `iphone`. Public Marktplaats search URLs are useful when you have already selected filters in the website UI.

If you need more complete text descriptions, enable `includeDetails`. If you only need a fast search-result export, keep `includeDetails` disabled.

### Proxy guidance

Small local checks often work without proxy. For larger recurring exports, enable Apify Proxy to reduce blocked pages.

If Marktplaats returns a blocked page, lower concurrency by running smaller batches and retry with proxy enabled.

### MCP

You can use this Actor from Apify integrations and MCP-compatible workflows by providing the same input JSON. This is useful when an agent needs current public Marktplaats listings before drafting a report, comparing prices, or updating a spreadsheet.

Install the Apify MCP server in Claude Desktop or Claude Code with a command like:

```bash
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors fetch_cat/marktplaats-listings-scraper
```

Example MCP server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--actors",
        "fetch_cat/marktplaats-listings-scraper"
      ],
      "env": {
        "APIFY_TOKEN": "your-apify-token"
      }
    }
  }
}
```

Example prompts:

- "Find 20 public Marktplaats listings for iphone 15 and summarize the price range."
- "Run the Marktplaats scraper for bakfiets with maxItems 50 and return the dataset URL."
- "Compare current Marktplaats listings for macbook and racefiets in two separate runs."

Recommended MCP-style inputs are small and specific, for example one query and a `maxItems` limit of 20-100 depending on the workflow.

### Legality

This Actor is designed for public Marktplaats.nl pages. It does not log in, bypass paywalls, or collect private account data.

You are responsible for using the output in compliance with applicable laws, Marktplaats terms, and data protection requirements. Avoid collecting personal data unless you have a lawful basis and a clear business need.

### Pricing and cost expectations

This Actor uses pay-per-event pricing: a small start event plus one result event for each listing saved. Set `maxItems` to control cost.

Runs with `includeDetails` enabled can take longer because they may request each listing page. For cost-controlled testing, start with a small `maxItems` value.

### Related actors

For broader marketplace monitoring, combine this Actor with other ecommerce, classifieds, or product price scraping actors in your Apify workflows.

You can chain datasets into spreadsheet exports, database syncs, webhooks, or monitoring tasks.

### FAQ

**Can I combine keywords and URLs?**

Yes. The Actor accepts both `queries` and `startUrls`.

**Does it scrape private data?**

No. It only accesses public Marktplaats pages.

**Why did I get zero results?**

The query may have no listings, or Marktplaats may have returned a blocked/changed page. Try a public search URL and enable proxy for higher-volume runs.

**Should I enable detail pages?**

Enable `includeDetails` when descriptions are important. Leave it disabled when you need a faster listing overview.

**How do I control spend?**

Use `maxItems` and test with a small input first.

# Actor input Schema

## `queries` (type: `array`):

Marktplaats search keywords, for example iphone, bakfiets, or vintage lamp.

## `startUrls` (type: `array`):

Public Marktplaats search URLs to scrape. You can combine URLs and keywords.

## `maxItems` (type: `integer`):

Maximum number of listing records to save.

## `includeDetails` (type: `boolean`):

Fetch each public listing detail page to add its meta description. Slower but useful for richer exports.

## `proxy` (type: `object`):

Optional Apify Proxy settings for higher-volume runs.

## Actor input object example

```json
{
  "queries": [
    "iphone"
  ],
  "startUrls": [
    {
      "url": "https://www.marktplaats.nl/q/iphone/"
    }
  ],
  "maxItems": 20,
  "includeDetails": false,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "iphone"
    ],
    "startUrls": [
        {
            "url": "https://www.marktplaats.nl/q/iphone/"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/marktplaats-listings-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 = {
    "queries": ["iphone"],
    "startUrls": [{ "url": "https://www.marktplaats.nl/q/iphone/" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/marktplaats-listings-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 '{
  "queries": [
    "iphone"
  ],
  "startUrls": [
    {
      "url": "https://www.marktplaats.nl/q/iphone/"
    }
  ],
  "maxItems": 20
}' |
apify call fetch_cat/marktplaats-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/Zcktz7ZVM6YFfo1Dr/builds/6X0aGalTbHONKGFOP/openapi.json