# Comparis.ch Scraper - Swiss Used Cars + Market Price (`rastriq/comparis-scraper`) Actor

Scrape used car listings from comparis.ch (Switzerland): price in CHF, mileage, fuel, gearbox, canton, original portal and comparis' own market price valuation and rating for every car. Same field names as the other Rastriq car scrapers. Swiss residential proxy pre-selected.

- **URL**: https://apify.com/rastriq/comparis-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 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/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

## Comparis.ch Scraper

**Comparis.ch Scraper** extracts used car listings from comparis.ch, Switzerland's biggest comparison portal: price in CHF, mileage, year, fuel, gearbox, canton, the original portal of the ad and, as a differentiator, **comparis' own market price valuation and rating for every car**. Search by brand and export a clean, de-duplicated dataset to JSON, CSV or Excel; no browser, no login.

> Part of the Rastriq car-marketplace family: the core fields (`id`, `title`, `make`, `model`, `year`, `km`, `hp`, `price`, `currency`, `fuel_type`, `gearbox`, `city`, `region`, `is_professional`, `url`, `img_url`, `source`, `scraped_at`) are identical across countries, and source-specific extras are prefixed `ext_`. Datasets from several countries can be stacked without re-mapping.

### What data you get with Comparis.ch Scraper

Comparis.ch Scraper returns one flat record per listing. Fields the source does not provide are `null`; nothing is guessed.

| Field | Type | Description |
|---|---|---|
| `id` | string | comparis.ch listing ID. |
| `title` | string (nullable) | Make plus version line as shown in the listing. |
| `make` | string (nullable) | Car manufacturer. |
| `model` | string (nullable) | Car model. |
| `year` | integer (nullable) | Year of first registration. |
| `km` | integer (nullable) | Mileage in kilometres. |
| `hp` | integer (nullable) | Engine power in PS/hp; null when the listing does not state it. |
| `price` | integer (nullable) | Asking price in whole CHF. |
| `currency` | string | ISO 4217 currency code (CHF). |
| `fuel_type` | string (nullable) | Fuel as published by comparis, in German (Benzin, Diesel, Elektro, Hybrid...). |
| `gearbox` | string (nullable) | Transmission as published, in German (Automat, Schaltgetriebe). |
| `city` | string (nullable) | City of the advertiser. |
| `region` | string (nullable) | Swiss canton code (two letters, for example ZH). |
| `is_professional` | boolean (nullable) | Not shown by the source: always null. comparis.ch does not say whether the seller is a dealer or a private person. |
| `url` | string (nullable) | Direct link to the listing on comparis.ch. |
| `img_url` | string (nullable) | Main photo; null when only a placeholder exists. |
| `source` | string | Always comparis.ch. |
| `scraped_at` | string | UTC extraction timestamp, ISO 8601. |
| `ext_version` | string (nullable) | Trim or version line. |
| `ext_postal_code` | string (nullable) | Swiss postal code (PLZ). |
| `ext_first_registration` | string (nullable) | First registration date as published (MM.YYYY). |
| `ext_condition` | string (nullable) | Condition label, for example Occasion (used). |
| `ext_body_type` | string (nullable) | Body type as published (suv, limousine...); null if absent. |
| `ext_comparis_market_price` | integer (nullable) | comparis.ch own market valuation of the car, in CHF. Compare it with price. |
| `ext_comparis_rating` | number (nullable) | comparis.ch own rating value, exactly as published (number). |
| `ext_source_portal` | string (nullable) | Original portal the ad comes from, for example AutoScout24. |
| `ext_first_seen` | string (nullable) | Date comparis first saw the ad (DD.MM.YYYY). |

### How to use Comparis.ch Scraper

1. Open **Comparis.ch Scraper** on Apify and click **Try for free**.
2. Enter a `make` (for example `audi`, `bmw`, `mercedes-benz`) or leave it empty for all used cars.
3. Set **Max pages** (10 listings per page) and **Max items**. The prefill (1 page, 10 items) is a cheap first test.
4. Keep the default **Swiss residential proxy** and click **Start**.
5. Download the dataset from the **Output** tab as JSON, CSV or Excel, or read it through the API.

