# Coches.net Scraper - Spanish Used Car Listings & Prices (`s-r/coches-net-scraper`) Actor

Scrape coches.net used, km 0 and new car listings in Spain: cash and financed prices, year, mileage, fuel, horsepower, DGT label, province, dealer or private seller, warranty and photos. Search by URL or by make, model, province and filters.

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

## Pricing

from $2.00 / 1,000 listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Coches.net Scraper

The Coches.net scraper collects Spanish car listings from coches.net for dealers, importers and pricing analysts. Search used (segunda mano), km 0 or new cars by make and model, Spanish province, price, year, mileage and fuel, or paste a coches.net search URL. Each dataset row is one car advertisement with the cash price, the financed price when the dealer offers one, vehicle specifications, the DGT environmental label, seller details, warranty and original photos.

### What the Coches.net scraper delivers

Use this actor to compare asking prices across provinces, build a shortlist of vehicles for import, review dealer inventory, or collect a dated snapshot for market research. The cash price and dealer-financed price are separate fields so you can compare the same type of offer. Price reductions, the source's market average and its price rating add context where the listing provides them. These are asking prices and source estimates; they do not represent completed sales or guaranteed valuations.

The actor supports cars in the used, km 0 and new sections. It reads listing information. Detailed equipment lists, vehicle descriptions, transmission filters, motorcycles, vans and motorhomes are outside the current scope. A car listed by a dealer and a private seller can have different optional fields. The output preserves those differences with null values instead of filling missing information with estimates.

### Use cases

- **Dealer stock and pricing.** Track how competing dealers in your province price the same make, model and year, and spot reductions through `previous_price` and `price_drop_percent`.
- **Import sourcing.** Filter by year, mileage, fuel and DGT label, sort by price, and export a shortlist with the dealer name, rating and warranty months for each car.
- **Market research on Spanish used car prices.** Run the same search on a schedule and compare snapshots by `listing_id` and `fetched_at` to follow asking prices, stock levels and time on the market.
- **Finance offers.** Compare `price` with `financed_price` and the stated instalment, term and APR to see how dealers use financing to lower the advertised price.
- **Electrified fleet monitoring.** Select the CERO or ECO label to watch supply and prices of electric and hybrid cars per province.

### Coches.net scraper input

Start with a make and a result limit. `make` accepts a name or slug, such as Toyota or Mercedes-Benz. `model` requires `make`. The actor checks that coches.net applied your selection and rejects an unknown make or model. This helps prevent a misspelt model from silently returning every car from the make.

For a more focused search, add `provinces`, an array of Spanish province names or slugs. For example, Madrid and A Coruña are recognised. Set `price_min` and `price_max` for cash prices in EUR, `year_min` and `year_max` for registration year, or `km_min` and `km_max` for mileage in kilometres. A minimum must not exceed its maximum. `power_min_hp` and `power_max_hp` select engine power in horsepower.

`fuel_types` accepts diesel, petrol, electric, hybrid, plug_in_hybrid, lpg, cng and other. `environmental_labels` accepts zero, eco, c and b; zero corresponds to the DGT CERO label. Multiple values match any selected value. `seller_type` accepts all, professional or private. `with_warranty` requires listings that indicate a warranty, and `keywords` adds free-text search terms.

Choose `offer_type` used, km0 or new. The default is used. `sort` supports relevance, price_asc, price_desc, year_asc, year_desc, km_asc and km_desc. Relevance can show promoted top advertisements; an explicit price, year or mileage order follows the source's chosen order. `include_top_ads`, enabled by default, controls whether promoted listings are included.

A supplied `url` takes priority over the other search fields. The result limit, top-ad setting and continuation cursor still apply. Supply a coches.net results URL, including its filters. Search URLs using `/search/` are accepted and converted to an equivalent results search. Detail URLs for a single advertisement are rejected. The actor starts at page one and manages pagination itself.

`max_items` defaults to 100 and accepts up to 10,000 unique car listings. It is a maximum rather than a promise: a narrow search may have fewer results. Promoted advertisements are deduplicated by their listing identifier along with ordinary advertisements. `cursor` resumes a search from the `next_cursor` of an earlier run.

#### Example input

This search for a Volkswagen Golf in Madrid, registered in 2018 or later with at most 100,000 km, cheapest first, returned 413 matching cars on coches.net:

```json
{
  "make": "Volkswagen",
  "model": "Golf",
  "provinces": ["Madrid"],
  "year_min": 2018,
  "km_max": 100000,
  "sort": "price_asc",
  "max_items": 30
}
```

### Coches.net scraper output

The dataset contains one row per unique listing. Core fields are `listing_id`, `url`, `title`, `price`, `currency`, `brand`, `condition`, `country`, `image_url`, `position`, `source` and `fetched_at`. Currency is EUR and the market is ES. The condition label is preserved as displayed by the source in Spanish; `offer_type` provides a separate normalised value.

