# Zefix Swiss Company Registry Scraper (`automation-lab/zefix-swiss-company-registry-scraper`) Actor

🇨🇭 Extract official Swiss company registry records from Zefix by company name, UID, or EHRAID with legal forms and SHAB events.

- **URL**: https://apify.com/automation-lab/zefix-swiss-company-registry-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.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.
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

## Zefix Swiss Company Registry Scraper

Extract official Swiss company registry data from Zefix by company name, UID, or EHRAID.

The actor uses public Zefix REST endpoints and saves structured company records to an Apify dataset.

### What does Zefix Swiss Company Registry Scraper do?

Zefix Swiss Company Registry Scraper searches the official Swiss company registry and returns clean registry records.

It can search by company term, Swiss UID, or direct Zefix EHRAID.

It can also fetch detail pages to include company purpose, translations, and SHAB publication events.

Use it when you need official Swiss company identifiers and registry metadata in a repeatable export.

### Who is it for?

Compliance teams can verify Swiss companies before onboarding suppliers or customers.

KYB teams can enrich lead lists with UIDs, legal forms, legal seats, and registry status.

Sales operations teams can turn company-name lists into structured Swiss registry records.

Data teams can schedule regular registry checks and export results through Apify integrations.

Researchers can collect public company metadata without manually copying Zefix pages.

### Why use this actor?

- ✅ Official public Zefix registry source
- ✅ HTTP-only implementation with no browser overhead
- ✅ Search by name, UID, or EHRAID
- ✅ Optional detail enrichment
- ✅ SHAB publication rows included as structured arrays
- ✅ Legal-form names resolved into readable English/German/French/Italian labels
- ✅ Dataset export works with JSON, CSV, Excel, API, webhooks, and integrations

### Data you can extract

| Field | Description |
| --- | --- |
| `name` | Registered company or organization name |
| `uidFormatted` | Swiss UID in formatted CHE style |
| `uid` | Raw UID value |
| `chidFormatted` | Formatted commercial register ID |
| `ehraid` | Zefix firm identifier |
| `legalFormName` | Resolved legal form such as Foundation or Corporation |
| `legalSeat` | Registered legal seat municipality |
| `registryOfficeCanton` | Canton from SHAB publication data when available |
| `status` | Zefix registry status |
| `shabDate` | Latest SHAB publication date |
| `deleteDate` | Deletion date if the firm is deleted |
| `cantonalExcerptUrl` | Public cantonal excerpt link |
| `translations` | Alternate registered names |
| `purpose` | Company purpose from the detail endpoint |
| `shabPublications` | Recent SHAB rows and mutation types |
| `sourceUrl` | Public REST source URL |
| `scrapedAt` | Timestamp when the record was saved |

### How much does it cost to scrape Swiss company registry records?

This actor uses pay-per-event pricing: a small one-time start fee plus one charge for each saved company record.

| Charge event | When it is charged | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Start | Once per run | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Company extracted | Per company saved | $0.00004578 | $0.000039809 | $0.000031051 | $0.000023885 | $0.000015924 | $0.000011146 |

Example BRONZE costs before Apify platform fees:

| Run size | Example charges | Estimated cost |
| --- | --- | ---: |
| First test run with 10 records | $0.005 start + 10 × $0.000039809 | ~$0.0054 |
| 100 records | $0.005 start + 100 × $0.000039809 | ~$0.0090 |
| 1,000 records | $0.005 start + 1,000 × $0.000039809 | ~$0.0448 |

On the FREE tier, a 10-record test run is about $0.0055, so a small validation run stays well under one cent before any Apify subscription/platform charges.

### How to use the actor

1. Open the actor on Apify.
2. Add company search terms such as `Nestle` or `Novartis`.
3. Optionally add UIDs such as `CHE-107.028.276`.
4. Optionally add direct EHRAIDs such as `284234`.
5. Set `maxResults` to control output volume.
6. Keep `includeDetails` enabled for purpose and SHAB events.
7. Run the actor.
8. Download the dataset as JSON, CSV, Excel, or via API.

### Input options

#### Company search terms

Use `searchTerms` for company names, brands, or free-text Zefix queries.

Example:

