# AutoScout24 CH car listings (`data_dino/autoscout24-ch`) Actor

Scrape AutoScout24 vehicle listings by make and model with price, mileage, year, and full detail filters. Returns flattened, structured records ready for analysis.

- **URL**: https://apify.com/data\_dino/autoscout24-ch.md
- **Developed by:** [Data Dino](https://apify.com/data_dino) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 results

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 CH Car Listings — Switzerland

Scrape AutoScout24 Switzerland (autoscout24.ch) vehicle listings by make and model with structured, analysis-ready output. This is the **only Apify actor that covers the Swiss market** — all other AutoScout24 scrapers on Apify target the pan-European domains (.com, .de, .at, .it, .nl, .be, .fr, .es) and do not support .ch, which runs on a separate backend API.

Designed for market researchers, pricing analysts, and automotive professionals who need Swiss vehicle data without manual browsing.

### Why use this actor?

- **Swiss market exclusivity** — the only Apify actor covering autoscout24.ch. No competitor supports the Swiss domain.
- **Simplest input** — just type a make and model name (e.g. "Tesla Model S"). No URL construction or slug lookup required; the actor resolves names to API keys automatically.
- **Rich filters** — narrow results by price range, mileage range, and first-registration year.
- **Full detail mode** — visit each listing's detail endpoint to extract every field the API returns: battery/range, dimensions, VIN, colors, equipment, description, and more.
- **Summary mode** — skip detail fetches for faster runs when summary fields are sufficient.
- **Motorcycle support** — search motorcycle listings in addition to cars. No other AutoScout24 actor offers this.
- **Analysis-ready output** — every listing is a flat, deduplicated record sorted by price. No nested objects to parse, no post-processing needed — ready for spreadsheets or databases.
- **No field is silently dropped** — the flattening layer captures every field the API returns, including fields not documented here.
- **Apify-native workflow** — schedule runs, monitor progress, and export the resulting dataset in JSON, CSV, Excel, or other supported formats.

### What you can collect

Each listing may include the following fields, depending on what the API returns:

| Category | Fields |
|---|---|
| Identity | Listing URL, listing ID, make, make key, model, model key, version full name |
| Price | Price in CHF, previous price, condition type |
| Vehicle specs | Mileage, first registration year, fuel type, transmission, horse power |
| Detail fields | Battery capacity, electric range, dimensions, VIN, exterior/interior color, equipment, and any other field the API returns |
| Seller | Seller name, seller type, seller city, seller zip |

The actor keeps the source listing URL with every record, making it easy to trace a finding back to the original ad.

### Input

| Field | Type | Required | Description |
|---|---|---:|---|
| `make` | String | Yes | Vehicle make name or key, e.g. "Tesla" or "tesla" |
| `model` | String | Yes | Vehicle model name or key, e.g. "Model S" or "model-s" |
| `domain` | String | No | Country domain to scrape (default: "ch"). Only "ch" is confirmed to work. |
| `category` | String | No | Vehicle category: "car" (default) or "motorcycle" |
| `detail` | Boolean | No | Fetch full details per listing (default: true). Disable for faster summary-only runs. |
| `priceFrom` | Integer | No | Minimum price in CHF (inclusive) |
| `priceTo` | Integer | No | Maximum price in CHF (inclusive) |
| `mileageFrom` | Integer | No | Minimum mileage in km (inclusive) |
| `mileageTo` | Integer | No | Maximum mileage in km (inclusive) |
| `yearFrom` | Integer | No | Earliest first-registration year (inclusive) |
| `yearTo` | Integer | No | Latest first-registration year (inclusive) |
| `delay` | Number | No | Delay in seconds between API requests (default: 0.4) |

#### Example input

```json
{
  "make": "Tesla",
  "model": "Model S",
  "priceTo": 50000,
  "yearFrom": 2020
}
```

### Output

The actor pushes one dataset item for each listing found. A representative result looks like this:

```json
{
  "id": 123456789,
  "make": "Tesla",
  "makeKey": "tesla",
  "model": "Model S",
  "modelKey": "model-s",
  "versionFullName": "Model S Long Range",
  "url": "https://www.autoscout24.ch/de/d/123456789",
  "price": 42900,
  "previousPrice": 44900,
  "conditionType": "Used",
  "mileage": 35000,
  "firstRegistrationYear": 2021,
  "fuelType": "Electric",
  "transmissionType": "Automatic",
  "horsePower": 510,
  "sellerName": "Auto Example AG",
  "sellerType": "Dealer",
  "sellerCity": "Zurich",
  "sellerZip": "8001"
}
```

The example shows the priority fields. A full-detail listing contains many more fields returned by the API, all flattened into the same record. Fields not present on a listing are omitted rather than set to null.

### Built for practical workflows

- **Swiss price analysis** — compare asking prices across models, years, and mileage bands on the Swiss market.
- **Market monitoring** — track listing volumes and price trends over time with scheduled runs.
- **Inventory research** — find vehicles matching specific criteria for acquisition or valuation.
- **EV research** — extract battery capacity and electric range fields for electric vehicle comparisons.
- **Motorcycle listings** — search motorcycle classifieds alongside cars.

### How to run

1. Open the actor in Apify.
2. Enter a vehicle make and model (e.g. "BMW" and "3 Series").
3. Optionally set price, mileage, or year filters.
4. Start the run.
5. Review the dataset or export it as JSON, CSV, Excel, or another supported format.

### Important limitations

- Only the `ch` (Switzerland) domain is supported; other AutoScout24 country domains use a different backend that this actor does not cover.
- Results depend on what the AutoScout24 API returns at run time.
- Prices are in CHF (Swiss Francs).
- There is no result limit — the actor fetches all matching listings for the given make/model and filters.

# Actor input Schema

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

Make name or key, e.g. 'Tesla' or 'tesla'. The scraper resolves human-readable names to API keys automatically.

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

Model name or key, e.g. 'Model S' or 'model-s'. The scraper resolves human-readable names to API keys automatically.

## `domain` (type: `string`):

Country domain to scrape, matching autoscout24.<domain>. Only 'ch' is confirmed to work as of this writing.

## `category` (type: `string`):

Vehicle category to search: car or motorcycle.

## `detail` (type: `boolean`):

When enabled, visit each listing's detail endpoint to extract every field the API returns (battery, range, VIN, colors, equipment, description, etc.). When disabled, keep only the summary fields from search results (faster, fewer fields).

## `priceFrom` (type: `integer`):

Minimum price in CHF (inclusive). Leave empty for no lower bound.

## `priceTo` (type: `integer`):

Maximum price in CHF (inclusive). Leave empty for no upper bound.

## `mileageFrom` (type: `integer`):

Minimum mileage in km (inclusive). Leave empty for no lower bound.

## `mileageTo` (type: `integer`):

Maximum mileage in km (inclusive). Leave empty for no upper bound.

## `yearFrom` (type: `integer`):

Earliest first-registration year (inclusive). Leave empty for no lower bound.

## `yearTo` (type: `integer`):

Latest first-registration year (inclusive). Leave empty for no upper bound.

## `delay` (type: `number`):

Delay in seconds between HTTP requests to the AutoScout24 API. Lower values are faster but may trigger rate limiting.

## Actor input object example

```json
{
  "make": "Tesla",
  "model": "Model S",
  "domain": "ch",
  "category": "car",
  "detail": true,
  "delay": 0.4
}
```

# Actor output Schema

## `dataset` (type: `string`):

Structured AutoScout24 vehicle listing records collected during the run.

# 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": "Tesla",
    "model": "Model S",
    "domain": "ch",
    "category": "car",
    "detail": true,
    "delay": 0.4
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_dino/autoscout24-ch").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": "Tesla",
    "model": "Model S",
    "domain": "ch",
    "category": "car",
    "detail": True,
    "delay": 0.4,
}

# Run the Actor and wait for it to finish
run = client.actor("data_dino/autoscout24-ch").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": "Tesla",
  "model": "Model S",
  "domain": "ch",
  "category": "car",
  "detail": true,
  "delay": 0.4
}' |
apify call data_dino/autoscout24-ch --silent --output-dataset

```

## MCP server setup

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

```

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/DAO3KockDb772UHTp/builds/nKCE32bsBqftXJAJp/openapi.json