# Wallapop Spain Marketplace Listings Scraper (`automation-lab/wallapop-marketplace-scraper`) Actor

Extract public Wallapop Spain listings by keyword, location, price, category, condition, date, or search URL. Export typed prices, photos, seller IDs, shipping flags, and optional detail metrics—no login required.

- **URL**: https://apify.com/automation-lab/wallapop-marketplace-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Wallapop Spain Marketplace Listings Scraper

Extract **public Wallapop Spain listings** by keyword, location, category, price, condition, publication date, or a saved search URL.
Get clean prices, photos, taxonomy, approximate location, seller identifiers, shipping signals, and optional engagement metrics without a login or API key.

This Wallapop scraper uses the marketplace's public JSON data route instead of loading heavy browser pages.
That makes scheduled resale sourcing and market monitoring fast, predictable, and easy to export.

- 🔎 Search one or many product keywords
- 📍 Target coordinates anywhere in Spain
- 💶 Apply price, category, condition, and date filters
- 🔗 Reuse a Wallapop search URL
- 📊 Export JSON, CSV, Excel, XML, or RSS from Apify
- ⏰ Schedule recurring runs and receive dataset webhooks

### What does Wallapop Marketplace Scraper do?

Wallapop Marketplace Scraper turns public classifieds from [Wallapop Spain](https://wallapop.com/) into one structured dataset row per listing.
It follows Wallapop's opaque pagination cursor, removes duplicate listing IDs across searches, and stops exactly at your requested limit.

Use the lightweight default mode for high-frequency inventory monitoring.
Enable detail enrichment only when you need condition, brand, model, characteristics, views, favorites, conversations, or hashtags.

Unlike browser-heavy approaches, this actor calls the first-party public JSON endpoints directly.
No login, cookie export, or private API credential is required for the supported Spain workflow.

### Who is it for? Wallapop scraper personas

**Resale sellers and sourcing teams**

- Discover newly listed phones, bikes, furniture, collectibles, or tools.
- Compare asking prices before buying inventory.
- Schedule a newest-first search and alert on attractive listings.

**Marketplace analysts**

- Track supply and asking-price ranges by product category.
- Compare regional inventory around Madrid, Barcelona, Valencia, or another coordinate.
- Export stable listing IDs for longitudinal analysis.

**Price comparison and aggregation products**

- Feed normalized listing records into a catalog or search index.
- Deduplicate results from overlapping keywords and saved searches.
- Enrich selected listings with public engagement counters.

**Data and automation engineers**

- Trigger searches through the Apify API.
- Connect datasets to Google Sheets, BigQuery, Make, Zapier, or a webhook.
- Build repeatable Wallapop inventory monitors without maintaining scraping infrastructure.

### Why use this Wallapop listings extractor?

- ⚡ **HTTP-only extraction** avoids browser rendering overhead.
- 🇪🇸 **Clear Spain scope** avoids unsupported claims about unverified country adapters.
- 🧭 **Two input routes** support structured filters and existing Wallapop search URLs.
- 🧹 **Exact ID deduplication** prevents repeated rows from overlapping searches.
- 🛡️ **Fail-closed filters** exclude records when price, category, date, or condition cannot be verified.
- 📦 **Typed output** keeps prices numeric, flags boolean, and timestamps export-friendly.
- 🔁 **Bounded retries** handle temporary rate limits and server errors.
- 💳 **Pay per event** means you pay for the run start and listings saved, not a monthly rental.
- 🔌 **Apify integrations** provide schedules, API access, webhooks, storage, and exports.

### What Wallapop data can you extract?

| Data group | Fields |
|---|---|
| Identity | Listing ID, canonical URL, title, description |
| Price | Numeric amount and currency |
| Classification | Category ID, category name, flattened taxonomy path |
| Freshness | Created, modified, and scraped timestamps |
| Photos | Primary image URL and all public image URLs |
| Location | Approximate city, region, postcode, country, latitude, longitude |
| Seller | Public seller ID and top-profile flag where returned |
| Fulfilment | Shippable and seller-allows-shipping flags |
| Listing state | Reserved, refurbished, and warranty flags |
| Enriched attributes | Condition, brand, model, characteristics |
| Engagement | Views, favorites, conversations, hashtags |
| Provenance | Source search URL used to discover the listing |

Wallapop deliberately returns approximate public location data.
Do not treat listing coordinates as a seller's exact address.
Some optional detail fields vary by category and may be absent when Wallapop does not publish them.

### How much does it cost to scrape Wallapop listings?

This actor uses **pay-per-event pricing**.
The package charges **$0.005 per run start** plus a formula-derived tiered price per saved listing.
Prices were validated from a representative paginated cloud run with a 92.8% net margin.

| Apify plan tier | Price per listing |
|---|---:|
| Free | $0.000040449 |
| Starter / Bronze | $0.000035173 |
| Scale / Silver | $0.000027435 |
| Business / Gold | $0.000021104 |
| Platinum | $0.000014069 |
| Diamond | $0.000010000 |

At the Free-tier rate, 100 saved listings cost about **$0.009**, including the start charge.
One thousand saved listings cost about **$0.045**.
Apify's Free plan includes monthly platform credits that can cover small evaluation runs.

Detail enrichment does not create a separate event charge, but it adds requests and runtime.
Leave it disabled for inexpensive high-frequency monitoring unless you need the extra fields.

### How to scrape Wallapop Spain listings

1. Open [Wallapop Marketplace Scraper](https://apify.com/automation-lab/wallapop-marketplace-scraper).
2. Enter one or more product keywords, such as `iphone`, `bicicleta`, or `mesa vintage`.
3. Set latitude and longitude for the Spanish market area you want to search.
4. Add optional radius, category, price, condition, date, or sort filters.
5. Choose whether to enrich every listing with detailed attributes and counters.
6. Set a small `maxItems` limit for your first run.
7. Click **Start** and review the default dataset.
8. Export the results or schedule the task for recurring monitoring.

**Minimal Madrid search**

```json
{
  "keywords": ["iphone"],
  "latitude": 40.4168,
  "longitude": -3.7038,
  "maxItems": 20,
  "includeDetails": false
}
````

**Newest like-new phones with details**

```json
{
  "keywords": ["smartphone"],
  "categoryIds": [24200],
  "conditions": ["as_good_as_new"],
  "maxPrice": 600,
  "sortBy": "newest",
  "includeDetails": true,
  "maxItems": 100
}
```

**Saved Wallapop search URL**

```json
{
  "keywords": [],
  "startUrls": [
    { "url": "https://wallapop.com/search?keywords=bicicleta&latitude=41.3874&longitude=2.1686" }
  ],
  "maxItems": 100
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `keywords` | string\[] | `["iphone"]` | Separate Wallapop product searches |
| `startUrls` | request\[] | `[]` | Wallapop Spain search or discover-content URLs |
| `latitude` | number | `40.4168` | Search center latitude |
| `longitude` | number | `-3.7038` | Search center longitude |
| `distanceKm` | integer | source default | Optional radius from 1 to 500 km |
| `categoryIds` | integer\[] | `[]` | Wallapop taxonomy IDs to request and verify |
| `minPrice` | number | source minimum | Minimum listing price in EUR |
| `maxPrice` | number | no ceiling | Maximum listing price in EUR |
| `conditions` | string\[] | `[]` | Verified Wallapop condition codes |
| `publishedAfter` | string | empty | ISO date or date-time lower boundary |
| `sortBy` | string | `most_relevance` | Relevance, newest, price, or distance order |
| `includeDetails` | boolean | `false` | Fetch attributes and engagement counters |
| `maxItems` | integer | `20` | Maximum unique listings to save |
| `extraSearchParams` | object | `{}` | Advanced verified API query parameters |

Provide at least one non-empty keyword or search URL.
When both are present, the actor processes both routes and deduplicates the combined output.

### Wallapop condition codes

Use these source condition values in `conditions`:

- `un_opened`
- `new`
- `as_good_as_new`
- `good`
- `fair`
- `has_given_it_all`

Condition filtering automatically fetches each candidate's detail record.
If a condition cannot be read, the listing is excluded rather than accidentally passing the filter.
That behavior is useful for strict sourcing pipelines, but it can reduce output for categories that do not expose condition.

### Output example

```json
{
  "id": "w67v5qrgw56x",
  "url": "https://wallapop.com/item/iphone-16-negro-1281791152",
  "title": "iPhone 16 Negro",
  "description": "Teléfono móvil iPhone 16 en color negro",
  "price": 480,
  "currency": "EUR",
  "categoryId": 24200,
  "categoryName": "Technology & electronics",
  "taxonomy": "Technology & electronics > Phones: mobiles & smartwatches > Smartphones",
  "imageUrl": "https://cdn.wallapop.com/images/example.jpg?pictureSize=W800",
  "imageUrls": ["https://cdn.wallapop.com/images/example.jpg?pictureSize=W800"],
  "city": "Madrid",
  "region": "Comunidad de Madrid",
  "countryCode": "ES",
  "sellerId": "p61o1y1nkdj5",
  "reserved": false,
  "refurbished": false,
  "hasWarranty": false,
  "shippable": true,
  "sellerAllowsShipping": false,
  "condition": "as_good_as_new",
  "brand": "Apple",
  "model": "iPhone 16",
  "views": 501,
  "favorites": 14,
  "sourceUrl": "https://api.wallapop.com/api/v3/search?keywords=iphone",
  "scrapedAt": "2026-07-16T03:00:00.000Z"
}
```

Fields that Wallapop omits are left out rather than filled with misleading placeholders.
The overview table highlights the most useful sourcing columns; API exports retain the complete row.

### Tips for better Wallapop results

- 🎯 Start with one precise keyword and 20 listings before scaling up.
- 📍 Use coordinates near the market you actually source from.
- 🗂️ Add a category ID when a keyword is ambiguous.
- 💶 Set a realistic price range to reduce irrelevant inventory.
- 🆕 Use `newest` sorting for scheduled listing alerts.
- ⚡ Keep `includeDetails` off when title, price, photos, and location are enough.
- 🔍 Enable details for condition-sensitive buying or engagement analysis.
- 🔗 Reuse a tested Wallapop search URL when the website UI already expresses your filters.
- 🧾 Store listing IDs in your downstream system to identify additions between runs.
- 🕐 Schedule at a respectful interval rather than continuously polling the source.

### Pagination, limits, and deduplication

Wallapop returns batches of listings and an opaque `next_page` cursor.
The actor follows that cursor until it reaches `maxItems`, the source has no next page, or all configured searches finish.

A listing found by two keywords is saved once per run.
The first source URL that produced the saved row is retained in `sourceUrl`.
The actor does not claim exhaustive historical coverage because Wallapop controls ranking and availability.

A total extraction failure causes the run to fail instead of silently producing a successful empty dataset.
A valid search with filters that match nothing also fails with guidance to review the input.

### Integrations and monitoring workflows

**Wallapop → Google Sheets**

Schedule a newest-first search and append prices, locations, URLs, and timestamps to a sourcing sheet.
Use the listing ID as the stable deduplication key.

**Wallapop → Slack or Discord**

Send a webhook when a new listing falls below a target price.
Include the canonical listing URL and primary image for quick review.

**Wallapop → Make or Zapier**

Trigger the actor from a scenario, filter dataset items, and create CRM records or notifications.
Use separate tasks for different cities or product categories.

**Wallapop → database or warehouse**

Load JSON exports into PostgreSQL, BigQuery, Snowflake, or a data lake.
Compare snapshots to measure inventory and price movement.

**Scheduled market monitor**

Run every hour or day, retain the previous listing IDs, and alert only on unseen records.
This actor provides extraction; your automation decides whether a record is new to your history.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/wallapop-marketplace-scraper').call({
  keywords: ['bicicleta gravel'],
  latitude: 41.3874,
  longitude: 2.1686,
  sortBy: 'newest',
  maxItems: 100,
});

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

### Using the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/wallapop-marketplace-scraper").call(run_input={
    "keywords": ["camara analogica"],
    "latitude": 40.4168,
    "longitude": -3.7038,
    "maxItems": 50,
    "includeDetails": True,
})

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

