# Swiss Type-Approval Master (TAS) + eTAN Crosswalk (`rastriq/swiss-type-approval-master`) Actor

Every Swiss vehicle type approval (cars, motorcycles, trailers) from ASTRA open data, with the EU type-approval number (eTAN) crosswalk, WLTP emissions and a change history the source does not keep.

- **URL**: https://apify.com/rastriq/swiss-type-approval-master.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** Business, Automation, Other
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 type approval returneds

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/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 Type-Approval Master (TAS) – eTAN crosswalk, WLTP emissions & change history

**Swiss Type-Approval Master (TAS)** turns the Swiss Federal Roads Office (ASTRA/FEDRO) open-data files into one clean, flat table of **Swiss type approval data**: every Swiss vehicle type approval for cars, motorcycles and trailers, with the **EU type-approval number (eTAN)**, WLTP emissions and – the part the source does not give you – a **change history**.

ASTRA publishes the TAS files once a month and **overwrites them in place**: the previous version of an approval is not kept. Swiss Type-Approval Master keeps that history for you. Run it on a schedule in *Delta* mode and every run returns only the approvals that are new, changed or removed, with `changed_fields` and the `previous_values` the source no longer shows.

> Rastriq – data infrastructure for official registers. Not affiliated with ASTRA/FEDRO.

### Use cases: what can you do with Swiss type approval data?

**1. EU-to-Swiss crosswalk and entity matching** - *OEM compliance, importers and data teams.*
Join Swiss approvals to certificates of conformity, KBA registration data or EEA CO2 monitoring on the EU type-approval number. Use `eu_type_approval_number` (normalised, e.g. `e4*2007/46-195/2013*0667`) together with `eu_tan_base`, `eu_tan_authority_code` and the extension range `eu_tan_ext_from` / `eu_tan_ext_to`. You get one key that links the Swiss and EU worlds. About 17.6 % of cars have no eTAN in the source and carry the flag `no_etan`, so you know which rows cannot be matched.

**2. Spare-parts catalogue and fitment data** - *aftermarket parts distributors and e-commerce catalogues.*
Map parts to vehicles by type, engine and power. Take `make_name_norm`, `commercial_name_norm`, `type`, `variant`, `version`, `engine_capacity_cc`, `max_net_power_kw`, `fuel_type` and `ch_vin_prefix` for the makes you sell parts for (`makes` filter). You get a fitment table that is refreshed monthly, with only the changed types in `delta` mode.

**3. Insurance and leasing: valuation and risk by version** - *insurers, leasing and fleet-finance analysts.*
Rate vehicles at version level rather than model level: `max_net_power_kw`, `co2_wltp`, `fuel_type`, `mass_empty_min_kg`, `mass_empty_max_kg`, `drive_type` and `date_of_approval`. Run a `snapshot` of automobile with `outputLevel: "type"` and join your policy or contract data on `make_name_norm` + `commercial_name_norm`. You get a power, mass and CO2 profile for every approved version.

**4. Importers and parallel imports into Switzerland** - *importers and homologation consultants.*
Before you bring a model in, check whether a Swiss approval exists and how it relates to the EU type. Filter by `makes`, then read `eu_type_approval_number`, `date_of_approval`, `date_of_approval_expiry`, `cancelation_date` and `reason_of_cancelation`; the flag `cancelled` marks withdrawn approvals. You get a quick, documented answer on which versions are approved and which are no longer valid.

**5. Vehicle master data and VIN decoding** - *vehicle data providers, marketplaces and fleet software.*
Build or refresh a master table: `ch_vin_prefix` and `vin_wmi` for VIN matching, `body_form_code`, `vehicle_category_code` (M1, N1...), `manufacturer_name_address`, plus engine and mass fields. Schedule `delta` monthly: you receive only new, changed and withdrawn types instead of re-ingesting 211,000 rows.

**6. CO2 and emissions audits, CO2-based taxation** - *environment, fleet and tax teams.*
Use `co2_wltp`, `co2_wltp_min`, `co2_wltp_max`, `fuel_consumption_wltp`, `electric_range_wltp_from_km` and `euro_level` to check what a vehicle emits. Switch to `outputLevel: "type_gearbox"` when CO2 depends on the transmission (`gearbox_type`). The flags `outlier`, `no_emission_data` and `no_emission_values` show which rows you should not trust.

**7. The change history ASTRA overwrites** - *regulatory monitoring and market analysts.*
ASTRA replaces its files each month. In `delta` mode every changed approval comes with `changed_fields` (e.g. `max_net_power_kw`, `euro_level`) and `previous_values` with the old values, and withdrawn approvals arrive as `removed`. You get an audit trail of when a version's power, CO2 or approval status changed, which ASTRA does not offer.

