# Swiss Health Insurance Premiums Lookup (LAMal / KVG) (`najx/swiss-health-insurance-premiums`) Actor

Official 2026 Swiss basic health insurance premiums for any canton, postal code or municipality, filtered by age group, deductible, accident cover and insurance model, sorted from cheapest to most expensive. Built on FOPH open data.

- **URL**: https://apify.com/najx/swiss-health-insurance-premiums.md
- **Developed by:** [Najim Abdelmoula](https://apify.com/najx) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 premium 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/actors/running/actors-in-store.md#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

### What does Swiss Health Insurance Premiums Lookup do?

**Swiss Health Insurance Premiums Lookup** returns the official **2026 basic health insurance premiums** (LAMal / KVG / AOS / OKP) for any place in Switzerland, sorted from cheapest to most expensive. Give it a **postal code**, a **canton** or a **municipality number**, plus the age group, deductible, accident cover and insurance model, and it returns every matching offer from every insurer as clean JSON: an **API for Swiss health insurance premiums**, built on the open data published by the [Federal Office of Public Health (FOPH / OFSP / BAG)](https://opendata.swiss/dataset/health-insurance-premiums).

It does **not** sign anybody up, does not give advice, and does not contact insurers. It answers one question well: *what does basic insurance cost, for whom, where, with which insurer.*

### Why use Swiss Health Insurance Premiums Lookup?

Every autumn, 9 million residents of Switzerland receive their new premium and many of them compare and switch before 30 November. The official data is public but ships as a 22 MB spreadsheet with coded columns (`AKL-ERW`, `FRA-2500`, `PR-REG CH2`, insurer numbers instead of names). This Actor does the decoding for you.

- 🏥 **Every insurer, every model, every deductible** for the selected place and person.
- 📍 **Postal code or municipality in, premium region out.** The Actor resolves the canton and the premium region from the place of residence, exactly as insurers do.
- 💸 **Cheapest first**, with monthly and annual amounts, insurer names and tariff names in French, German and Italian.
- 🤖 **Made for AI agents and automations**: one call, structured output, no scraping, no login, no captcha. Works through the Apify API, the MCP server, n8n, Make, Zapier and scheduled runs.
- 📅 **Refreshed at every FOPH release**: the 2027 premiums are added as soon as the Federal Council publishes them (usually late September).

Typical users: comparison tools, brokers and advisors, HR and relocation services, journalists, AI assistants answering "what is the cheapest health insurance in Lausanne?", and anyone building a Swiss personal-finance product.

### What data does it return?

| Field | Type | Description |
| --- | --- | --- |
| `rank` | integer | Position in the list, 1 = cheapest |
| `insurer` / `insurerId` | string / integer | Insurer name and FOPH number |
| `model` | string | `standard`, `familyDoctor`, `hmo` or `telmedOrOther` |
| `tariffName` / `tariffNames` | string / object | Tariff name, with DE/FR/IT variants |
| `deductibleCHF` | integer | Annual deductible (franchise) |
| `accidentCover` | boolean | Whether accident cover is included |
| `monthlyPremiumCHF` / `annualPremiumCHF` | number | Premium per month and per year |
| `canton` / `region` | string / integer | Canton and premium region the premium applies to |
| `ageGroup` / `childRank` | string / integer | Age group, and child rank for sibling tariffs |
| `isBaseTariff` / `isStandardDeductible` | boolean | Flags from the FOPH data |

The run also stores a `SUMMARY` record with the resolved location, any warnings and the cheapest offer.

### How to look up Swiss health insurance premiums

1. Open the Actor and enter a **postal code** (e.g. `1003`), or pick a **canton**, or enter a **municipality BFS number** for the most precise region.
2. Choose the **age group** (adult, young adult, child), the **deductible**, whether **accident cover** is needed, and the **model** (any, standard, family doctor, HMO, telemedicine or other).
3. Optionally restrict to a few **insurers** and set a **limit**.
4. Click **Start**. Results appear in the Output tab within seconds, cheapest first.
5. Download them as JSON, CSV or Excel, or call the Actor from your code with the API tab.

#### What is a premium region?

Cantons with large cost differences are split into up to three premium regions (BE, BL, FR, GR, LU, SG, SH, TI, VD, VS, ZH). The region is defined by the **municipality of residence**, not by the postal code. When a postal code covers several regions, the Actor returns all of them and tells you so in the run log; pass `municipalityBfs` to get exactly one.

#### Which deductible and accident cover should I choose?

Adults and young adults can choose 300, 500, 1000, 1500, 2000 or 2500 CHF; children 0 to 600 CHF. Employees working 8 hours a week or more are insured against accidents by their employer and set `accidentCover` to `false`; everybody else keeps `true`. Leave the deductible empty to compare all of them at once.

### How much does it cost?

The Actor uses **pay-per-event** pricing: you pay a small amount per premium returned (see the pricing box on this page), nothing when a query returns no results. A typical query for one person, one deductible and all models returns 40 to 120 results. Use `limit` to cap the cost, or `insurers` to compare a shortlist. Free Apify plans include enough credit to run it many times a month.

### Input

See the Input tab for all options. Minimal example:

```json
{ "postalCode": "1003", "ageGroup": "adult", "deductible": 2500, "accidentCover": false }
```

Advanced example, three insurers in Zurich premium region 1 for a first child, telemedicine models only:

```json
{ "canton": "ZH", "region": 1, "ageGroup": "child", "childRank": 1, "model": "telmedOrOther", "insurers": ["CSS", "Helsana", "Sanitas"] }
```

### Output

You can download the dataset in JSON, CSV, Excel or HTML formats. Two simplified items:

```json
[
  {
    "rank": 1,
    "year": 2026,
    "canton": "VD",
    "region": 1,
    "insurerId": 1509,
    "insurer": "Sanitas",
    "model": "telmedOrOther",
    "tariffId": "TelMed (Compact One)",
    "tariffName": "TelMed (Compact One)",
    "ageGroup": "adult",
    "deductibleCHF": 2500,
    "accidentCover": false,
    "monthlyPremiumCHF": 412.2,
    "annualPremiumCHF": 4946.4
  },
  {
    "rank": 2,
    "insurer": "CSS",
    "model": "familyDoctor",
    "tariffName": "Multimed",
    "deductibleCHF": 2500,
    "monthlyPremiumCHF": 416.2,
    "annualPremiumCHF": 4994.4
  }
]
```

### Using the Actor from code and AI agents

Call it through the [Apify API](https://docs.apify.com/api/v2) in any language, or expose it to Claude, ChatGPT, Cursor or any MCP client through the [Apify MCP server](https://mcp.apify.com/). Example with the Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("<ACTOR_ID>").call(run_input={  # Actor ID or "username/name" from the API tab
    "postalCode": "8001", "ageGroup": "adult", "deductible": 2500, "accidentCover": False, "model": "telmedOrOther", "limit": 10,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["rank"], item["insurer"], item["tariffName"], item["monthlyPremiumCHF"])
```

### Data source, accuracy and privacy

- Source: FOPH open data *Krankenversicherungsprämien / Primes de l'assurance-maladie* on [opendata.swiss](https://opendata.swiss/dataset/health-insurance-premiums), plus the premium-region tables from [priminfo.admin.ch](https://www.priminfo.admin.ch). The data is bundled in the Actor at build time; nothing is fetched at run time.
- Premiums are those approved by the FOPH for the premium year. Insurers may apply supplements or discounts not reflected in the official data; always confirm with the insurer or on priminfo.admin.ch before signing.
- Premiums for people living in the EU/EFTA (cross-border workers, pensioners) are not included in this version.
- The Actor processes no personal data: it never receives a name, a date of birth or an address, only a postal code or municipality.

### Frequently asked questions

#### Is this the same data as priminfo.admin.ch?

Yes. The federal premium calculator and this Actor use the same FOPH dataset. The Actor returns it as structured data instead of a web form.

#### When are the 2027 premiums available?

The Federal Council announces them at the end of September. A new version of the Actor with the 2027 data is published within days; set `year` to `2027` once it is listed in the changelog.

#### Can I get premiums for a whole canton in one run?

Yes: pass `canton` without `region` and the Actor returns every premium region. Combine with `limit` if you only need the cheapest offers.

#### Something looks wrong

Open an issue in the **Issues** tab with the input you used. Corrections to the source data itself have to go to the FOPH.

### Development

Python 3.12, Apify SDK, no runtime dependencies beyond the SDK. `scripts/build_dataset.py` downloads the FOPH and priminfo files and writes the compact tables under `data/`; `pytest tests` checks the lookup logic against the shipped data; `apify run` runs the Actor locally.

# Actor input Schema

## `postalCode` (type: `string`):

Four-digit Swiss postal code of the place of residence, e.g. 1003 for Lausanne. Resolves the canton and the premium region. If the postal code spans several regions, all of them are returned; pass municipalityBfs to disambiguate.

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

Two-letter canton code. Used alone it returns every premium region of the canton unless region is set.

## `region` (type: `integer`):

Premium region within the canton (0 = single region; 1, 2 or 3 in BE, BL, FR, GR, LU, SG, SH, TI, VD, VS, ZH). Ignored when municipalityBfs is given.

## `municipalityBfs` (type: `integer`):

Federal municipality number, e.g. 5586 for Lausanne. The most precise way to select the premium region, since the region is defined by the municipality of residence.

## `ageGroup` (type: `string`):

child = 0-18, youngAdult = 19-25, adult = 26 and over (age reached during the premium year).

## `childRank` (type: `integer`):

1 for the first child. Some insurers publish sibling discounts (rank 3 and above); use 3 to see them.

## `deductible` (type: `integer`):

Adults and young adults: 300, 500, 1000, 1500, 2000 or 2500. Children: 0, 100, 200, 300, 400, 500 or 600. Leave empty to get every deductible.

## `accidentCover` (type: `boolean`):

true if the person is NOT covered for accidents by an employer (working fewer than 8 hours a week, self-employed, child, student, retired). Employees working 8+ hours a week are covered by their employer and choose false.

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

standard = free choice of doctor; familyDoctor = family doctor model (HAM); hmo = HMO practice; telmedOrOther = telemedicine and other alternative models (DIV); any = all models.

## `insurers` (type: `array`):

Insurer names (case-insensitive substring, e.g. "Assura", "CSS", "Helsana") or FOPH insurer numbers (e.g. 1542). Leave empty for all insurers.

## `limit` (type: `integer`):

Results are sorted from cheapest to most expensive; 0 returns all of them. Each result is one billable event.

## `year` (type: `integer`):

Premium year. Only years shipped with this Actor version are available (see README).

## Actor input object example

```json
{
  "postalCode": "1003",
  "ageGroup": "adult",
  "childRank": 1,
  "accidentCover": true,
  "model": "any",
  "limit": 0,
  "year": 2026
}
```

# Actor output Schema

## `premiums` (type: `string`):

No description

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

No description

# 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 = {
    "postalCode": "1003"
};

// Run the Actor and wait for it to finish
const run = await client.actor("najx/swiss-health-insurance-premiums").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 = { "postalCode": "1003" }

# Run the Actor and wait for it to finish
run = client.actor("najx/swiss-health-insurance-premiums").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 '{
  "postalCode": "1003"
}' |
apify call najx/swiss-health-insurance-premiums --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,najx/swiss-health-insurance-premiums"
        }
    }
}

```

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/DljNjecIcsPha8mcj/builds/NWDLUe8INKooOOQni/openapi.json