Typical uses of Comparis.ch Scraper:

- Spot deals by comparing each `price` with `ext_comparis_market_price`
- Track Swiss used car prices by brand, model and year
- Compare Switzerland with other markets using the same field names

### Input example

The prefilled input of Comparis.ch Scraper (a cheap first run):

```json
{
  "make": "audi",
  "maxPages": 1,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CH"
  }
}
```

| Parameter | Type | Default | Prefill | Description |
|---|---|---|---|---|
| `make` | string | — | `audi` | Brand as in the comparis.ch URL, lowercase. Examples: `audi`, `bmw`, `mercedes-benz`, `volkswagen`. Leave empty to browse all used cars. |
| `maxPages` | integer | `3` | `1` | Maximum number of result pages to read (10 listings per page). comparis.ch serves about 100 pages per search, so split very large brands into several runs. Use 1 for a quick test. |
| `maxItems` | integer | — | `10` | Maximum number of listings to return in total. If empty, it defaults to 10 times Max pages. Example: `10` costs about $0.045. |
| `proxyConfiguration` | object | Residential CH | Residential CH | Residential proxy from Switzerland is required: comparis.ch answers HTTP 403 to datacenter IPs, so the default is Apify RESIDENTIAL with country `CH`. The Actor rotates to a fresh IP on 403 and fails explicitly if it stays blocked. The Swiss residential proxy is included in the price: you only pay the events listed in Pricing. |

### Output example

A real record returned by Comparis.ch Scraper:

```json
{
  "id": "33725632",
  "title": "Audi e-tron 55 quattro",
  "make": "Audi",
  "model": "e-tron",
  "year": 2020,
  "km": 127000,
  "hp": 408,
  "price": 16200,
  "currency": "CHF",
  "fuel_type": "Elektro",
  "gearbox": "Automat",
  "city": "Erlinsbach",
  "region": "SO",
  "is_professional": null,
  "url": "https://www.comparis.ch/carfinder/marktplatz/details/show/33725632",
  "img_url": "https://mapl-assets.b-cdn.net/carfinder/images/datacollect/40592b39-15bf-9570-3421-895a9de5cbb6.jpg",
  "source": "comparis.ch",
  "scraped_at": "2026-10-24T20:54:25.280892+00:00",
  "ext_version": "e-tron 55 quattro",
  "ext_postal_code": "5015",
  "ext_first_registration": "03.2020",
  "ext_condition": "Occasion",
  "ext_body_type": "suv",
  "ext_comparis_market_price": 35000,
  "ext_comparis_rating": 6,
  "ext_source_portal": "AutoScout24",
  "ext_first_seen": "24.10.2026"
}
```

### Pricing

Comparis.ch Scraper uses pay-per-event pricing: **$0.005 per run start** plus **$0.004 per listing** ($4.00 per 1,000). You only pay for unique listings delivered to the dataset; a run that returns nothing charges no listings.

| Run | Cost in events |
|---|---|
| 10 listings (prefill) | $0.045 |
| 30 listings (default run) | $0.125 |
| 1,000 listings | $4.005 |
| 10,000 listings | $40.005 |

comparis.ch blocks datacenter IPs, so Comparis.ch Scraper uses Apify **Residential proxy (Switzerland)** by default. The proxy is included in the price: you only pay the events listed above, with no extra proxy or platform charges.

Tip: start with the prefilled input, check the output, then raise `maxPages` and `maxItems`.

### Limitations

- **Not shown by the source:** `is_professional` is always `null`; comparis.ch does not say whether the seller is a dealer or a private person.
- **No seller name or phone.** comparis.ch can list private sellers, who are natural persons, so the Actor does not extract them. Use the listing `url` to reach the seller through the original portal (`ext_source_portal`).
- `ext_comparis_market_price` and `ext_comparis_rating` are comparis' own valuation, reported as published. They can differ a lot from the asking price, and the rating scale is not documented by the source.
- A single search is served in about 100 pages (10 listings each), so split large brands into several runs. When a page returns fewer than 10 listings the Actor treats it as the end of the results.
- Fuel type, gearbox and body type use comparis.ch's German labels. Tested pagination: 3 pages of Audi returned 30 unique listings, with comparis announcing about 16,300 results.