```json
{
  "searchTerms": ["Nestle", "Novartis"],
  "maxResults": 25
}
````

#### Swiss UID values

Use `uids` for known Swiss UID values.

The actor sends the UID through the public Zefix search endpoint.

Example:

```json
{
  "uids": ["CHE-107.028.276"],
  "maxResults": 5
}
```

#### Direct EHRAIDs

Use `ehraids` when you already know the Zefix firm ID.

This is the most direct detail lookup.

Example:

```json
{
  "ehraids": ["284234"],
  "includeDetails": true
}
```

#### Result limit

Use `maxResults` to cap the number of unique company records saved across all inputs.

Start with a small number while validating your workflow.

#### Detail enrichment

Set `includeDetails` to `true` to fetch the detail endpoint for each company.

Details include purpose, translations, and SHAB publications.

Set it to `false` for faster search-result-only runs.

#### SHAB publication limit

Use `maxShabPublications` to limit event rows per company.

A value between 5 and 20 is usually enough for screening workflows.

#### Canton filters

Use `cantonFilters` to keep records from specific registry office cantons.

Example values: `VD`, `ZH`, `BE`, `GE`.

#### Legal seat filters

Use `legalSeatFilters` to keep companies from exact municipality names.

Example values: `Lausanne`, `Zürich`, `Vevey`.

#### Status filters

Use `statusFilters` to keep only matching Zefix statuses.

A common value is `EXISTIEREND` for active entities.

### Example input

```json
{
  "searchTerms": ["Nestle"],
  "uids": ["CHE-107.028.276"],
  "ehraids": ["284234"],
  "maxResults": 10,
  "includeDetails": true,
  "maxShabPublications": 5,
  "statusFilters": ["EXISTIEREND"]
}
```

### Example output

```json
{
  "name": "Fondation Nestlé pour l'étude des problèmes de l'alimentation dans le monde",
  "uidFormatted": "CHE-107.028.276",
  "uid": "CHE107028276",
  "chidFormatted": "CH-550-0175071-5",
  "ehraid": 284234,
  "legalFormName": "Foundation",
  "legalSeat": "Lausanne",
  "registryOfficeCanton": "VD",
  "status": "EXISTIEREND",
  "shabDate": "2025-06-25",
  "cantonalExcerptUrl": "https://prestations.vd.ch/...",
  "purpose": "contribuer à l'amélioration de la nutrition...",
  "shabPublications": [
    {
      "shabDate": "2025-06-25",
      "shabId": 1006366293,
      "registryOfficeCanton": "VD",
      "mutationTypes": ["adressaenderung"]
    }
  ],
  "sourceUrl": "https://www.zefix.ch/ZefixREST/api/v1/firm/284234.json",
  "scrapedAt": "2026-06-09T00:00:00.000Z"
}
```

### Tips for better results

- Use the official company name when possible.
- Use UID or EHRAID for exact matching.
- Keep `includeDetails` enabled when you need purpose or SHAB rows.
- Use `maxResults` to avoid collecting broad matches from generic names.
- Use status filters to exclude deleted entities.
- Use legal seat filters for city-level screening.

### Integrations

You can connect the dataset to Google Sheets for compliance review.

You can send dataset webhooks to a CRM enrichment pipeline.

You can export JSON to a data warehouse for KYB checks.

You can schedule the actor daily or weekly to monitor known EHRAIDs.

You can call the actor from Make, Zapier, n8n, or a custom backend.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/zefix-swiss-company-registry-scraper').call({
  searchTerms: ['Nestle'],
  maxResults: 10,
  includeDetails: true,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/zefix-swiss-company-registry-scraper').call(run_input={
    'searchTerms': ['Nestle'],
    'maxResults': 10,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~zefix-swiss-company-registry-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["Nestle"],"maxResults":10,"includeDetails":true}'
```

### Using with MCP