#### Recipe 1: monthly change monitor for selected makes

Schedule on day 1 and day 5 of each month. The first run is a full `baseline`; later runs return only new, changed and removed approvals for these makes.

```json
{
  "mode": "delta",
  "vehicleGroups": ["automobile"],
  "makes": ["Tesla", "BYD", "Polestar"],
  "includeEmissions": true,
  "outputLevel": "type",
  "maxItems": 0
}
```

#### Recipe 2: CO2 audit by gearbox variant

One row per approval and gearbox variant, with WLTP emissions, for a CO2 or tax review of specific makes.

```json
{
  "mode": "snapshot",
  "vehicleGroups": ["automobile"],
  "makes": ["Volkswagen", "Skoda"],
  "includeEmissions": true,
  "outputLevel": "type_gearbox",
  "maxItems": 0
}
```

### Why the history matters

| Source (ASTRA) | Swiss Type-Approval Master |
|---|---|
| Overwrites approvals each month; previous values are gone | Stores a comparable record per approval and compares it on every run |
| No change flag | `change_type`: `baseline`, `new`, `changed`, `unchanged`, `removed` |
| – | `changed_fields` (e.g. `["max_net_power_kw","euro_level"]`) and `previous_values` (e.g. `{"max_net_power_kw": 200.0}`) |
| 340 MB + 90 MB CSV files | Skips the download entirely (`source_unchanged`, a few seconds, no results charged) when ASTRA has not published anything new |

History starts the first time **you** run the actor: the first Delta run is a full `baseline`, every later run shows what changed since the previous one. Use the same *State key* (or the same filters) to keep one stream.

### How to use Swiss Type-Approval Master

1. **Try it:** keep the pre-filled input (`snapshot`, automobiles, make *Tesla*, max 100 rows) and click **Start**. The actor reads the full source file for the chosen vehicle groups (about 450 MB, a few minutes) and returns up to 100 rows. Filters only decide which rows are returned.
2. **Get the whole table once:** set *Mode* to **Delta** (or Snapshot), leave *Makes* empty and *Max items* at 0. The first run returns everything as `baseline`.
3. **Monitor monthly:** schedule the same input on day 1 of every month (and again on day 5, because ASTRA sometimes publishes late). Runs where nothing changed finish in seconds and cost only the start fee.
4. **Instant bulk copy:** *Preloaded* returns the latest full snapshot prepared by Rastriq without any waiting, at a lower price per row (no change history). At launch, if that snapshot is not published yet, the run falls back to the live snapshot mode and is billed as `type-approval`.

#### Input

| Field | Description |
|---|---|
| `mode` | `snapshot` (all approvals in scope, each flagged against your last run), `delta` (default when empty: only new / changed / removed; first run = full `baseline`), `preloaded` (ready-made latest snapshot). |
| `vehicleGroups` | `automobile` (about 211,000 approvals), `motorcycle`, `trailer`. Default: automobile. |
| `makes` | Optional list of makes. Matching ignores case, accents and punctuation (`mercedes-benz` = `MERCEDES BENZ`); it is an exact make name, not "contains". Makes that match nothing are reported in the run summary. |
| `includeEmissions` | Join the WLTP emissions file (default `true`). |
| `outputLevel` | `type` (one row per approval, default) or `type_gearbox` (one row per approval and gearbox variant). |
| `maxItems` | Stop after N rows (0 = no limit). A truncated first run does not save state. |
| `stateKey` | Name of your delta stream. By default derived from groups, makes, emissions flag and output level, so different filters keep separate histories. |

#### How emissions are aggregated

ASTRA publishes one emission row per gearbox variant. At `outputLevel = type` the row with the **lowest WLTP CO2** is used for `co2_wltp`, `fuel_consumption_wltp`, `euro_level`…, together with `co2_wltp_min`, `co2_wltp_max`, `gearbox_count` and `gearbox_types`. Electric vehicles use the lowest electric consumption; older approvals without WLTP fall back to the NEDC values (`co2_nedc`). At `type_gearbox` each variant is its own row (`record_key` = `1TE101|2`).

### Swiss Type-Approval Master output fields

One flat row per Swiss approval (or approval + gearbox). Main fields:

