# Wallapop Scraper 🇪🇸 (listings, prices, seller info) (`tagadanar/wallapop-scraper`) Actor

Scrape Wallapop.com search results into flat JSON: title, price, location and photos, plus demand signals like view and favorite counts. Filter by keyword, category, price band and distance. No API key, one flat price per listing with platform usage included.

- **URL**: https://apify.com/tagadanar/wallapop-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 1,000 listing 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.

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 Scraper 🇪🇸

Pull live listings from Wallapop, Spain's biggest second-hand marketplace app, as clean structured data. Search by keyword or browse a category, filter by price and location, and get back one flat JSON record per listing with the price, the photos, the location and how many people have viewed or favorited it. No account, no API key, one price per listing with platform usage included.

Wallapop covers everything Spaniards buy and sell second-hand: phones, computers, furniture, clothing, cars, motorbikes, tools, collectibles. If you are reselling, tracking prices, building a lead list or sizing demand for a category, this turns the whole marketplace into a spreadsheet.

### What you get

Each listing is one row:

| Field | What it is |
| --- | --- |
| `id` | Wallapop listing id |
| `title` | Listing title |
| `description` | Full listing text |
| `url` | Direct link to the listing |
| `price` | Price as a number |
| `currency` | Usually `EUR` |
| `categoryId` / `category` | Wallapop category, e.g. `Tecnología y electrónica` |
| `city` / `postalCode` / `region` / `countryCode` | Where the item is listed |
| `latitude` / `longitude` | Listing coordinates |
| `imageUrl` / `imageCount` | First photo and how many the listing has |
| `images` | Every photo, with "Include listing details" on |
| `sellerId` | Seller identifier |
| `sellerName` | Seller display name, with "Include seller info" on |
| `shippable` | Whether the seller ships |
| `reserved` | Whether the item is marked as reserved |
| `views` / `favorites` | Demand signals, with "Include listing details" on |
| `attributes` | Structured specs (brand, model, condition, and similar), with "Include listing details" on |
| `createdAt` / `modifiedAt` | When the listing was posted and last touched (ISO 8601) |
| `searchQuery` | The search term this row came from |
| `source` / `scrapedAt` | `wallapop` and the capture time |

### Who uses it

- **Resellers and flippers** watching what a phone, a console or a bike actually sells for, and spotting under-priced listings early. The `views` and `favorites` counts show which listings are getting attention before they sell.
- **Price-monitoring tools** that run a saved search on a schedule and feed fresh listings into a repricing model.
- **Market researchers** pulling every listing in a category for a demand or price snapshot across a city or region.
- **Lead-gen teams** building a list of active sellers in a category with a name and location attached.

### How to use it

Type a search the way you would on Wallapop, or pick a category to browse without a keyword. Set how many listings you want, and turn on the two enrichment switches if you need view/favorite counts or the seller's name.

**Cheapest iPhones near Madrid, newest first**