Vehicle fields include make and model names and identifiers, year, mileage in kilometres, fuel label and identifier, horsepower, DGT environmental label and body-type identifier. Mileage can be null for new cars. A fuel value or horsepower may be absent from an individual advertisement; the actor keeps that field null.

Commercial fields include financed price, stated financing provider and terms, previous price, price reduction, market average, seller type, dealer name, dealer rating and review count, warranty flag and warranty months. Financing conditions belong to the particular advertisement and should be confirmed with its seller. Seller phone numbers are delivered only for professional dealers. Private sellers always have a null phone field, including listings where a contact number is present in the source data.

The row also contains province, city and region where supplied, original gallery images, image count, publication and creation timestamps, certification and reservation flags, and the source page. `fetched_at` is a UTC retrieval timestamp. Keep it with the listing identifier when comparing successive snapshots because asking prices, photos and availability can change.

#### Example output

One row from the Golf search above, delivered on 5 October 2026. The gallery is shortened to two of its 19 images and the dealer phone field is left out here; everything else is as delivered:

```json
{
  "source": "coches-net-scraper",
  "fetched_at": "2026-10-05T21:21:38.197Z",
  "listing_id": "71634461",
  "url": "https://www.coches.net/volkswagen-golf-business-10-tsi-81kw-110cv-5p-gasolina-2018-en-madrid-71634461-covo.aspx",
  "title": "VOLKSWAGEN Golf Business 1.0 TSI",
  "brand": "VOLKSWAGEN",
  "condition": "Ocasión",
  "currency": "EUR",
  "country": "ES",
  "make": "VOLKSWAGEN",
  "make_id": 47,
  "model": "Golf",
  "model_id": 89,
  "price": 13790,
  "financed_price": 11990,
  "includes_taxes": true,
  "financing": {
    "lender": "lendrock",
    "monthly_instalment": 143.32,
    "terms_months": 120,
    "apr": 7.9348,
    "down_payment": 0
  },
  "previous_price": null,
  "price_drop_percent": null,
  "price_rating": "fair",
  "market_average_price": 13600,
  "year": 2018,
  "mileage_km": 90262,
  "fuel_type": "Gasolina",
  "fuel_type_id": 2,
  "power_hp": 110,
  "environmental_label": "c",
  "body_type_id": 1,
  "offer_type": "used",
  "province": "Madrid",
  "province_id": 28,
  "city": "Leganés",
  "region": "Madrid",
  "seller_type": "professional",
  "seller_name": "Muy Car Madrid - Leganés",
  "seller_id": "133987",
  "seller_rating": 4.6,
  "seller_review_count": 49,
  "has_warranty": true,
  "warranty_months": 12,
  "is_certified": false,
  "has_reservation": true,
  "is_top_ad": false,
  "is_urgent": false,
  "image_url": "https://a.ccdn.es/cnet/vehicles/20877445/95276bd3-0554-43ce-9367-26fc40117b61.jpg",
  "images": [
    "https://a.ccdn.es/cnet/vehicles/20877445/95276bd3-0554-43ce-9367-26fc40117b61.jpg",
    "https://a.ccdn.es/cnet/vehicles/20877445/4643805f-5f0b-4f42-bb12-aea13c2bcb98.jpg"
  ],
  "image_count": 19,
  "published_at": "2026-09-30T14:01:29.000Z",
  "created_at": "2026-09-30T14:01:29.000Z",
  "page": 1,
  "position": 4
}
```

The run's OUTPUT record includes `total_results`, `pages_fetched`, `partial`, `warnings`, `search` and `next_cursor`. The source's total counts ordinary results; promoted rows can make delivered counts differ. The summary record reports delivered listings, pages fetched and the free-plan allowance remaining. The actor automatically follows continuation cursors while its run budget allows. If a page remains unavailable, it retains the listings already collected and reports the unfinished search. Use the returned cursor with the same search to resume.

### How to scrape coches.net

1. Open the actor and enter a make, for example Toyota, or paste a coches.net results URL.
2. Add a model, provinces and the price, year, mileage, fuel or DGT label filters you need.
3. Set `max_items` to the number of cars you want and start the run.
4. Download the dataset as JSON, CSV or Excel, or read it through the Apify API and integrations.
5. Schedule the same input daily or weekly to build a price history.

### How it compares to other ways to get coches.net data

**Browsing coches.net by hand** works for a handful of cars but does not give you a spreadsheet of hundreds of listings with consistent fields, dates and positions.

**Writing your own coches.net scraper** means maintaining page parsing, pagination, deduplication of promoted ads and retries yourself, and keeping up with changes to the site. This actor delivers a stable, documented row instead.

**The coches.net developer zone** offers search boxes to embed on your own website. Those widgets send visitors to coches.net; they do not hand you listing data to analyse.

