# Swiss Public Tenders Scraper (simap.ch) — Tenders & Awards (`publicdata/simap-swiss-public-tenders`) Actor

Scrape Swiss public tenders and contract awards from simap.ch: CPV codes, offer deadlines, award criteria with weights, buyer contacts and — for awards — the winner, awarded price and number of bids. Filter by canton, CPV, publication type and date. Official API, no login.

- **URL**: https://apify.com/publicdata/simap-swiss-public-tenders.md
- **Developed by:** [Riccardo](https://apify.com/publicdata) (community)
- **Categories:** Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/platform/actors/running/actors-in-store#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

## Swiss Public Tenders (simap.ch) — search, monitor & export

**Stop refreshing simap.ch by hand: every Swiss tender matching your cantons and CPV codes arrives as a structured feed — and for contracts already decided, you get the awarded price, how many bids came in, and the award criteria with their exact weights.**

simap.ch is the official gazette for Swiss public procurement: the Confederation, all 26 cantons and the municipalities publish there, around 1,000 tender publications a month plus the awards that follow. The site shows one publication at a time; this Actor turns the same public data into a dataset you can filter, schedule and pipe anywhere — JSON export, CSV or Excel.

### What you get

Around 38 fields per publication, in the language you ask for (IT/DE/FR/EN, with fallback to the other official languages; raw translations stay in `translations`).

**Award data that is rarely exported in bulk:**

- **`winnerPrice` and `winnerCurrency`** — the amount the contract was actually awarded for (e.g. `616666.6` CHF), not an estimate
- **`award.numberOfSubmissions`** — how many bidders you were up against
- **`awardCriteria` with `weighting` and `maxPoints`** — e.g. Price 70 %, References 30 %, with `isPriceCriterion` separating price from quality
- `winnerName`, the ranked `award.vendors` list, the decision date and justification, and `referencedTender` linking the Zuschlag back to its tender

**Deadlines that decide whether you can still bid:** **`offerDeadline`** (ISO 8601 with timezone), `qnaDeadline` for questions to the buyer, `offerOpening`, `offerValidityUntil`, `documentsAvailableFrom`.

**Who is buying, where, and what:**

- `buyerName` plus a `buyer` contact block (address, e-mail, phone, city, canton), and `recipient`, where offers must be sent
- `canton`, `city`, `postalCode`, `country` of the place of performance
- `cpvCode` with readable `cpvLabel`, `orderType` (supply / service / construction), `processType` (open, selective, invitation, direct)
- `title`, plain-text `description`, `qualificationCriteria`, `lotsDetailed` for multi-lot projects
- `stateContractArea` (WTO/GPA treaty scope) and `publicationTed` (also in the EU journal TED)

**Identifiers and provenance:** `projectNumber` (stable across all publications of one project), `publicationNumber`, `projectId`, `publicationId`, `pubType`, `publicationDate`, the `simapUrl` deep link, `source` and the mandatory `disclaimer`.

### Who uses this

- A **bid manager** watches three cantons and two CPV branches, and sees new tenders the morning they appear.
- A **sales lead** pulls a year of awards to see which competitor wins at which Zuschlagspreis, against how many bidders, before pricing the next offer.
- A **bid-strategy analyst** reads the criteria weights first: 70 % price and 30 % references call for two different documents.
- A **compliance officer or researcher** keeps a dated, unaltered record of what each body published, or builds multi-year procurement statistics.
- An **AI agent** calls this Actor as an MCP tool to answer "which public tenders in Switzerland close in the next 14 days for CPV 72000000?".

### Example output

A tender (shortened):

```json
{
  "projectNumber": "42601",
  "pubType": "tender",
  "publicationDate": "2026-08-19",
  "title": "Concorso per la fornitura di tre carburanti di aviazione",
  "buyerName": "Aeroporto cantonale di Locarno",
  "canton": "TI",
  "city": "Gordola",
  "cpvCode": "09100000",
  "cpvLabel": "Combustibili",
  "processType": "open",
  "offerDeadline": "2026-10-12T12:00:00+02:00",
  "qnaDeadline": "2026-09-23",
  "awardCriteria": [
    { "title": "Prezzo", "weighting": 70, "maxPoints": 6, "isPriceCriterion": true }
  ],
  "buyer": {
    "name": "Aeroporto cantonale di Locarno",
    "email": "dt-sg.ud@ti.ch",
    "phone": "+41918142625",
    "city": "Gordola",
    "canton": "TI"
  },
  "simapUrl": "https://www.simap.ch/it/project-detail/93027c93-e1c9-4b7d-99db-c974e735ba8b",
  "source": "simap.ch",
  "disclaimer": "Dies ist keine amtliche Veröffentlichung. Massgebend ist die auf simap.ch publizierte Version."
}
```

An award (shortened) — the part other sources leave out:

```json
{
  "projectNumber": "24563",
  "pubType": "award",
  "winnerName": "Edilstrada SA",
  "winnerPrice": 616666.6,
  "winnerCurrency": "CHF",
  "source": "simap.ch"
}
```

### Input

| Field | What it does |
|---|---|
| `search` | Full-text query: keyword, project number, buyer name. Quotes = exact phrase. Empty = all filter matches. |
| `publicationTypes` | Default `["tender"]`. Use `["award_tender"]` for who won what. |
| `cantons` | Canton codes of the place of performance, e.g. `["TI","ZH","GE"]`. Empty = all of Switzerland. |
| `cpvCodes` | CPV codes, prefix-matched, e.g. `45000000` construction, `72000000` IT services. |
| `publishedFrom` / `publishedUntil` | Date window, `YYYY-MM-DD`. Default from = 30 days ago. |
| `onlySwitzerland` | Exclude projects performed abroad. Default `true`. |
| `language` | Preferred language for text fields: `it`, `de`, `fr`, `en`. Default `it`. |
| `includeDetails` | Adds description, CPV label, deadlines, weighted award criteria, qualification criteria, contact, lots. Default `true`. |
| `stripHtml` | Rich text converted to plain text. Default `true`. |
| `maxItems` | Safety cap. Default `200`, `0` = no limit. |

Every open IT-services tender in Zurich and Bern published since 1 August, texts in German:

```json
{
  "publicationTypes": ["tender"],
  "cantons": ["ZH", "BE"],
  "cpvCodes": ["72000000"],
  "publishedFrom": "2026-08-01",
  "language": "de"
}
```

Competitor intelligence: every Zuschlag in Ticino this year, with winner, price and bid count:

```json
{
  "publicationTypes": ["award_tender"],
  "cantons": ["TI"],
  "publishedFrom": "2026-01-01",
  "language": "it",
  "maxItems": 0
}
```

### Run it on a schedule

To monitor new Swiss tenders daily, save your filters as a Task, leave `publishedFrom` empty so each run covers the last 30 days, and schedule it. Attach an Apify integration to the dataset and results go straight to **Google Sheets, Slack, e-mail, a webhook, Make or Zapier** — no code in between. Many teams run one task per canton or CPV branch so each alert reaches the right person.

If you keep history, deduplicate on **`publicationId`**, unique per publication, or on `publicationNumber`. Group a tender with its later award using `projectNumber`.

### Use it from code or from an AI agent

Developers start runs and read results through the Apify API or CLI in any language; the dataset comes back as JSON, CSV, Excel or XML. The Actor is also exposed as an **MCP tool** via the Apify MCP server, so an AI agent can call it directly — every input field carries a description written for that purpose.

### Pricing

Pay per event: a small fee for each publication exported, shown in the pricing box on this page. Platform usage is negligible because this tender scraper uses simap's public REST API only — no browser, no proxies, no captcha, no login. A hundred publications with full details take roughly 30 seconds, politely rate-limited with retries.

### Where the data comes from

Data comes from the public simap.ch API. simap's terms (AGB §4) permit API users to obtain publication data for commercial purposes and pass it to third parties unaltered and visually separated from any commentary, carrying this notice — which ships in the `disclaimer` field of every record:

> *Dies ist keine amtliche Veröffentlichung. Massgebend ist die auf simap.ch publizierte Version.* — This is not an official publication; the version published on simap.ch prevails.

Honest limits. Tender **documents (PDFs) are not downloaded** — they stay the intellectual property of the contracting authorities, so you get publication metadata and texts, not the specification files. Publications appear as simap publishes them: daily, not real-time. Coverage is whatever a body chooses to publish; below-threshold invitation and direct awards are largely unpublished. Award fields exist only on award publications, and buyers sometimes omit an optional field. This Actor is independent and not affiliated with the simap.ch association.

### Related Actors

Same engine, same official-source approach:

- [**AusTender (Australia)**](https://apify.com/publicdata/austender-australian-government-contracts) — federal contracts, winners and expiry dates
- [**UK Public Tenders**](https://apify.com/publicdata/uk-contracts-finder-find-a-tender) — Contracts Finder and Find a Tender in one run
- [**Swiss Commercial Register (SHAB)** — new companies, changes, deletions and bankruptcies](https://apify.com/publicdata/shab-swiss-company-gazette)
- [**EU Tenders (TED)** — European procurement notices and contract awards](https://apify.com/publicdata/ted-eu-public-tenders)
- [**France Company Register** — SIREN/SIRET, executives, official labels](https://apify.com/publicdata/france-company-register-scraper)
- [**GLEIF LEI** — LEI lookup, lapsed-LEI screening, parent companies](https://apify.com/publicdata/gleif-lei-scraper)
- [**Brazil CNPJ** — Receita Federal company data and partners](https://apify.com/publicdata/brazil-cnpj-lookup)

# Actor input Schema

## `search` (type: `string`):

Full-text query (keyword, project number, buyer name). Leave empty to list everything matching the filters. Tip: use quotes for exact phrases, e.g. "42601".

## `publicationTypes` (type: `array`):

Which publication types to return. Default: open tenders only. 'award\_tender' gives who won what (useful for competitor intelligence).

## `cantons` (type: `array`):

Two-letter canton codes, e.g. TI, ZH, GE. Empty = all of Switzerland.

## `cpvCodes` (type: `array`):

Common Procurement Vocabulary codes to filter by (e.g. 45000000 construction, 72000000 IT services). Prefix matching is done by simap.

## `publishedFrom` (type: `string`):

Only publications whose newest publication date is on/after this day. Default: 30 days ago.

## `publishedUntil` (type: `string`):

Only publications on/before this day.

## `onlySwitzerland` (type: `boolean`):

Exclude projects whose place of performance is abroad.

## `language` (type: `string`):

Titles/descriptions are returned in this language when available, with automatic fallback to the other official languages. All raw translations are kept in the 'translations' field.

## `includeDetails` (type: `boolean`):

Adds description, CPV label, offer deadline, Q\&A deadline, award criteria with weights, qualification criteria, buyer contact, lots. One extra request per publication (still fast: ~5/s).

## `stripHtml` (type: `boolean`):

Convert rich-text fields to plain text.

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

Stop after this many publications (safety cap). 0 = no limit.

## Actor input object example

```json
{
  "publicationTypes": [
    "tender"
  ],
  "cantons": [
    "TI"
  ],
  "onlySwitzerland": true,
  "language": "it",
  "includeDetails": true,
  "stripHtml": true,
  "maxItems": 200
}
```

# Actor output Schema

## `dataset` (type: `string`):

Tenders and awards from simap.ch. Every exported row is one item in the default dataset.

# 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 = {
    "search": "",
    "publicationTypes": [
        "tender"
    ],
    "cantons": [
        "TI"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicdata/simap-swiss-public-tenders").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 = {
    "search": "",
    "publicationTypes": ["tender"],
    "cantons": ["TI"],
}

# Run the Actor and wait for it to finish
run = client.actor("publicdata/simap-swiss-public-tenders").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 '{
  "search": "",
  "publicationTypes": [
    "tender"
  ],
  "cantons": [
    "TI"
  ]
}' |
apify call publicdata/simap-swiss-public-tenders --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,publicdata/simap-swiss-public-tenders"
        }
    }
}

```

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/nm2hQBphfU8wWlFa2/builds/SrTPm5uO35wjeta5Y/openapi.json