| Group | Fields |
|---|---|
| Keys | `record_key`, `ch_type_approval_number`, `eu_type_approval_number`, `eu_type_approval_number_raw`, `eu_tan_base`, `eu_tan_authority_code`, `eu_tan_ext_from`, `eu_tan_ext_to`, `ch_vin_prefix`, `vin_wmi`, `make_name_norm`, `commercial_name_norm` |
| Vehicle | `vehicle_group`, `vehicle_category_code` (M1, N1…), `make_code`, `make_name`, `commercial_name`, `type`, `variant`, `version`, `body_form_code`, `manufacturer_name_address` |
| Engine | `fuel_type` (ASTRA code), `working_principle`, `plug_in_hybrid` (ASTRA's off-vehicle-charging index; null for pure electric, only meaningful for hybrids), `engine_capacity_cc`, `max_net_power_kw`, `number_of_cylinders`, `drive_type`, masses: `mass_empty_min_kg` / `mass_empty_max_kg`, `max_laden_mass_min_kg` (almost always filled) and `max_laden_mass_kg` (upper bound, filled for about a third of cars) |
| Emissions | `co2_wltp`, `co2_wltp_min`, `co2_wltp_max`, `fuel_consumption_wltp`, `electric_consumption_wltp`, `electric_range_wltp_from_km` / `_to_km`, `co2_nedc`, `euro_level`, `gearbox_type`, `gearbox_types` |
| Lifecycle | `version_no`, `date_of_approval`, `date_of_last_change`, `cancelation_date`, `date_of_approval_expiry` |
| History | `change_type`, `changed_fields`, `previous_values`, `first_seen_at`, `last_seen_at`, `source_file`, `source_url`, `source_updated_at` |
| Quality | `quality_flags` |

`make_name_norm` / `commercial_name_norm` are upper-cased, accent-free, alphanumeric-only versions of the make and model names, meant for fuzzy joins with other portals. `vin_wmi` is the first 3 characters of the VIN prefix when they are not wildcards.

`change_type` is one of `baseline`, `new`, `changed`, `unchanged`, `removed` (`preloaded` in Preloaded mode).

`quality_flags` mark, never filter: `no_etan`, `invalid_etan_format`, `invalid_ch_number`, `outlier` (power outside 1–1500 kW or WLTP CO2 outside 0–600 g/km), `no_emission_data` (no row in the emissions file), `no_emission_values` (row without CO2/consumption values), `cancelled`. About 17.6 % of cars (37,202 of 211,485) have no EU type-approval number in the source and get `no_etan`.

#### Example row (shortened)

```json
{
  "record_key": "1TD501",
  "ch_type_approval_number": "1TD501",
  "vehicle_group": "automobile",
  "vehicle_category_code": "M1",
  "make_name": "TESLA",
  "commercial_name": "Model S 60",
  "eu_type_approval_number": "e4*2007/46-195/2013*0667",
  "eu_tan_authority_code": "e4",
  "eu_tan_ext_from": "00",
  "eu_tan_ext_to": "02",
  "ch_vin_prefix": "5YJSA2.G........., 5YJSA..1.........",
  "fuel_type": "E",
  "max_net_power_kw": 285.0,
  "change_type": "baseline",
  "changed_fields": [],
  "previous_values": null,
  "quality_flags": ["no_emission_values"]
}
```

In later Delta runs a modified approval carries the change instead (structure only, values are illustrative):

```json
{ "change_type": "changed", "changed_fields": ["max_net_power_kw", "euro_level"],
  "previous_values": { "max_net_power_kw": 200.0, "euro_level": "B6d" } }
```

### Swiss Type-Approval Master input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `delta` when empty (pre-filled: `snapshot`) | `snapshot`, `delta` or `preloaded`. |
| `vehicleGroups` | array of strings | automobile (pre-filled: `["automobile"]`) | `automobile` (about 211,000 approvals, 354 MB file), `motorcycle`, `trailer`. |
| `makes` | array of strings | empty = all makes (pre-filled: `["Tesla"]`) | Exact make names, matched ignoring case, accents and punctuation. |
| `includeEmissions` | boolean | `true` | Join the ASTRA emissions file by Swiss approval number. Switch off to skip about 90 MB of download. |
| `outputLevel` | string | `type` | `type` (one row per approval) or `type_gearbox` (one row per approval and gearbox variant; requires emissions). |
| `maxItems` | integer (min 0) | `0` = no limit (pre-filled: `100`) | Stop after this many rows. A truncated first run does not save state. |
| `stateKey` | string | empty | Name of your delta stream. |
| `allowMassChange` | boolean | `false` | Delta safety net: allows runs where more than 10% of approvals changed (see Safety nets). |

Pre-filled input (Tesla automobiles, 100 rows):

```json
{"mode": "snapshot", "vehicleGroups": ["automobile"], "makes": ["Tesla"], "includeEmissions": true, "outputLevel": "type", "maxItems": 100}
```

Motorcycles of one make, full snapshot:

```json
{"mode": "snapshot", "vehicleGroups": ["motorcycle"], "makes": ["BMW"], "maxItems": 0}
```

### Real example record: motorcycle approval without eTAN

A real motorcycle row (shortened), as returned by the first run. Older approvals can have no EU type-approval number or WLTP data: `eu_type_approval_number` and `co2_wltp` are `null` here and the row carries the flag `no_etan`.

```json
{
  "record_key": "6BA301",
  "ch_type_approval_number": "6BA301",
  "vehicle_group": "motorcycle",
  "output_level": "type",
  "version_no": 0,
  "vehicle_type": "Motorrad",
  "make_code": "4012",
  "make_name": "BMW",
  "commercial_name": "R850R",
  "type": "BMW259",
  "ch_vin_prefix": ".......R850R, WB10401..........",
  "eu_type_approval_number": null,
  "manufacturer_name_address": "BMW BAYERISCHE MOTOREN WERKE AG, D-80788 MUENCHEN",
  "fuel_type": "B",
  "working_principle": "Boxer",
  "engine_capacity_cc": 848,
  "max_net_power_kw": 52,
  "number_of_cylinders": 2,
  "mass_empty_min_kg": 310,
  "max_laden_mass_min_kg": 450,
  "date_of_approval": "1996-10-14",
  "date_of_approval_expiry": "2003-09-30",
  "co2_wltp": null,
  "make_name_norm": "BMW",
  "commercial_name_norm": "R850R",
  "source_file": "TAS_Motorrad.csv",
  "source_updated_at": "2026-09-29T11:16:27Z",
  "change_type": "baseline",
  "changed_fields": [],
  "previous_values": null,
  "quality_flags": [
    "no_etan"
  ]
}
```

### How much does it cost to use Swiss Type-Approval Master?

Swiss Type-Approval Master uses pay-per-event pricing. Prices per 1,000 events on the BRONZE tier:

| Event | Price |
|---|---|
| `actor-start` | $0.01 per run (4 GB memory, 4 x $0.0025) |
| `type-approval` (snapshot rows and the first `baseline`) | $1.00 per 1,000 rows |
| `type-approval-change` (delta rows: new / changed / removed) | $3.00 per 1,000 rows |
| `type-approval-preloaded` (row of the ready-made snapshot) | $0.50 per 1,000 rows |

Apify plan discounts apply to these prices: Free plan +15 %, Silver -15 %, Gold / Platinum / Diamond -30 %.

**Real-cost examples**

- **Complete automobile baseline:** about 211,500 rows is roughly **$211** (about **$106** as `preloaded`).
- **One make:** the whole source is read either way, but you only pay for the rows you return, so a single make costs a few dollars.
- **Monthly delta:** you pay only for the changed rows, plus the start fee.
- **ASTRA has published nothing new:** the run finishes in seconds with **no per-row charge**, only the Actor start fee.

**Worked example (BRONZE tier):** a 1,000-row snapshot or first baseline is 1,000 x $0.001 = $1.00, plus the Actor start (4 GB = 4 x $0.0025 = $0.01): **$1.01**. A monthly delta that returns 200 changed approvals is 200 x $0.003 = $0.60 plus $0.01: **$0.61**. The same 1,000 rows as `preloaded` cost 1,000 x $0.0005 = $0.50 plus $0.01: $0.51.

Filter by make or use `maxItems` while you test.

### Safety nets

- **Count drop:** if the number of approvals falls more than 2 % against your saved state (or automobiles fall below 190,000), a Delta run stops with `source_anomaly`, emits nothing, keeps your state and never reports mass removals. A Snapshot run still returns the rows but without removals and does not save state.
- **Mass change:** in Delta mode, if more than 10 % of the approvals are new / changed / removed, or the emissions-join coverage drops by more than 5 points, the run stops with status `mass_change` and keeps your state. Tick *Allow mass changes* once you have checked that ASTRA really changed that much.
- **Different configuration, same State key:** if you reuse a State key with other vehicle groups, emissions setting or output level, the old state is not comparable; the run starts a new `baseline` (and says so in the run summary) instead of reporting everything as changed. The make filter always has its own history.
- **Format changes:** missing key columns in the ASTRA files stop the run before anything is returned.

### Data source, licence and attribution

Data: Swiss Federal Roads Office (FEDRO / ASTRA), *Typengenehmigungen TAS*, published as open data at `opendata.astra.admin.ch`, availability "Freely available (open data)", update frequency **monthly**. Please credit "Source: FEDRO/ASTRA, TAS open data" when you republish. ASTRA does not disclose the holder of a type approval; the manufacturer name and address are those of the vehicle manufacturer. Swiss Type-Approval Master adds normalisation, the emission join, quality flags and the change history; it is not an official ASTRA service.

### FAQ

**Is it legal to use this data?** ASTRA publishes the TAS files as open data. The files describe vehicle types, not persons. Keep the attribution above and check ASTRA's terms for your specific use.

**How often does the data change?** ASTRA updates monthly (the last publication seen while building this actor was 29 September 2026). Schedule the actor on day 1 and day 5.

**What does `fuel_type` mean?** The actor keeps ASTRA's own fuel codes (for example `B`, `D`, `E`); ASTRA does not publish the code table with the open data, so they are not translated.

**Why are some `eu_type_approval_number` values empty?** Older Swiss approvals pre-date the EU numbering or ASTRA did not record it; those rows get the `no_etan` flag.

**Does it need proxies or a browser?** No. Plain HTTP; the source file downloads take a few minutes.

**Something looks wrong?** Open an issue from the Actor page; include the `ch_type_approval_number`.

**How do I keep the cost down?** Filter by `makes`, set `maxItems` for tests, and use *Delta* for repeat runs: unchanged approvals are free, and a run where ASTRA published nothing new costs only the start fee.

### Related Rastriq actors

- [AutoScout24 Scraper](https://apify.com/rastriq/autoscout24-scraper) - European car listings.
- [Mobile.de Scraper](https://apify.com/rastriq/mobile-de-scraper) - Germany car marketplace.
- [Ford Europe Car Prices & Trims Scraper](https://apify.com/rastriq/ford-europe-car-prices) - Ford prices and trims in Europe.

# Changelog

This Actor's version history is a separate document: https://apify.com/rastriq/swiss-type-approval-master/changelog.md

# Actor input Schema

## `mode` (type: `string`):

<b>Snapshot</b>: every approval in scope, flagged new / changed / unchanged / removed against your last run. <b>Delta</b> (default when empty): only what changed; the first run is a full <code>baseline</code>. <b>Preloaded</b>: instant, cheaper copy of the latest full snapshot published by the author (no change history).

## `vehicleGroups` (type: `array`):

Which ASTRA files to process. Automobiles is about 211,000 approvals (354 MB file); motorcycles and trailers are small. Empty = automobiles.

## `makes` (type: `array`):

Optional. Match on the make name ignoring case, accents and punctuation (<code>mercedes-benz</code> = <code>MERCEDES BENZ</code>). Exact name, not 'contains'. Empty = all makes. Makes that match nothing are listed in the run summary.

## `includeEmissions` (type: `boolean`):

Joins the ASTRA emissions file by Swiss approval number (CO2, consumption, electric consumption and range, Euro level, gearbox variants). Turn off to skip about 90 MB of download.

## `outputLevel` (type: `string`):

<b>Type</b>: one row per Swiss approval number, with the lowest-CO2 WLTP row plus min/max range across gearbox variants. <b>Type + gearbox</b>: one row per approval and gearbox variant (requires emissions).

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

Stop after this many rows (0 = no limit). A truncated first run does not save state.

## `stateKey` (type: `string`):

Name of your delta stream. Runs sharing the same key compare against each other. By default the stream is derived from groups, makes, emissions and output level, so different filters keep separate histories.

## `allowMassChange` (type: `boolean`):

Delta safety net: if more than 10% of the approvals are new / changed / removed, or the emissions join coverage drops by more than 5 points, the run stops with status <code>mass_change</code>, emits nothing and keeps your state. Tick this only after checking the source really changed that much.

## Actor input object example

```json
{
  "mode": "snapshot",
  "vehicleGroups": [
    "automobile"
  ],
  "makes": [
    "Tesla"
  ],
  "includeEmissions": true,
  "outputLevel": "type",
  "maxItems": 100,
  "allowMassChange": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `changes` (type: `string`):

No description

## `runSummary` (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 = {
    "mode": "snapshot",
    "vehicleGroups": [
        "automobile"
    ],
    "makes": [
        "Tesla"
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/swiss-type-approval-master").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 = {
    "mode": "snapshot",
    "vehicleGroups": ["automobile"],
    "makes": ["Tesla"],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/swiss-type-approval-master").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 '{
  "mode": "snapshot",
  "vehicleGroups": [
    "automobile"
  ],
  "makes": [
    "Tesla"
  ],
  "maxItems": 100
}' |
apify call rastriq/swiss-type-approval-master --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rastriq/swiss-type-approval-master"
        }
    }
}
```

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/qHVen4MosaArfdd9t/builds/7j9biH837kKebPoBG/openapi.json