# Swiss BAG Infectious Diseases Scraper (`parseforge/swiss-bag-infectious-diseases-scraper`) Actor

Follow weekly notifiable infectious disease statistics from the Swiss Federal Office of Public Health. Each record returns the disease, week, year, canton, case count, age group, sex, hospitalizations, and deaths. Built for epidemiology research and public health monitoring.

- **URL**: https://apify.com/parseforge/swiss-bag-infectious-diseases-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.52 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🦠 Swiss BAG Infectious Diseases Scraper

> 🚀 **Pull weekly Swiss notifiable infectious disease counts in seconds. By canton, age group, sex, and disease, straight from the BAG idd.bag.admin.ch public API.**

> 🕒 **Last updated** 2026-06-05 · **📊 10 fields** per record · 26 cantons · Weekly resolution since 1988 · Source BAG

The Swiss BAG Infectious Diseases Scraper turns the Swiss Federal Office of Public Health (Bundesamt für Gesundheit, BAG) `idd.bag.admin.ch/api/v1/communicablediseases` endpoint into a clean structured dataset. Filter by disease, canton, and year range, and the actor returns one row per stratum.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| 🧪 Epidemiologists | Build longitudinal time series of notifiable diseases |
| 🏥 Public health teams | Monitor outbreak signals across cantons |
| 📰 Health journalists | Verify case counts for stories |
| 🎓 Academic researchers | Build training and validation cohorts |
| 👩‍💻 Civic tech builders | Power public dashboards |

### 📋 What the Swiss BAG Infectious Diseases Scraper does

- Calls the public BAG endpoint with your filters.
- Normalises field names across the API's German, French, Italian, and English variants.
- Returns one row per disease, week, year, canton, age group, sex stratum.

> 💡 **Why it matters** Notifiable disease data is fragmented across PDF reports and a JS dashboard. The API exists but is undocumented. This actor wraps it.

### 🎬 Full Demo

_🚧 Coming soon._

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
<tr><td><code>disease</code></td><td>string</td><td>No</td><td>Disease name. Empty for all.</td></tr>
<tr><td><code>yearFrom</code></td><td>integer</td><td>No</td><td>Earliest year. Default 2024.</td></tr>
<tr><td><code>yearTo</code></td><td>integer</td><td>No</td><td>Latest year. Default current.</td></tr>
<tr><td><code>canton</code></td><td>enum</td><td>No</td><td>Canton code (ZH, BE, GE, etc.). Empty for all.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td>Free 10, paid up to 1,000,000.</td></tr>
</table>