Use Apify MCP to run this actor from Claude Code, Claude Desktop, Cursor, VS Code, or another MCP client.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/zefix-swiss-company-registry-scraper
```

#### Claude Code MCP setup

Run this command in Claude Code after setting `APIFY_TOKEN` in your shell:

```bash
claude mcp add apify-zefix --transport http "https://mcp.apify.com/?tools=automation-lab/zefix-swiss-company-registry-scraper&token=$APIFY_TOKEN"
```

Then ask Claude Code to call the actor with your preferred `searchTerms`, `uids`, or `ehraids` input.

#### Claude Desktop, Cursor, and VS Code MCP setup

Add this MCP server to your client configuration. Replace `YOUR_APIFY_TOKEN` with your Apify API token.

```json
{
  "mcpServers": {
    "apify-zefix": {
      "url": "https://mcp.apify.com/?tools=automation-lab/zefix-swiss-company-registry-scraper&token=YOUR_APIFY_TOKEN"
    }
  }
}
```

For clients that require command-based server definitions, use this HTTP bridge form:

```json
{
  "mcpServers": {
    "apify-zefix": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.apify.com/?tools=automation-lab/zefix-swiss-company-registry-scraper&token=YOUR_APIFY_TOKEN"
      ]
    }
  }
}
```

Example Claude prompt:

```text
Run the Zefix Swiss Company Registry Scraper for Nestle and summarize active Swiss entities with UID and legal seat.
```

Another prompt:

```text
Look up EHRAID 284234 and extract purpose, legal form, latest SHAB event, and cantonal excerpt URL.
```

### Scheduling workflows

Schedule daily checks for a watchlist of EHRAIDs.

Schedule weekly searches for new subsidiaries or suppliers.

Send results to a webhook and compare against previous snapshots.

### Data quality notes

The actor returns data available from Zefix public endpoints.

Some fields can be missing when Zefix does not provide them for a record.

Canton filtering depends on detail SHAB publication rows.

UID searches are sent through the public search endpoint and may return matching records rather than a separate UID-only API route.

### Limitations

The actor does not log in to private registry systems.

The actor does not scrape paid Moneyhouse pages.

The actor does not guarantee legal interpretation of registry data.

The actor does not replace a professional compliance review.

### FAQ

#### Is this official Zefix data?

The actor reads public Zefix REST endpoints and returns fields exposed by those official public responses.

#### Does the actor need a proxy?

No proxy is configured by default because the tested Zefix REST endpoints respond to direct HTTP requests.

### Troubleshooting

#### Why did I get more than one company for a UID-like query?

Zefix search can behave like free-text search. Use EHRAID for exact detail lookup when you have it.

#### Why is `registryOfficeCanton` empty?

The canton is derived from SHAB publication rows. Enable details and allow at least one SHAB publication.

#### Why are some purpose fields empty?

Some records may not expose purpose text in the public detail response.

### Legality and responsible use

Zefix provides public Swiss registry information.

Use the data responsibly and follow Apify terms, Zefix terms, and applicable privacy and compliance rules.

Do not use registry data for unlawful profiling, harassment, spam, or prohibited automated decisions.

### Related scrapers

- https://apify.com/automation-lab/google-maps-business-scraper
- https://apify.com/automation-lab/company-enrichment-scraper
- https://apify.com/automation-lab/business-directory-scraper

### Changelog

Initial version supports company search terms, UID searches, direct EHRAID detail lookups, legal-form lookup, filters, and SHAB publication enrichment.

### Support

If a search behaves unexpectedly, include the exact input JSON and a sample Zefix company name or EHRAID.

### Developer notes

This actor is HTTP-only and uses the official public Zefix REST endpoints.

No proxy is configured by default.

The default memory is 256 MB.

### Output schema summary

The dataset view shows the most important company identifiers and screening fields.

Full JSON exports include nested SHAB publication arrays and localized legal-form names.

### Version

Actor version: 0.1.

### Ready-to-run sample

Copy this input for a small first run:

```json
{
  "searchTerms": ["Nestle"],
  "maxResults": 10,
  "includeDetails": true,
  "maxShabPublications": 5,
  "statusFilters": ["EXISTIEREND"]
}
```

# Actor input Schema

## `searchTerms` (type: `array`):

Company names, trade names, or free-text registry queries to search on Zefix.

## `uids` (type: `array`):

Optional Swiss UIDs such as CHE-107.028.276. These are searched through the public Zefix search endpoint.

## `ehraids` (type: `array`):

Optional Zefix firm identifiers for direct detail lookups, for example 284234.

## `maxResults` (type: `integer`):

Maximum number of unique company records to save across all search terms, UIDs, and EHRAIDs.

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

Fetch each company's detail endpoint to include purpose, translations, and SHAB publication rows.

## `maxShabPublications` (type: `integer`):

Maximum SHAB publication/event rows to include for each company when details are enabled.

## `cantonFilters` (type: `array`):

Keep only firms whose latest SHAB publication has one of these canton codes, for example VD, ZH, BE. Requires details.

## `legalSeatFilters` (type: `array`):

Keep only firms with these exact legal-seat municipality names, for example Lausanne or Zürich.

## `statusFilters` (type: `array`):

Keep only firms with these Zefix statuses. Common value: EXISTIEREND.

## Actor input object example

```json
{
  "searchTerms": [
    "Nestle",
    "Novartis"
  ],
  "uids": [
    "CHE-107.028.276"
  ],
  "ehraids": [
    "284234"
  ],
  "maxResults": 10,
  "includeDetails": true,
  "maxShabPublications": 10,
  "cantonFilters": [
    "VD"
  ],
  "statusFilters": [
    "EXISTIEREND"
  ]
}
```

# Actor output Schema

## `overview` (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 = {
    "searchTerms": [
        "Nestle",
        "Novartis"
    ],
    "uids": [
        "CHE-107.028.276"
    ],
    "ehraids": [
        "284234"
    ],
    "maxResults": 10,
    "cantonFilters": [
        "VD"
    ],
    "statusFilters": [
        "EXISTIEREND"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/zefix-swiss-company-registry-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 = {
    "searchTerms": [
        "Nestle",
        "Novartis",
    ],
    "uids": ["CHE-107.028.276"],
    "ehraids": ["284234"],
    "maxResults": 10,
    "cantonFilters": ["VD"],
    "statusFilters": ["EXISTIEREND"],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/zefix-swiss-company-registry-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 '{
  "searchTerms": [
    "Nestle",
    "Novartis"
  ],
  "uids": [
    "CHE-107.028.276"
  ],
  "ehraids": [
    "284234"
  ],
  "maxResults": 10,
  "cantonFilters": [
    "VD"
  ],
  "statusFilters": [
    "EXISTIEREND"
  ]
}' |
apify call automation-lab/zefix-swiss-company-registry-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/zefix-swiss-company-registry-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zefix Swiss Company Registry Scraper",
        "description": "🇨🇭 Extract official Swiss company registry records from Zefix by company name, UID, or EHRAID with legal forms and SHAB events.",
        "version": "0.1",
        "x-build-id": "aNZFrFE0y873WdjxW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~zefix-swiss-company-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-zefix-swiss-company-registry-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/automation-lab~zefix-swiss-company-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-zefix-swiss-company-registry-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/automation-lab~zefix-swiss-company-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-zefix-swiss-company-registry-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": {
                    "searchTerms": {
                        "title": "Company search terms",
                        "type": "array",
                        "description": "Company names, trade names, or free-text registry queries to search on Zefix.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "uids": {
                        "title": "Swiss UID values",
                        "type": "array",
                        "description": "Optional Swiss UIDs such as CHE-107.028.276. These are searched through the public Zefix search endpoint.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ehraids": {
                        "title": "Zefix EHRAIDs",
                        "type": "array",
                        "description": "Optional Zefix firm identifiers for direct detail lookups, for example 284234.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum company records",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of unique company records to save across all search terms, UIDs, and EHRAIDs.",
                        "default": 25
                    },
                    "includeDetails": {
                        "title": "Include company details",
                        "type": "boolean",
                        "description": "Fetch each company's detail endpoint to include purpose, translations, and SHAB publication rows.",
                        "default": true
                    },
                    "maxShabPublications": {
                        "title": "Maximum SHAB publications per company",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum SHAB publication/event rows to include for each company when details are enabled.",
                        "default": 10
                    },
                    "cantonFilters": {
                        "title": "Registry office canton filters",
                        "type": "array",
                        "description": "Keep only firms whose latest SHAB publication has one of these canton codes, for example VD, ZH, BE. Requires details.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "legalSeatFilters": {
                        "title": "Legal seat filters",
                        "type": "array",
                        "description": "Keep only firms with these exact legal-seat municipality names, for example Lausanne or Zürich.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "statusFilters": {
                        "title": "Status filters",
                        "type": "array",
                        "description": "Keep only firms with these Zefix statuses. Common value: EXISTIEREND.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```