**Other coches.net scrapers in the Apify Store** differ in fields and pricing, so compare the output before you choose. This actor keeps the dealer-financed price separate from the cash price, includes the stated financing terms, the DGT environmental label, dealer rating and warranty months, checks that a requested make and model were actually applied instead of silently widening the search, and never returns private sellers' phone numbers.

### Pricing

The intended pricing is $0.002 per delivered listing plus a $0.0005 run-start event. Check the actor's current Store pricing before running; the Store price controls the actual charge. Listing events are charged only for rows delivered to the dataset. Repeated advertisements are not charged twice within a run. A search with no matching cars produces no listing charge and retains only the run-start event.

Users without a paid Apify plan receive at most ten listings per run. The actor applies that limit before collecting additional pages and reports the allowance in the run output. Paid users can request the full supported limit. Apify's own platform usage is separate from the listing event price.

### FAQ

#### Can I collect both used and new cars?

Yes. Choose used, km0 or new with `offer_type`. Run separate searches when comparing those groups because their mileage and pricing conventions differ.

#### Why is a financed price lower than the cash price?

A dealer may advertise a different purchase price when financing is arranged through its lender. Compare `price` with `financed_price` and review the stated financing conditions. The actor does not calculate a total borrowing cost.

#### Can I export results to a spreadsheet?

Yes. Apify datasets support formats including JSON, CSV and Excel. Use scalar fields for a flat spreadsheet; gallery images and financing conditions are nested fields that are easiest to preserve in JSON.

#### Does the actor collect private phone numbers?

No. It returns business phone numbers for professional dealers where supplied. Phone fields for private sellers are always null.

#### What happens if the requested model does not exist?

The actor returns an invalid-input message. It does not deliver a broader make search as though it matched your model. Correct the model name and start a new search.

#### Can I paste a coches.net URL instead of filling in the fields?

Yes. Copy the address of a coches.net results page with your filters applied and put it in `url`. It takes priority over the other search fields; `max_items`, `include_top_ads` and `cursor` still apply. A link to a single car advertisement is rejected.

#### How many cars can one run return?

Up to 10,000 unique listings per run, limited by how many cars match your search. For larger collections, split the search by province, year or fuel type, or continue with the returned `next_cursor`.

#### Is there a coches.net API for market data?

The developer zone of coches.net offers embeddable search widgets rather than a data feed of listings. This actor works as a coches.net API for that purpose: start it with a JSON input through the Apify API and receive structured JSON rows back.

# Actor input Schema

## `url` (type: `string`):

A coches.net search URL. Overrides other search fields; max_items, include_top_ads and cursor still apply.

## `make` (type: `string`):

Make name or slug, for example Toyota or Mercedes-Benz.

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

Model name or slug. Requires make. Unknown makes or models are rejected.

## `offer_type` (type: `string`):

Used, km 0 or new cars.

## `provinces` (type: `array`):

Spanish province names or slugs, for example Madrid or A Coruña.

## `fuel_types` (type: `array`):

Fuel types; multiple values match any selected fuel.

## `environmental_labels` (type: `array`):

DGT environmental labels. zero means CERO.

## `seller_type` (type: `string`):

Filter dealer or private listings.

## `with_warranty` (type: `boolean`):

Require a warranty.

## `keywords` (type: `string`):

Free-text search words.

## `sort` (type: `string`):

Result order. relevance can include promoted top ads.

## `max_items` (type: `integer`):

Maximum unique listings across all continuation requests.

## `include_top_ads` (type: `boolean`):

Include promoted listings, deduplicated by listing_id.

## `cursor` (type: `string`):

Opaque next_cursor from a previous response; repeat the same search input.

## `price_min` (type: `integer`):

Minimum cash price in eur.

## `price_max` (type: `integer`):

Maximum cash price in eur.

## `year_min` (type: `integer`):

Minimum registration year.

## `year_max` (type: `integer`):

Maximum registration year.

## `km_min` (type: `integer`):

Minimum mileage in kilometres.

## `km_max` (type: `integer`):

Maximum mileage in kilometres.

## `power_min_hp` (type: `integer`):

Minimum engine power in horsepower.

## `power_max_hp` (type: `integer`):

Maximum engine power in horsepower.

## Actor input object example

```json
{
  "make": "Toyota",
  "offer_type": "used",
  "seller_type": "all",
  "with_warranty": false,
  "sort": "relevance",
  "max_items": 100,
  "include_top_ads": true
}
```

# Actor output Schema

## `results` (type: `string`):

One row per unique car listing.

## `output` (type: `string`):

Delivery counts and charge events.

## `summary` (type: `string`):

Listings, pages fetched and free_tier_remaining.

# 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 = {
    "make": "Toyota"
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/coches-net-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 = { "make": "Toyota" }

# Run the Actor and wait for it to finish
run = client.actor("s-r/coches-net-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "make": "Toyota"
}' |
apify call s-r/coches-net-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/coches-net-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/7wU4WuB8rdfeI9m9m/builds/fncgLfed5njSUX47s/openapi.json