### Related Actors

Other Rastriq car-marketplace scrapers with the same core fields:

| Country | Actor | Notes |
|---|---|---|
| Portugal | [StandVirtual Scraper](https://apify.com/rastriq/standvirtual-scraper) | dealer-heavy marketplace |
| Portugal | [CustoJusto Scraper](https://apify.com/rastriq/custojusto-scraper) | general classifieds, many private sellers |
| Turkey | [Arabam.com Scraper](https://apify.com/rastriq/arabam-scraper) | used cars |
| Poland | [OtoMoto Scraper](https://apify.com/rastriq/otomoto-scraper) | largest Polish marketplace |
| Romania | [Autovit Scraper](https://apify.com/rastriq/autovit-scraper) | Romanian marketplace |
| Spain | [Coches.net Scraper](https://apify.com/rastriq/cochesnet-spain) | Spain's top marketplace |
| Switzerland, Germany, EU | [AutoScout24 Scraper](https://apify.com/rastriq/autoscout24-scraper) | the portal most comparis ads come from |

### FAQ

**Is it legal to scrape comparis.ch?** Comparis.ch Scraper reads publicly visible listing pages at a low request rate, without logging in or bypassing access controls, and it does not extract seller names or phone numbers. Check the website terms and make sure your use of the data complies with the law that applies to you, including data protection rules.

**Does Comparis.ch Scraper need a proxy?** Yes. comparis.ch returns HTTP 403 to datacenter IPs, so a Swiss residential proxy is pre-selected (Apify Proxy, group RESIDENTIAL, country `CH`). It is included in the price: you only pay the events listed in Pricing. On a 403 the Actor rotates to a fresh IP up to five times per page and fails with a clear message if the site stays blocked.

**How often should I run Comparis.ch Scraper?** Swiss listings change daily. Weekly runs per brand are enough for market tracking; compare `ext_comparis_market_price` between runs to follow valuations.

**Can I schedule Comparis.ch Scraper or call it from my code?** Yes. Use Apify schedules, the API, or integrations such as Make, Zapier or Google Sheets to run it automatically and send the dataset on.

**Something broke or a field is missing?** comparis.ch changes its pages from time to time. Open an issue on the Actor page and include the run link.

# Actor input Schema

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

Brand as in the comparis.ch URL, lowercase. Examples: <code>audi</code>, <code>bmw</code>, <code>mercedes-benz</code>, <code>volkswagen</code>. Leave empty to browse all used cars.

## `maxPages` (type: `integer`):

Maximum number of result pages to read (10 listings per page). comparis.ch serves about 100 pages per search, so split very large brands into several runs. Use 1 for a quick test.

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

Maximum number of listings to return in total. If empty, it defaults to 10 times Max pages. Example: <code>10</code> costs about $0.045.

## `proxyConfiguration` (type: `object`):

<b>Residential proxy from Switzerland is required</b>: comparis.ch answers HTTP 403 to datacenter IPs, so the default is Apify RESIDENTIAL with country <code>CH</code>. The Actor rotates to a fresh IP on 403 and fails explicitly if it stays blocked. The Swiss residential proxy is included in the price: you only pay the events listed in the Pricing tab.

## Actor input object example

```json
{
  "make": "audi",
  "maxPages": 1,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CH"
  }
}
```

# Actor output Schema

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

Used car listings extracted from comparis.ch, including comparis' market price valuation.

# 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": "audi",
    "maxPages": 1,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "CH"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/comparis-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": "audi",
    "maxPages": 1,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "CH",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/comparis-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": "audi",
  "maxPages": 1,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CH"
  }
}' |
apify call rastriq/comparis-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rastriq/comparis-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/wr6rVN9eNEMsn8pnn/builds/RO1yh05acm6mghmGd/openapi.json