# Comparis Scraper - Swiss Insurance & Telecom Comparison (`studio-amba/comparis-scraper`) Actor

Scrape comparison data from Comparis.ch, Switzerland's leading comparison platform. Extract insurance plans, telecom offers, auto deals, and property listings with prices, providers, ratings, and features. No login or cookies required.

- **URL**: https://apify.com/studio-amba/comparis-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Comparis Scraper

Scrape comparison data from [Comparis.ch](https://www.comparis.ch), Switzerland's leading online comparison platform. Extract insurance plans, telecom offers, auto deals, and property listings with prices, providers, ratings, and features.

No login or cookies required.

### How to scrape Comparis data

1. Go to the [Comparis Scraper](https://apify.com/studio-amba/comparis-scraper) on Apify Store.
2. Click **Try for free** to open the actor in Apify Console.
3. Select a **Category** (Insurance, Telecom, Property, or Auto).
4. Optionally enter a **Search Query** to filter results (e.g. "Krankenkasse", "Handy Abo", "Autoversicherung").
5. Choose a **Subcategory** to narrow your search (e.g. "krankenkassen", "mobile", "autoversicherung").
6. Set **Max Results** to control how many items to scrape.
7. Click **Start** and wait for the run to finish.
8. Download your data in JSON, CSV, Excel, or any other supported format.

### What data can you extract from Comparis?

This scraper extracts structured comparison data across all major Comparis categories:

#### Insurance (Versicherungen)
- Health insurance (Krankenkassen) plans and premiums
- Car insurance (Autoversicherung) quotes and coverage
- Home contents and personal liability insurance (Hausratversicherung)
- Legal protection insurance (Rechtsschutzversicherung)
- Pet insurance (Tierversicherung)
- Supplemental insurance (Zusatzversicherung)

#### Telecom (Telekom)
- Mobile phone plans and subscription offers
- Internet provider comparisons
- TV packages and bundles
- Combined telecom deals

#### Property (Immobilien)
- Rental listings across Switzerland
- Properties for sale
- Regional market data

#### Auto
- New and used car listings
- Car insurance comparisons
- Vehicle marketplace offers

### Output fields

Each scraped item contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `planName` | string | Name of the plan, product, or listing |
| `provider` | string | Provider or company name (e.g. Swisscom, CSS, Zurich) |
| `category` | string | Comparis category: versicherungen, telekom, immobilien, or auto |
| `subcategory` | string | Specific subcategory (e.g. krankenkassen, mobile) |
| `monthlyPrice` | number | Monthly price in CHF |
| `annualPrice` | number | Annual price in CHF |
| `currency` | string | Currency code (CHF) |
| `rating` | number | User or Comparis rating score |
| `reviewCount` | integer | Number of reviews or ratings |
| `features` | array | List of included features and benefits |
| `planDescription` | string | Short description of the plan or product |
| `imageUrl` | string | Provider logo or product image URL |
| `url` | string | Direct URL to the detail page on Comparis.ch |
| `scrapedAt` | string | ISO 8601 timestamp of data collection |

### Example output

```json
{
    "planName": "BASIC Hausarztmodell",
    "provider": "CSS Versicherung",
    "category": "versicherungen",
    "subcategory": "krankenkassen",
    "monthlyPrice": 312.50,
    "annualPrice": 3750.00,
    "currency": "CHF",
    "rating": 4.2,
    "reviewCount": 1523,
    "features": [
        "Hausarztmodell",
        "Franchise CHF 2500",
        "Telemedizin inklusive"
    ],
    "planDescription": "Grundversicherung mit Hausarztmodell und Telemedizin",
    "imageUrl": "https://www.comparis.ch/images/providers/css-logo.png",
    "url": "https://www.comparis.ch/krankenkassen/anbieter/css-versicherung",
    "scrapedAt": "2026-06-09T10:30:00.000Z"
}
````

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `category` | string | `versicherungen` | Category to scrape: versicherungen, telekom, immobilien, or auto |
| `searchQuery` | string | `Krankenkasse` | Search term to filter results. Leave empty to browse a category |
| `subcategory` | string | (empty) | Optional subcategory to narrow results |
| `canton` | string | (empty) | Swiss canton code (ZH, BE, GE, etc.) for regional results |
| `maxResults` | integer | 50 | Maximum number of items to scrape (1-1000) |
| `proxyConfiguration` | object | Swiss RESIDENTIAL | Proxy settings. Swiss residential proxies strongly recommended |

### Supported subcategories

#### Insurance (versicherungen)

- `krankenkassen` -- Health insurance comparison
- `autoversicherung` -- Car insurance quotes
- `hausrat` -- Home contents and liability insurance
- `rechtsschutz` -- Legal protection insurance
- `tierversicherung` -- Pet insurance
- `zusatzversicherung` -- Supplemental health insurance

#### Telecom (telekom)

- `mobile` -- Mobile phone plans
- `internet` -- Internet providers
- `tv` -- TV packages
- `combo` -- Combined deals

#### Property (immobilien)

- `mieten` -- Rental listings
- `kaufen` -- Properties for sale

#### Auto

- `neuwagen` -- New cars
- `occasion` -- Used cars
- `autoversicherung` -- Car insurance

### Tips for best results

- **Use Swiss proxies**: Comparis.ch restricts access from non-Swiss IP addresses. Always use residential proxies with Swiss (CH) country setting.
- **Start with specific subcategories**: Instead of browsing the entire "versicherungen" category, use subcategories like "krankenkassen" for more focused results.
- **Canton matters for insurance**: Health insurance premiums vary by canton. Set the `canton` field for location-specific comparisons.
- **Moderate result counts**: Start with 20-50 results to verify the scraper works for your use case before scaling up.

### Use cases

- **Insurance comparison**: Monitor Swiss health insurance premiums across providers and cantons for market research.
- **Telecom market analysis**: Track mobile and internet plan pricing across Swiss providers (Swisscom, Sunrise, Salt, etc.).
- **Real estate monitoring**: Build datasets of Swiss property listings for price analysis and market trends.
- **Competitive intelligence**: Compare product offerings and pricing strategies across Swiss service providers.
- **Data journalism**: Gather structured comparison data for reporting on Swiss consumer markets.

### Proxy requirements

Comparis.ch uses anti-bot protection that blocks most datacenter proxies. For reliable scraping:

- Use **Apify Residential Proxies** with country set to **Switzerland (CH)**.
- The actor automatically configures Swiss residential proxies if no custom proxy is specified.
- Datacenter proxies will likely be blocked with 403 errors.

### Limitations

- Results depend on what Comparis.ch displays publicly. Some comparison tools require form submissions with specific parameters (e.g., age, postal code for health insurance).
- The scraper extracts data as rendered on the page. For highly personalized comparisons, results may vary.
- Rate limiting is handled automatically with session rotation and retries.

### FAQ

**Is a Comparis account needed?**
No. This scraper works without any login, cookies, or API keys. It extracts publicly available comparison data.

**What proxy should I use?**
Swiss residential proxies are strongly recommended. The default configuration uses Apify residential proxies with CH country setting.

**How often can I run this scraper?**
You can run it as often as needed. The actor handles rate limiting and session rotation automatically.

**Can I scrape specific insurance providers?**
Yes. Use the `searchQuery` parameter to search for specific providers (e.g. "CSS", "Swisscom", "Zurich") or plan types.

# Actor input Schema

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

Which Comparis category to scrape. Each category navigates to different comparison pages on Comparis.ch.

## `searchQuery` (type: `string`):

Search term to filter results (e.g. 'Krankenkasse', 'Handy Abo', 'Autoversicherung', 'Wohnung Zurich'). Leave empty to browse the selected category.

## `subcategory` (type: `string`):

Optional subcategory to narrow results. Depends on the selected category. Insurance: krankenkassen, autoversicherung, hausrat, rechtsschutz. Telecom: mobile, internet, tv. Auto: neuwagen, occasion. Immobilien: mieten, kaufen.

## `canton` (type: `string`):

Swiss canton code for region-specific results (e.g. 'ZH' for Zurich, 'BE' for Bern, 'GE' for Geneva). Important for insurance and property comparisons.

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

Maximum number of comparison items to scrape.

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

Proxy settings for the browser. Residential proxies with Swiss IP strongly recommended -- Comparis.ch blocks datacenter IPs and non-Swiss traffic aggressively.

## Actor input object example

```json
{
  "category": "versicherungen",
  "searchQuery": "Krankenkasse",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "CH"
  }
}
```

# 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 = {
    "searchQuery": "Krankenkasse",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "CH"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/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 = {
    "searchQuery": "Krankenkasse",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "CH",
    },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Comparis Scraper - Swiss Insurance & Telecom Comparison",
        "description": "Scrape comparison data from Comparis.ch, Switzerland's leading comparison platform. Extract insurance plans, telecom offers, auto deals, and property listings with prices, providers, ratings, and features. No login or cookies required.",
        "version": "0.1",
        "x-build-id": "zMdqMayCbomVAUwnm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~comparis-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-comparis-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/studio-amba~comparis-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-comparis-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/studio-amba~comparis-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-comparis-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": {
                    "category": {
                        "title": "Category",
                        "enum": [
                            "versicherungen",
                            "telekom",
                            "immobilien",
                            "auto"
                        ],
                        "type": "string",
                        "description": "Which Comparis category to scrape. Each category navigates to different comparison pages on Comparis.ch.",
                        "default": "versicherungen"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term to filter results (e.g. 'Krankenkasse', 'Handy Abo', 'Autoversicherung', 'Wohnung Zurich'). Leave empty to browse the selected category."
                    },
                    "subcategory": {
                        "title": "Subcategory",
                        "type": "string",
                        "description": "Optional subcategory to narrow results. Depends on the selected category. Insurance: krankenkassen, autoversicherung, hausrat, rechtsschutz. Telecom: mobile, internet, tv. Auto: neuwagen, occasion. Immobilien: mieten, kaufen."
                    },
                    "canton": {
                        "title": "Canton",
                        "type": "string",
                        "description": "Swiss canton code for region-specific results (e.g. 'ZH' for Zurich, 'BE' for Bern, 'GE' for Geneva). Important for insurance and property comparisons."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of comparison items to scrape.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the browser. Residential proxies with Swiss IP strongly recommended -- Comparis.ch blocks datacenter IPs and non-Swiss traffic aggressively."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
