# AutoScout24 Listings — One Row per Car, $0.0006 Each (`jpmarketdata/autoscout24-listings`) Actor

Give a make (and model) and get every matching AutoScout24 car listing on the country site you pick, one row each. Returns price, make, model, registration year, mileage, fuel, transmission, seller type and URL. $0.0006 per car, no start fee; no results = no charge. Unofficial.

- **URL**: https://apify.com/jpmarketdata/autoscout24-listings.md
- **Developed by:** [h ichi](https://apify.com/jpmarketdata) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.60 / 1,000 listing returneds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## AutoScout24 Listings — One Row per Car, $0.0006 Each

**What it does:** Returns the AutoScout24 car listings that match your search on one country site, one row per car, at a flat rate per row.

**You enter:** Searches, each with a make, e.g. `{"make": "bmw", "model": "3-series"}`, and a country (default de).

**You get:** One row per car: price, make, model, variant, registration year, mileage, fuel, transmission, power (kW), dealer or private, seller country, URL; plus the site's total count and whether its 200-page ceiling was hit.

**Price:** $0.0006 per car delivered. No start fee, no monthly fee. No results = no charge.

**Example:** enter make `bmw`, model `3-series` (Germany) → 11,005 cars found · one row: BMW 318 Touring · 2011 · 118,300 km · Benzin · Automatik · €11,900 · private seller

> Unofficial — not affiliated with AutoScout24. Reads public pages only.

### Pricing — the flat rate, and no start fee

**$0.0006 per car delivered. Every plan. No start fee. No monthly rental.**

You are charged for cars that are actually in your dataset — the event fires
with the number of records pushed, never with the number you asked for and
never with the site's hit count. A search that matches nothing costs nothing.

| | per car | start fee | 100 cars | 1,000 cars | 10,000 cars |
|---|---|---|---|---|---|
| **This Actor** | **$0.0006** | **none** | **$0.06** | **$0.60** | **$6.00** |
| `blackfalcondata/autoscout24-scraper` | $0.0008 | $0.005/run | $0.085 | $0.805 | $8.005 |
| `memo23/autoscout24-scraper` | $0.0009 | $0.005/run | $0.095 | $0.905 | $9.005 |
| `ivanvs/autoscout-scraper` | $0.003 | none | $0.30 | $3.00 | $30.00 |

Because there is no start fee, **the advantage is biggest on small and
frequent runs**. A 100-car run costs 29% less than the cheapest alternative
and 41% less than the next; if you run a 100-car check hourly, that is $52.56
a year against $74.46 and $83.22. On very large single runs the start fee
stops mattering and the saving settles at 25-33% on the per-car rate alone.

### Input

```json
{
  "searches": [
    { "make": "bmw", "model": "3-series", "priceTo": 20000, "yearFrom": 2018 },
    { "make": "audi", "model": "a4", "mileageTo": 100000 }
  ],
  "maxListings": 200,
  "country": "de"
}
```

| field | meaning |
|---|---|
| `searches` | one object per search. `make` is required (AutoScout24's robots.txt disallows the make-less search). |
| `maxListings` | cars per search, 10-4000. Default 100. |
| `country` | `de`, `at`, `be`, `es`, `fr`, `it`, `lu`, `nl`. Default `de`. |

Search keys applied: **`make`, `model`, `priceFrom`, `priceTo`, `yearFrom`,
`yearTo`, `mileageTo`** (prices in EUR, years are registration years,
mileage in km). Every one of them is checked against the server's own echo of
the query before a single record is emitted — see below. Any other key is
ignored, and the run log says which ones and that the results are *not*
filtered by them.

Model slugs differ per country front-end (`3er` on `.de`, `serie-3` on `.fr`).
You do not have to know them: a wrong-but-recognisable slug such as
`3-series` is followed to the canonical one and the search runs normally.

### The 200-page ceiling — the thing every AutoScout24 scraper hits

AutoScout24's `numberOfPages` **saturates at 200**. Measured: 200 pages for a
4,981-car search, 200 for an 11,008-car search, and 200 for the 62,000-car BMW
population. At ~20 listings a page that is a hard wall at roughly **4,000
cars**, and it applies to every scraper on the platform, including this one
and including every competitor above. No amount of runtime gets past it.

So a "10,000 BMWs" claim is not a thing anyone can deliver, and a 4,000-row
dump of an 11,000-car market is 36% of that market, not the market.

Every record therefore carries:

- `totalFound` — the site's own exact hit count for your search;
- `pagesReported` — `numberOfPages` as returned;
- `pagesCeilingHit` — `true` when that number is 200, i.e. the site stopped
  enumerating and there are cars you cannot reach.

When the ceiling is hit the run log says so explicitly. **To reach the rest of
the market, split the search** with `priceFrom`/`priceTo`, `yearFrom`/`yearTo`
or `mileageTo` into slices that each stay under ~4,000 cars.

### Placeholder prices (`priceIsPlaceholder`)

Dealers use the price field for things that are not prices: price-on-request,
a deposit, a parts-only car. On the cheapest page of `bmw/3er` the first two
listings are **€1**, and the third is €400.

These are **not** filtered out — you paid for the rows and you get them — but
each one is flagged `priceIsPlaceholder: true` and counted in the run log, so
"cheapest car" never means "€1 non-price". The cut is on price alone
(≤ €100). The site's own `priceLabel` (`top-price`, `toolow-price`,
`unknown`) is passed through untouched but is *not* used for the flag: it is a
price *evaluation* and appears on perfectly real cars at €10,900.

### Seller details are not emitted

Company name, contact person, phone numbers, seller id, street, postcode and
city are **never** read from the page and never appear in a record. The only
seller facts you get are `sellerType` (`Dealer` / `PrivateSeller`) and
`sellerCountry` (a two-letter country code). Detail pages are never requested
— `/angebote/` is disallowed by robots.txt, so the listing URL is emitted for
you to open, not fetched.

If you need dealer contact data, this Actor is not the tool and will not
become it.

### Output

One record per car, `"type": "listing"`:

```json
{
  "type": "listing",
  "search": "bmw/3-series",
  "country": "de",
  "currency": "EUR",
  "totalFound": 11005,
  "pagesReported": 200,
  "pagesCeilingHit": true,
  "id": "44a79204-d10d-4551-95ae-24061aa1f969",
  "url": "https://www.autoscout24.de/angebote/bmw-3er-touring-318i-...",
  "price": 11900,
  "priceLabel": "unknown",
  "priceIsPlaceholder": false,
  "make": "BMW",
  "model": "318",
  "modelGroup": "3er",
  "variant": "Touring",
  "registrationYear": 2011,
  "firstRegistration": "03-2011",
  "mileageKm": 118300,
  "fuel": "Benzin",
  "transmission": "Automatik",
  "powerKw": 105,
  "sellerType": "PrivateSeller",
  "sellerCountry": "DE",
  "scrapedAt": "2026-08-10T..."
}
```

`price`, `mileageKm`, `registrationYear` and `powerKw` are numbers, not
strings; a value the page does not carry is `null`, never `0` and never `""`.
Field names and text come from the country front-end you searched, so a German
run says `Benzin` and `Automatik`.

### How it stays honest

- **The redirect echo-check.** AutoScout24 answers `308` when a slug is not
  the canonical one for the front-end, and the redirect target **has the query
  string stripped**. A naive scraper follows it and returns a perfectly
  plausible page of the *unfiltered* population — right shape, right make,
  wrong cars. This Actor re-attaches the query by hand and then refuses any
  response whose `pageQuery` does not echo every filter it sent.
- **The sort is never the site default.** `sort=standard` is tier- and
  ad-weighted (a measured page was 20/20 dealers). Enumeration always uses
  `sort=age&desc=1` — newest listing first, independent of price and stable
  across pages.
- **Paid placements are dropped.** Promoted (`Nfm`) and OCS slots sit inline
  among the organic hits and look identical; they are excluded and counted, so
  you are not charged for adverts.
- **Charged = pushed.** The run log prints both, and they are asserted equal.

### Limits

- Asking prices of live listings, not transaction prices.
- \~4,000 cars per search maximum — the site's wall, not ours (above).
- One page every 1.5s, and a run stops paging before the 300s Actor timeout
  rather than being killed mid-write; a truncated search says so in the log.
- `autoscout24.ch` is deliberately unsupported: it is a separate operator
  quoting CHF, and mixing currencies into one feed is not worth it.

### If something goes wrong

- **Wrong number or a failed run?** Open a ticket on the **Issues** tab. I read every one and reply within 2 business days (Japan time).
- **You never get a fake "empty" result.** If the site can't be read, the run fails and says so.
- **No results = no charge.** You only pay for results you actually get.
- **Checked every week.** An automatic test runs this tool weekly; if the site changes, I fix it.
- **Public pages only.** No login, no personal data, and it goes easy on the site.

### More tools by the same author

- [AutoScout24 Used Car Prices by Model — Median & Range](https://apify.com/jpmarketdata/autoscout24-price-market-checker)
- [AutoScout24 Underpriced Cars — Discount vs Model Median](https://apify.com/jpmarketdata/autoscout24-underpriced-deals)
- [Vinted Prices by Country — Cheapest vs Priciest Site](https://apify.com/jpmarketdata/vinted-cross-country-price-gap)
- [Vinted Listings — One Row per Item, $0.0008 Each](https://apify.com/jpmarketdata/vinted-listings)
- [Vinted Asking Prices — Median, Range & Favourites](https://apify.com/jpmarketdata/vinted-price-checker)
- [Vinted Underpriced Listings — Cheap and Most Favourited](https://apify.com/jpmarketdata/vinted-underpriced-deals)

All tools (Japan marketplaces, real estate, jobs, racing, prediction markets): <https://apify.com/jpmarketdata>

### Disclaimer

Unofficial, independent tool — **not affiliated with, endorsed by, or sponsored by AutoScout24**. Product names and logos belong to their owners and only say where the data comes from. Data is read from public pages, for market research; check before you act on it.

# Actor input Schema

## `searches` (type: `array`):

One object per search, e.g. {"make":"bmw","model":"3-series","priceTo":20000}.

## `maxListings` (type: `integer`):

How many cars to return per search. AutoScout24 saturates at 200 pages however deep you go.

## `country` (type: `string`):

AutoScout24 country site to search.

## Actor input object example

```json
{
  "searches": [
    {
      "make": "bmw",
      "model": "3-series"
    }
  ],
  "maxListings": 100,
  "country": "de"
}
```

# Actor output Schema

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

One record per AutoScout24 listing: price, make, model, year, mileage, fuel, transmission, seller country and URL.

# 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 = {
    "searches": [
        {
            "make": "bmw",
            "model": "3-series"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/autoscout24-listings").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 = { "searches": [{
            "make": "bmw",
            "model": "3-series",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/autoscout24-listings").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 '{
  "searches": [
    {
      "make": "bmw",
      "model": "3-series"
    }
  ]
}' |
apify call jpmarketdata/autoscout24-listings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jpmarketdata/autoscout24-listings"
        }
    }
}

```

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/h9h5KY69mdUMeaUXU/builds/X7uUI3AGdQlnjUDWs/openapi.json