```json
{
  "query": ["iphone 13"],
  "priceTo": 400,
  "orderBy": "newest",
  "maxResults": 100
}
````

**Full detail on a category, with demand signals**

```json
{
  "categoryId": 24200,
  "maxResults": 200,
  "includeDetails": true
}
```

**Two searches, with seller names**

```json
{
  "query": ["bicicleta electrica", "patinete electrico"],
  "maxResults": 100,
  "includeSeller": true
}
```

**Search a different city**

```json
{
  "query": ["moto scooter"],
  "latitude": 41.3874,
  "longitude": 2.1686,
  "orderBy": "closest",
  "maxResults": 60
}
```

Wallapop ranks and filters results by distance from a point even for a keyword search, so setting "Latitude"/"Longitude" to the city you care about (Barcelona in the example above) matters, not just the "Closest" sort.

### Pricing

You pay per listing returned, platform usage included in the price. No subscription.

| Event | Price |
| --- | --- |
| Actor start | $0.001 per run |
| Listing scraped | $1.50 per 1,000 |

Turning on "Include listing details" or "Include seller info" costs nothing extra: it is the same per-listing price either way, just a fuller record.

### FAQ

**Do I need a Wallapop account or an API key?**
No. You give a search, you get listings.

**What does "Include listing details" add that the search doesn't already have?**
The search itself already returns the title, price, location, description and first photo. Turning this on adds the view count, the favorite count, every photo, and the structured specs (brand, model, color, storage, condition, and similar) where the seller filled them in.

**Can I monitor a search on a schedule?**
Yes. Sort by `newest`, set a Schedule on the actor, and each run returns the latest listings for your search.

**Why does the location I set change my results even for a plain keyword search?**
Wallapop is built around local search: the app ranks nearby listings first no matter the sort, and very distant listings can be left out entirely. Set "Latitude"/"Longitude" to the area you actually care about.

**Is it reliable?**
Yes. It reads Wallapop's own structured data rather than scraping page markup, so the fields stay stable when the app or site restyles.

### Related scrapers

Building a European classifieds pipeline? These cover the other big markets with the same flat output:

- **Subito.it Scraper** for Italy
- **Kleinanzeigen Scraper** for Germany
- **Marktplaats Scraper** for the Netherlands

***

Wallapop scraper, Wallapop.com scraper, Spain classifieds scraper, scrape Wallapop listings, Spanish marketplace data, second-hand prices Spain, resale price research, Wallapop API alternative, classifieds price monitoring, demand signals views favorites.

# Actor input Schema

## `query` (type: `array`):

One search per entry, exactly what you would type into the Wallapop search box, e.g. <code>iphone 13</code>, <code>bicicleta electrica</code>. Leave empty to browse a single category with "Category ID" instead.

## `categoryId` (type: `integer`):

Restrict the search to one Wallapop category. A few top-level ids: 100 Coches (cars), 14000 Motos, 24200 Tecnologia y electronica, 12465 Moda y accesorios, 200 Inmobiliaria, 12467 Hogar y jardin, 17000 Bicicletas, 13100 Electrodomesticos. Leave empty to search every category.

## `priceFrom` (type: `number`):

Lowest price to include, in euros.

## `priceTo` (type: `number`):

Highest price to include, in euros.

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

Wallapop ranks and filters results by distance from a point, so this matters even for a nationwide keyword search. Defaults to Madrid.

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

Paired with "Latitude". Defaults to Madrid.

## `orderBy` (type: `string`):

Order of the results, same choices as on the site.

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

Stop after this many listings across all searches. You are only charged for listings actually delivered.

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

Fetch each listing's own page for its view count, favorite count and structured specs (brand, model, condition and similar), on top of what the search already returns. One extra request per listing, same price per listing either way.

## `includeSeller` (type: `boolean`):

Fetch the seller's public profile for their display name. One extra request per listing, same price per listing either way.

## Actor input object example

```json
{
  "query": [
    "iphone"
  ],
  "latitude": 40.4168,
  "longitude": -3.7038,
  "orderBy": "relevance",
  "maxResults": 40,
  "includeDetails": false,
  "includeSeller": false
}
```

# Actor output Schema

## `listings` (type: `string`):

One item per listing in the default dataset.

# 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 = {
    "query": [
        "iphone"
    ],
    "maxResults": 40
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/wallapop-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 = {
    "query": ["iphone"],
    "maxResults": 40,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/wallapop-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 '{
  "query": [
    "iphone"
  ],
  "maxResults": 40
}' |
apify call tagadanar/wallapop-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wallapop Scraper 🇪🇸 (listings, prices, seller info)",
        "description": "Scrape Wallapop.com search results into flat JSON: title, price, location and photos, plus demand signals like view and favorite counts. Filter by keyword, category, price band and distance. No API key, one flat price per listing with platform usage included.",
        "version": "0.1",
        "x-build-id": "jwQvQRyJHjJhW0z4n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tagadanar~wallapop-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tagadanar-wallapop-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/tagadanar~wallapop-scraper/runs": {
            "post": {
                "operationId": "runs-sync-tagadanar-wallapop-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/tagadanar~wallapop-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-tagadanar-wallapop-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": {
                    "query": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "One search per entry, exactly what you would type into the Wallapop search box, e.g. <code>iphone 13</code>, <code>bicicleta electrica</code>. Leave empty to browse a single category with \"Category ID\" instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "type": "integer",
                        "description": "Restrict the search to one Wallapop category. A few top-level ids: 100 Coches (cars), 14000 Motos, 24200 Tecnologia y electronica, 12465 Moda y accesorios, 200 Inmobiliaria, 12467 Hogar y jardin, 17000 Bicicletas, 13100 Electrodomesticos. Leave empty to search every category."
                    },
                    "priceFrom": {
                        "title": "Price from (EUR)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Lowest price to include, in euros."
                    },
                    "priceTo": {
                        "title": "Price up to (EUR)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Highest price to include, in euros."
                    },
                    "latitude": {
                        "title": "Latitude",
                        "type": "number",
                        "description": "Wallapop ranks and filters results by distance from a point, so this matters even for a nationwide keyword search. Defaults to Madrid.",
                        "default": 40.4168
                    },
                    "longitude": {
                        "title": "Longitude",
                        "type": "number",
                        "description": "Paired with \"Latitude\". Defaults to Madrid.",
                        "default": -3.7038
                    },
                    "orderBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "newest",
                            "price_low_to_high",
                            "price_high_to_low",
                            "closest"
                        ],
                        "type": "string",
                        "description": "Order of the results, same choices as on the site.",
                        "default": "relevance"
                    },
                    "maxResults": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Stop after this many listings across all searches. You are only charged for listings actually delivered.",
                        "default": 40
                    },
                    "includeDetails": {
                        "title": "Include listing details",
                        "type": "boolean",
                        "description": "Fetch each listing's own page for its view count, favorite count and structured specs (brand, model, condition and similar), on top of what the search already returns. One extra request per listing, same price per listing either way.",
                        "default": false
                    },
                    "includeSeller": {
                        "title": "Include seller info",
                        "type": "boolean",
                        "description": "Fetch the seller's public profile for their display name. One extra request per listing, same price per listing either way.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```