# Swiss Pollen Data (MeteoSwiss) – Hourly & Daily Counts (`opendata-souce2026/swiss-pollen-data-meteoswiss`) Actor

Measured pollen concentrations from the official MeteoSwiss pollen network: birch, grasses, hazel, alder, ash, beech and oak at 15 Swiss stations. Hourly (live) or daily, history back to 1969. For allergy apps, health research and AI agents. CC BY 4.0.

- **URL**: https://apify.com/opendata-souce2026/swiss-pollen-data-meteoswiss.md
- **Developed by:** [Taylor Ford](https://apify.com/opendata-souce2026) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

## Swiss Pollen Data (MeteoSwiss) – Hourly & Daily Counts

Get **measured pollen concentrations from the official MeteoSwiss pollen monitoring network** – Switzerland's national pollen service – as clean JSON, CSV or Excel. **Hourly values through the day** or **daily values back to 1969**, for **15 stations** across all of Switzerland's climate and vegetation regions.

What you get, in **pollen grains per m³ of air**, for the seven allergy-relevant pollen types MeteoSwiss measures:

- 🌳 **Birch** (*Betula*), **Alder** (*Alnus*), **Hazel** (*Corylus*), **Ash** (*Fraxinus*), **Beech** (*Fagus*), **Oak** (*Quercus*)
- 🌾 **Grasses** (*Poaceae*) – the main summer allergen
- plus `totalPollen` and the **dominant pollen type** of each hour or day

Stations: **Basel, Bern, Buchs SG, La Chaux-de-Fonds, Davos, Genève, Locarno, Lausanne, Lugano, Luzern, Münsterlingen, Neuchâtel, Payerne, Sion, Zürich**. Search by name (`"Zürich"`, `"Geneva"`) or MeteoSwiss abbreviation (`"PZH"`). No API key, no scraping, no login.

These are **measurements, not a forecast**: what was actually in the air, from MeteoSwiss' automatic real-time pollen monitors.

### What can I use it for?

- 🤧 **Allergy apps, newsletters and pharmacies** – show today's live birch or grass pollen load by region, or send alerts when counts rise.
- 🏥 **Health research & epidemiology** – decades of daily pollen counts per station to correlate with hospital visits, medication sales or symptom diaries.
- 🌡️ **Climate & phenology research** – season start, peak and length of birch or grass pollen over 50+ years.
- 💊 **Pharma & retail** – time antihistamine campaigns and stock by region.
- 📊 **Dashboards & AI agents** – a reliable Swiss pollen feed; works as a tool via the Apify MCP server (*"How high is the grass pollen in Zürich right now?"*).

### Example input

Last 7 days, daily, three stations:

```json
{
  "stations": ["Zürich", "Bern", "Geneva"],
  "resolution": "daily",
  "days": 7
}
```

Live hourly birch and grass pollen, latest value per station, all stations (e.g. scheduled every hour):

```json
{
  "resolution": "hourly",
  "pollenTypes": ["birch", "grasses"],
  "latestOnly": true
}
```

History – the full birch season 2015 in Basel:

```json
{
  "stations": ["Basel"],
  "resolution": "daily",
  "startDate": "2015-03-01",
  "endDate": "2015-05-31",
  "pollenTypes": ["birch"]
}
```

### Example output

**Daily** (one row per station and day):

```json
{
  "stationAbbr": "PBS",
  "stationName": "Basel",
  "canton": "BS",
  "latitude": 47.5618,
  "longitude": 7.583931,
  "elevationM": 256,
  "resolution": "daily",
  "date": "2015-04-13",
  "dayWindowUtc": "2015-04-13 06:00 to 2015-04-14 06:00 UTC",
  "alder": 2,
  "birch": 486,
  "hazel": 0,
  "beech": 2,
  "ash": 240,
  "oak": 2,
  "grasses": 2,
  "totalPollen": 734,
  "dominantPollen": "birch",
  "dominantPollenLatin": "Betula",
  "unit": "pollen/m³"
}
```

(Real values: the birch peak of 2015 in Basel.)

**Hourly** rows have `timestampUtc` and `localTime` instead of `date`, e.g. `"timestampUtc": "2026-10-11T05:00:00.000Z"`, `"localTime": "2026-10-11 07:00"` (Europe/Zurich).

A **summary** (date window, stations, row counts, source) is saved in the key-value store under `OUTPUT`.

### Fields

| Field | Meaning |
|---|---|
| `stationAbbr`, `stationName`, `canton` | MeteoSwiss pollen station |
| `latitude`, `longitude`, `elevationM` | Station position and height above sea level |
| `date`, `dayWindowUtc` | Daily: MeteoSwiss pollen day, the mean from 06:00 UTC to 06:00 UTC the next day |
| `timestampUtc`, `localTime` | Hourly: timestamp as published by MeteoSwiss (UTC) and in your time zone |
| `alder`, `birch`, `hazel`, `beech`, `ash`, `oak`, `grasses` | Pollen concentration in pollen grains per m³ of air (`null` = not measured) |
| `totalPollen` | Sum of the returned pollen types |
| `dominantPollen`, `dominantPollenLatin` | Pollen type with the highest count (`null` when all are 0) |

### Notes

- **Seasons:** hazel and alder from about January, ash and birch in March–April, oak and beech in April–May, grasses May–August. Outside the season most values are 0 – switch on **Only rows with pollen** to skip those.
- **Daily** values are available up to yesterday (each station from its start, Basel since 1969); **hourly** values from 2023 and through today. MeteoSwiss updates the hourly values through the day, so schedule hourly runs if you want a live feed.
- Dates in the input are UTC calendar days.
- The tool reads only the MeteoSwiss files needed for your date window (small CSV files per station).

### Pricing

You pay only per row returned – no monthly fee. One week of daily values for three stations is 21 rows; the latest hourly value for all 15 stations is 15 rows. Empty results cost nothing.

### Source and license

Data: **MeteoSwiss** (Federal Office of Meteorology and Climatology), [pollen monitoring network open data](https://data.geo.admin.ch/browser/index.html#/collections/ch.meteoschweiz.ogd-pollen) from the federal geodata portal data.geo.admin.ch, published under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) (see the [MeteoSwiss open data terms of use](https://opendatadocs.meteoswiss.ch/general/terms-of-use)). Please credit "Source: MeteoSwiss" when you publish the data. This tool is independent and not affiliated with or endorsed by MeteoSwiss.

# Actor input Schema

## `stations` (type: `array`):

Pollen stations by name or MeteoSwiss abbreviation, e.g. "Zürich", "Geneva", "Bern", "PBS". Leave empty for all 15 stations: Basel, Bern, Buchs SG, La Chaux-de-Fonds, Davos, Genève, Locarno, Lausanne, Lugano, Luzern, Münsterlingen, Neuchâtel, Payerne, Sion, Zürich.

## `resolution` (type: `string`):

Daily: one row per station and day (MeteoSwiss daily mean, 06:00 to 06:00 UTC; available up to yesterday, history back to the start of each station, Basel since 1969). Hourly: one row per station and hour, updated through the day (available from 2023).

## `days` (type: `integer`):

When no start date is set: how many days back from today to return. Default 7 for daily, 1 for hourly (yesterday and today).

## `startDate` (type: `string`):

First day to return, format YYYY-MM-DD (UTC date), e.g. 2025-03-01. Overrides Days back.

## `endDate` (type: `string`):

Last day to return, format YYYY-MM-DD (UTC date). Default: today.

## `pollenTypes` (type: `array`):

Which pollen to return. Leave empty for all seven: alder, birch, hazel, beech, ash, oak, grasses.

## `onlyWithPollen` (type: `boolean`):

Skip days or hours where all selected pollen types measured 0 (useful outside the pollen season, roughly October to January).

## `latestOnly` (type: `boolean`):

Return only the most recent measurement per station, e.g. for a dashboard or an alert that runs every hour.

## `timeZone` (type: `string`):

IANA time zone used for the localTime field of hourly rows. timestampUtc is always included.

## Actor input object example

```json
{
  "stations": [
    "Zürich",
    "Bern",
    "Geneva"
  ],
  "resolution": "daily",
  "onlyWithPollen": false,
  "latestOnly": false,
  "timeZone": "Europe/Zurich"
}
```

# Actor output Schema

## `results` (type: `string`):

One row per station and day (daily) or per station and hour (hourly), in pollen grains per m³ of air.

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

Date window, stations, pollen types, row counts and source attribution.

# 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 = {
    "stations": [
        "Zürich",
        "Bern",
        "Geneva"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("opendata-souce2026/swiss-pollen-data-meteoswiss").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 = { "stations": [
        "Zürich",
        "Bern",
        "Geneva",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("opendata-souce2026/swiss-pollen-data-meteoswiss").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 '{
  "stations": [
    "Zürich",
    "Bern",
    "Geneva"
  ]
}' |
apify call opendata-souce2026/swiss-pollen-data-meteoswiss --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,opendata-souce2026/swiss-pollen-data-meteoswiss"
        }
    }
}
```

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/F0ICdh3RLHTxm0k2h/builds/hc6aJERDDwfwfkH5a/openapi.json