**Example 1, measles in Zurich 2024:**
```json
{
  "disease": "Masern",
  "canton": "ZH",
  "yearFrom": 2024,
  "yearTo": 2024,
  "maxItems": 100
}
````

**Example 2, all reported diseases nationwide 2025:**

```json
{
  "yearFrom": 2025,
  "yearTo": 2025,
  "maxItems": 500
}
```

> ⚠️ **Good to Know** The BAG API is public and free. No registration required.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🦠 `disease` | string | Disease name. |
| 📅 `week` | integer | ISO week number. |
| 📅 `year` | integer | Year. |
| 🏔️ `canton` | string | Two-letter canton code. |
| 🔢 `cases` | integer | Reported cases for this stratum. |
| 👤 `ageGroup` | string | Age group bucket. |
| ⚧ `sex` | string | Sex stratum. |
| 🏥 `hospitalizations` | integer | Hospitalisations when reported. |
| ⚰️ `deaths` | integer | Deaths when reported. |
| 🕒 `scrapedAt` | string | When this row was fetched. |
| ❌ `error` | string | Set if the upstream response was an error. |

### ✨ Why choose this Actor

| 🆓 | Public BAG endpoint, no key required. |
| 🌍 | All 26 cantons covered. |
| 📅 | Weekly resolution back to 1988. |
| 🧹 | Field names normalised across language variants. |
| 🛟 | Errors surface as a clean record, never a crash. |

### 📈 How it compares to alternatives

| Approach | Setup | Multilang fields | Stratum normalisation |
|---|---|---|---|
| Manual PDF download | hours | ❌ | ❌ |
| Roll your own fetch | 30 min plus | ❌ | ❌ |
| **This Actor** | 5 sec | ✅ | ✅ |

### 🚀 How to use

1. Click **Try for free**.
2. Pick a disease, canton, and year range.
3. Click **Start**.
4. Open the dataset.

### 💼 Business use cases

**🏥 Public health** Track outbreak signals across cantons.

**🧪 Epidemiology** Build longitudinal cohorts for time-series modelling.

**📰 Newsrooms** Verify case counts for stories.

**🤖 ML training** Feed structured surveillance data into forecasting models.

### 🔌 Automating Swiss BAG Infectious Diseases Scraper

- **Make and Zapier** trigger weekly when BAG publishes new numbers.
- **Cron** Apify scheduler runs every Friday.
- **Webhooks** receive POST on completion.
- **Warehouses** pipe to BigQuery or Snowflake.

### 🌟 Beyond business use cases

**🎓 Education** Real surveillance data for epidemiology courses.

**🧪 Personal research** Track outbreaks in your canton.

**🤝 Non-profit** Power health equity dashboards.

**🧰 Tinkering** Prototype a forecasting model.

### 🤖 Ask an AI assistant about this scraper

Paste this README into ChatGPT, Claude, or any assistant.

### ❓ Frequently Asked Questions

**❓ Do I need an account** No, the BAG endpoint is public.

**❓ Which diseases are covered** All notifiable diseases in the Swiss list (mandatory reporting).

**❓ How fresh is the data** BAG updates weekly.

**❓ Is the language fixed** No, the actor accepts German, French, Italian, and English disease names.

**❓ Can I schedule runs** Yes.

**❓ Is this scraping** No, it is the official public API.

### 🔌 Integrate with any app

Apify ships native integrations with Make, Zapier, Slack, Discord, Google Drive, Google Sheets, Gmail, Airbyte, Keboola, Telegram, GitHub, and any REST endpoint or webhook.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [ParseForge GovInfo Scraper](https://apify.com/parseforge/govinfo-publications-scraper) | US federal publications. |
| [ParseForge OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database. |
| [ParseForge Alpha Vantage Scraper](https://apify.com/parseforge) | Public market data. |

> 💡 **Pro Tip** browse the complete [ParseForge collection](https://apify.com/parseforge).

***

**Disclaimer** This actor uses only publicly available data. ParseForge is not affiliated with, endorsed by, or sponsored by any of the third-party services referenced. Users are responsible for complying with the target site's terms of service and applicable law. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

# Actor input Schema

## `topic` (type: `string`):

Disease topic group

## `disease` (type: `string`):

Filter by disease key substring, e.g. covid19, gonorrhea, campylobacteriosis

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

Earliest year to include (data starts 2013).

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

Latest year to include.

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

Free users limited to 10.

## Actor input object example

```json
{
  "topic": "",
  "yearFrom": 2020,
  "yearTo": 2025,
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "yearFrom": 2020,
    "yearTo": 2025,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/swiss-bag-infectious-diseases-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 = {
    "yearFrom": 2020,
    "yearTo": 2025,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/swiss-bag-infectious-diseases-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 '{
  "yearFrom": 2020,
  "yearTo": 2025,
  "maxItems": 10
}' |
apify call parseforge/swiss-bag-infectious-diseases-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/swiss-bag-infectious-diseases-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Swiss BAG Infectious Diseases Scraper",
        "description": "Follow weekly notifiable infectious disease statistics from the Swiss Federal Office of Public Health. Each record returns the disease, week, year, canton, case count, age group, sex, hospitalizations, and deaths. Built for epidemiology research and public health monitoring.",
        "version": "0.1",
        "x-build-id": "CLRrpAjRQN9QejGwB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~swiss-bag-infectious-diseases-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-swiss-bag-infectious-diseases-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/parseforge~swiss-bag-infectious-diseases-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-swiss-bag-infectious-diseases-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/parseforge~swiss-bag-infectious-diseases-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-swiss-bag-infectious-diseases-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": {
                    "topic": {
                        "title": "Topic",
                        "enum": [
                            "",
                            "respiratory-pathogens",
                            "sti",
                            "foodborne",
                            "ticks"
                        ],
                        "type": "string",
                        "description": "Disease topic group",
                        "default": ""
                    },
                    "disease": {
                        "title": "Disease key filter",
                        "type": "string",
                        "description": "Filter by disease key substring, e.g. covid19, gonorrhea, campylobacteriosis"
                    },
                    "yearFrom": {
                        "title": "Year from",
                        "minimum": 2013,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Earliest year to include (data starts 2013)."
                    },
                    "yearTo": {
                        "title": "Year to",
                        "minimum": 2013,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Latest year to include."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users limited to 10."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```