### Using the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~wallapop-marketplace-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["mesa vintage"],
    "latitude": 39.4699,
    "longitude": -0.3763,
    "maxItems": 50
  }'
```

After the run finishes, fetch items from its `defaultDatasetId` or use the synchronous dataset endpoint for small jobs.
Keep API tokens in environment variables or a secret manager.

### Use with AI agents via MCP

Wallapop Marketplace Scraper can be called by AI clients through Apify's hosted [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp) server.

**Claude Code**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/wallapop-marketplace-scraper"
```

**Claude Desktop, Cursor, or VS Code**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/wallapop-marketplace-scraper"
    }
  }
}
```

Your client uses OAuth to authenticate with Apify on first use.

Example prompts:

- "Use `automation-lab/wallapop-marketplace-scraper` to find the newest iPhone listings within 50 km of Madrid under €500."
- "Extract 100 gravel bicycle listings around Barcelona and compare median asking price by brand."
- "Monitor my Wallapop Spain search URL and summarize newly discovered listings with warranty and shipping."

### Legality: is it legal to scrape Wallapop?

This actor extracts data visible through Wallapop's public anonymous listing interfaces.
It does not log in, bypass access controls, or retrieve private messages or precise seller addresses.

Scraping public data is generally permitted in many jurisdictions, but your use must comply with applicable law, Wallapop's terms, intellectual-property rights, and privacy rules such as GDPR.
Collect only the data you need, use respectful schedules, and avoid contacting sellers in abusive or automated ways.
If your use case involves personal-data profiling or commercial outreach, obtain appropriate legal advice and establish a lawful basis.

### Limitations

- Version 1 supports **Wallapop Spain only**.
- Italy and Portugal are not silently treated as equivalent sources.
- Wallapop controls ranking, inventory availability, and API response fields.
- Approximate coordinates are not exact seller locations.
- Some categories do not publish condition, brand, model, or engagement counters.
- Detail enrichment increases runtime because it adds one public request per candidate.
- Search URLs must point to Wallapop search or discover-content pages, not arbitrary item pages.
- The actor retries temporary 403, 408, 429, and server errors, but sustained source blocking can still fail a run.
- Historical completeness is not guaranteed; this is a current-listing search tool.

### Troubleshooting

**Why did the run say no listings matched?**

The keyword may be too narrow, the radius too small, or the combined category, price, date, and condition filters may exclude every record.
Remove one filter at a time and test with a small limit.

**Why are condition or engagement fields missing?**

Enable `includeDetails`.
Even with enrichment, Wallapop may omit fields that do not apply to the category or listing.

**Why was my search URL rejected?**

Only Wallapop Spain `/search` and `/discover-content` URLs, or the verified `api.wallapop.com/api/v3/search` route, are accepted.
This prevents unrelated URLs from bypassing the actor's Spain listing scope.

**Why did the run stop after fewer listings than requested?**

The source may have exhausted matching inventory, or strict local verification may have removed records that did not satisfy your filters.
Review the log summary and loosen the most selective filter.

### FAQ

**How fast is Wallapop Marketplace Scraper?**

Search-only runs usually process a small dataset quickly because they use HTTP JSON rather than a browser.
Detail mode is slower because each listing requires one additional request.

**Do I need a Wallapop account or API key?**

No.
The supported Spain search and listing-detail records are retrieved from anonymous public endpoints.

**Can I scrape multiple keywords in one run?**

Yes.
Add several entries to `keywords`; the actor processes them sequentially and deduplicates repeated listing IDs.

**Can I use my existing Wallapop search URL?**

Yes.
Paste a Spain search or discover-content URL into `startUrls`.
The actor translates its public query parameters to the JSON search route.

**How much does a run cost?**

You pay a small run-start charge and a tiered event price for each listing saved.
The exact amount appears in the input UI and each run's billing details.

**How does this compare with a browser scraper?**

The direct JSON approach avoids downloading and rendering consumer HTML, images, scripts, and fonts.
It is typically lighter and more suitable for scheduled monitoring.

**Can the actor download listing images?**

It exports public image URLs but does not copy image binaries into storage.
A downstream workflow can download selected images if your use is authorized.

**Does it return seller contact details?**

No.
It returns only the public seller ID and profile-status signal present in listing data, not private contact details or messages.

### Other marketplace scrapers

Combine this actor with other Automation Lab marketplace and commerce tools:

- [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) for auction and fixed-price listings
- [Etsy Scraper](https://apify.com/automation-lab/etsy-scraper) for handmade marketplace research
- [Amazon Product Scraper](https://apify.com/automation-lab/amazon-product-scraper) for retail product intelligence
- [Facebook Marketplace Scraper](https://apify.com/automation-lab/facebook-marketplace-scraper) for local classified listings
- [Mercado Libre Scraper](https://apify.com/automation-lab/mercado-libre-scraper) for Latin American marketplace data
- [Google Shopping Scraper](https://apify.com/automation-lab/google-shopping-scraper) for cross-store price comparison

Check each linked actor's current Store page for supported countries, inputs, and pricing before combining workflows.

# Actor input Schema

## `keywords` (type: `array`):

Enter one or more products to find on Wallapop Spain. Each keyword starts a separate search.

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

Paste Wallapop Spain search or discover-content URLs. URL searches are combined with keyword searches.

## `latitude` (type: `number`):

Set the center latitude for structured keyword searches. The default is central Madrid.

## `longitude` (type: `number`):

Set the center longitude for structured keyword searches. The default is central Madrid.

## `distanceKm` (type: `integer`):

Limit listings to this distance from the selected coordinates. Leave empty to use Wallapop's default coverage.

## `categoryIds` (type: `array`):

Optional Wallapop taxonomy IDs. Returned listings are verified against these IDs before saving.

## `minPrice` (type: `number`):

Save only listings at or above this euro price.

## `maxPrice` (type: `number`):

Save only listings at or below this euro price. Leave empty for no ceiling.

## `conditions` (type: `array`):

Optional Wallapop condition codes. Condition filtering automatically fetches item details and fails closed when condition cannot be verified.

## `publishedAfter` (type: `string`):

Optional ISO date or date-time. Listings without a parseable publication timestamp are excluded when this filter is active.

## `sortBy` (type: `string`):

Choose how Wallapop orders each structured keyword search.

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

Fetch each listing detail to add condition, brand, model, characteristics, engagement counters, and hashtags. This makes runs slower.

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

Stop after saving this many unique matching listings across all searches.

## `extraSearchParams` (type: `object`):

Advanced: add verified Wallapop search query parameters that are not exposed above. Standard filters take precedence when keys overlap.

## Actor input object example

```json
{
  "keywords": [
    "iphone"
  ],
  "startUrls": [],
  "latitude": 40.4168,
  "longitude": -3.7038,
  "distanceKm": 20,
  "categoryIds": [],
  "maxPrice": 1000,
  "conditions": [],
  "sortBy": "most_relevance",
  "includeDetails": false,
  "maxItems": 20,
  "extraSearchParams": {}
}
```

# 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 = {
    "keywords": [
        "iphone"
    ],
    "startUrls": [],
    "latitude": 40.4168,
    "longitude": -3.7038,
    "distanceKm": 20,
    "categoryIds": [],
    "minPrice": 0,
    "maxPrice": 1000,
    "conditions": [],
    "publishedAfter": "",
    "sortBy": "most_relevance",
    "includeDetails": false,
    "maxItems": 20,
    "extraSearchParams": {}
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/wallapop-marketplace-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 = {
    "keywords": ["iphone"],
    "startUrls": [],
    "latitude": 40.4168,
    "longitude": -3.7038,
    "distanceKm": 20,
    "categoryIds": [],
    "minPrice": 0,
    "maxPrice": 1000,
    "conditions": [],
    "publishedAfter": "",
    "sortBy": "most_relevance",
    "includeDetails": False,
    "maxItems": 20,
    "extraSearchParams": {},
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/wallapop-marketplace-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 '{
  "keywords": [
    "iphone"
  ],
  "startUrls": [],
  "latitude": 40.4168,
  "longitude": -3.7038,
  "distanceKm": 20,
  "categoryIds": [],
  "minPrice": 0,
  "maxPrice": 1000,
  "conditions": [],
  "publishedAfter": "",
  "sortBy": "most_relevance",
  "includeDetails": false,
  "maxItems": 20,
  "extraSearchParams": {}
}' |
apify call automation-lab/wallapop-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wallapop Spain Marketplace Listings Scraper",
        "description": "Extract public Wallapop Spain listings by keyword, location, price, category, condition, date, or search URL. Export typed prices, photos, seller IDs, shipping flags, and optional detail metrics—no login required.",
        "version": "0.1",
        "x-build-id": "UsENQ974221gUjQu8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~wallapop-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-wallapop-marketplace-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/automation-lab~wallapop-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-wallapop-marketplace-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/automation-lab~wallapop-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-wallapop-marketplace-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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Enter one or more products to find on Wallapop Spain. Each keyword starts a separate search.",
                        "default": [
                            "iphone"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Wallapop search URLs",
                        "type": "array",
                        "description": "Paste Wallapop Spain search or discover-content URLs. URL searches are combined with keyword searches.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "latitude": {
                        "title": "Latitude",
                        "minimum": 27,
                        "maximum": 44.5,
                        "type": "number",
                        "description": "Set the center latitude for structured keyword searches. The default is central Madrid.",
                        "default": 40.4168
                    },
                    "longitude": {
                        "title": "Longitude",
                        "minimum": -19,
                        "maximum": 5,
                        "type": "number",
                        "description": "Set the center longitude for structured keyword searches. The default is central Madrid.",
                        "default": -3.7038
                    },
                    "distanceKm": {
                        "title": "Search radius (km)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Limit listings to this distance from the selected coordinates. Leave empty to use Wallapop's default coverage."
                    },
                    "categoryIds": {
                        "title": "Category IDs",
                        "type": "array",
                        "description": "Optional Wallapop taxonomy IDs. Returned listings are verified against these IDs before saving.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minPrice": {
                        "title": "Minimum price (EUR)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Save only listings at or above this euro price."
                    },
                    "maxPrice": {
                        "title": "Maximum price (EUR)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Save only listings at or below this euro price. Leave empty for no ceiling."
                    },
                    "conditions": {
                        "title": "Conditions",
                        "type": "array",
                        "description": "Optional Wallapop condition codes. Condition filtering automatically fetches item details and fails closed when condition cannot be verified.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "un_opened",
                                "new",
                                "as_good_as_new",
                                "good",
                                "fair",
                                "has_given_it_all"
                            ],
                            "enumTitles": [
                                "Unopened",
                                "New",
                                "As good as new",
                                "Good condition",
                                "Fair condition",
                                "Has given it all"
                            ]
                        }
                    },
                    "publishedAfter": {
                        "title": "Published after",
                        "type": "string",
                        "description": "Optional ISO date or date-time. Listings without a parseable publication timestamp are excluded when this filter is active."
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "most_relevance",
                            "newest",
                            "price_low_to_high",
                            "price_high_to_low",
                            "closest"
                        ],
                        "type": "string",
                        "description": "Choose how Wallapop orders each structured keyword search.",
                        "default": "most_relevance"
                    },
                    "includeDetails": {
                        "title": "Enrich listing details",
                        "type": "boolean",
                        "description": "Fetch each listing detail to add condition, brand, model, characteristics, engagement counters, and hashtags. This makes runs slower.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Stop after saving this many unique matching listings across all searches.",
                        "default": 20
                    },
                    "extraSearchParams": {
                        "title": "Extra Wallapop API parameters",
                        "type": "object",
                        "description": "Advanced: add verified Wallapop search query parameters that are not exposed above. Standard filters take precedence when keys overlap."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```