# search.ch Swiss Business Directory Scraper (`solidcode/search-ch-scraper`) Actor

\[💰 $0.06 / 1K] Extract Swiss business leads from search.ch — name, category, phones, website, email, full address, canton, ratings, and profile links. Search any category across multiple Swiss cities at once, or paste result-page URLs.

- **URL**: https://apify.com/solidcode/search-ch-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.06 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## search.ch Swiss Business Directory Scraper

Pull Swiss business listings from search.ch at scale — company names, categories, phone numbers, websites, emails, full addresses, cantons, and ratings across all 26 cantons and in German, French, Italian, or English. Search dozens of categories across dozens of cities in a single run, or paste result-page URLs you built in the browser. Built for Swiss B2B sales teams, lead-generation agencies, and market researchers who need clean, structured Swiss business contacts without copying them out of the phone book one entry at a time.

### Why This Scraper?

- **All 26 Swiss cantons in one run** — search by city, canton code (ZH, GE, TI, VD...), or postal code (8000, 1200), and every listing carries its two-letter canton so you can segment leads by region instantly.
- **Four language editions** — pull labels and results from the German, French, Italian, or English version of search.ch, matching how the business is listed in its own region.
- **Phone numbers in clean E.164 format** — every published number comes back as `+41...`, ready to dial, import into a CRM, or feed to an autodialer with no reformatting.
- **Decoded email addresses** — flip on details and the actor recovers the business email that search.ch scrambles on the page, giving you a direct contact channel most exports miss.
- **Multi-term × multi-city cross-product** — list ten categories and ten cities and get all 100 searches in a single run; no need to launch a run per query.
- **Componentized Swiss addresses** — every row splits the address into street, postal code (PLZ), locality, and canton, so you get mail-merge-ready fields, not one string to parse.
- **Up to 200 businesses per search combo** — each category-and-city pairing pulls the full result set, with an overshoot-safe cap so you never lose the last page.
- **Ratings and review counts** — the average star rating and number of reviews come with each listing, so you can prioritize established, well-reviewed businesses.
- **Punycode-safe websites** — internationalized Swiss domains (`xn--...`) are preserved exactly as registered, so links always resolve.

### Use Cases

**Lead Generation**
- Build call lists of Swiss businesses by category and canton, phone numbers dial-ready in E.164
- Collect direct business emails for outreach when profile details are enabled
- Target a single city, a whole canton, or all of Switzerland from one search
- Assemble named-category prospect lists (Treuhand, Garage, Coiffeur, Zahnarzt) in bulk

**Market Research**
- Map how many businesses in a category operate in each of the 26 cantons
- Compare business density across Zürich, Geneva, Bern, and Basel
- Track ratings and review counts to gauge competitive strength in a region
- Analyze the German-, French-, and Italian-speaking markets side by side

**Recruitment & Sourcing**
- Find employers by profession and region for candidate placement
- Build directories of firms in a target trade across specific cantons
- Segment sourcing lists by city or postal code

**CRM Enrichment**
- Backfill missing phone, website, and address fields on existing Swiss records
- Add canton and postal code to accounts for territory assignment
- Attach business emails to contacts that only had a name and city

### Getting Started

#### Search One Category in One City

The simplest way to start — a single term and location:

```json
{
    "searchTerms": ["Restaurant"],
    "locations": ["Zürich"],
    "maxResults": 100
}
````

#### Many Categories Across Many Cities

Every term is paired with every location — this runs six searches:

```json
{
    "searchTerms": ["Treuhand", "Garage", "Coiffeur"],
    "locations": ["Bern", "8000"],
    "maxResults": 300
}
```

#### Paste Result URLs, Add Emails, Choose Language

Reuse a search you built on search.ch, enrich each listing with its email, and read results in French:

```json
{
    "startUrls": [
        "https://search.ch/tel/index.fr.html?all=Avocat&where=Gen%C3%A8ve"
    ],
    "includeDetails": true,
    "language": "fr",
    "maxResults": 200
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["Restaurant"]` | Keywords, business categories, company names, or professions (e.g. "Restaurant", "Zahnarzt", "Treuhand"). Each term is searched in every location below. |
| `locations` | string\[] | `["Zürich"]` | Swiss cities, cantons, or postal codes (e.g. "Zürich", "Genève", "Bern", "8000", "TI"). Each is combined with every search term. Leave empty to search all of Switzerland. |

#### Or Paste URLs

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | URL\[] | `[]` | Paste search.ch result-page URLs directly from your browser. When provided, the search terms and locations above are ignored. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `language` | select | `German` | Language edition of search.ch to use for labels and results: German, French, Italian, or English. |
| `includeDetails` | boolean | `false` | Also open each business's profile page to add its email address and fill in canton, website, and rating. Slower, since it fetches one extra page per business. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of listings collected across all searches. Set to 0 for no cap (a safety limit of 50,000 still applies). |
| `maxPagesPerSearch` | integer | `0` | Optional cap on result pages fetched per individual search (about 10 listings per page). Leave at 0 to rely on Maximum Results. |

### Output

Each business is one row. Here's a representative result with details enabled:

```json
{
    "name": "Ristorante Bellavista",
    "categories": ["Restaurant", "Pizzeria", "Catering"],
    "industry": "Restaurant",
    "phones": ["+41442345678"],
    "email": "info@bellavista.ch",
    "website": "https://www.bellavista.ch",
    "address": "Bahnhofstrasse 12, 8001 Zürich",
    "streetAddress": "Bahnhofstrasse 12",
    "postalCode": "8001",
    "locality": "Zürich",
    "canton": "ZH",
    "rating": 4.6,
    "reviewCount": 128,
    "isPaidListing": false,
    "resultPosition": 3,
    "profileUrl": "https://search.ch/tel/zuerich/bahnhofstrasse-12/ristorante-bellavista",
    "searchTerm": "Restaurant",
    "searchLocation": "Zürich",
    "sourceUrl": "https://search.ch/tel/?all=Restaurant&where=Z%C3%BCrich",
    "scrapedAt": "2026-07-02T14:30:00Z"
}
```

#### Business & Contact

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Business or person name |
| `categories` | string\[] | Category tags from the listing |
| `industry` | string | Primary category (most relevant tag) |
| `phones` | string\[] | Published phone numbers in E.164 format (+41...) |
| `email` | string | Business email — filled when details are enabled and published |
| `website` | string | External website URL, punycode preserved |
| `rating` | number | Average rating when present |
| `reviewCount` | number | Number of reviews when present |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `address` | string | Full formatted address line |
| `streetAddress` | string | Street and number |
| `postalCode` | string | Swiss postal code (PLZ) |
| `locality` | string | City or town |
| `canton` | string | Two-letter Swiss canton code (ZH, GE, TI...) |

#### Listing & Query Context

| Field | Type | Description |
|-------|------|-------------|
| `isPaidListing` | boolean | Whether the entry is a paid/premium listing |
| `resultPosition` | number | Position within the result set |
| `profileUrl` | string | search.ch profile page URL for the business |
| `searchTerm` | string | Search term that produced this row |
| `searchLocation` | string | Location filter that produced this row |
| `sourceUrl` | string | Result page this listing came from |
| `scrapedAt` | string | ISO 8601 timestamp of extraction |

### Tips for Best Results

- **Segment by canton or postal code** — pass a canton code (ZH, VD, TI) or a PLZ (8000, 1200) as a location to carve Switzerland into clean territories, then match on the returned `canton` field.
- **Turn on details only when you need emails** — enabling profile details recovers business emails and fills canton, website, and rating, but adds a page fetch per business. Leave it off for fast name-and-phone lists.
- **Reuse a search from your browser** — build and preview a search on search.ch, then paste the result-page URL into `startUrls` to scrape exactly what you saw.
- **Pick the region's language** — use the French or Italian edition when targeting Romandy or Ticino so category labels and descriptions match how businesses list themselves.
- **List many categories at once** — because every term pairs with every location, one run with several professions and several cities covers a whole prospecting grid.
- **Leave locations empty for nationwide sweeps** — a term with no location searches all of Switzerland; add locations only when you want to focus.
- **Start with a small Maximum Results** — run 50 first to confirm the categories and cities return what you expect, then raise the cap for the full pull.

### Pricing

**From $0.06 per 1,000 results** — a fraction of the cost of building and maintaining your own Swiss directory extractor. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.0072 | $0.0068 | $0.0064 | $0.0060 |
| 1,000 | $0.072 | $0.068 | $0.064 | $0.060 |
| 10,000 | $0.72 | $0.68 | $0.64 | $0.60 |
| 100,000 | $7.20 | $6.80 | $6.40 | $6.00 |

A "result" is one business row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate business research, market analysis, and lead generation using publicly listed Swiss directory information. Users are responsible for complying with applicable laws — including Swiss and EU data-protection rules — and with search.ch's Terms of Service. Do not use extracted contact data for spam, harassment, or any unlawful purpose, and honor opt-out and do-not-contact requests.

# Actor input Schema

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

Keywords, business categories, company names, or professions to look up on search.ch (e.g. 'Restaurant', 'Zahnarzt', 'Treuhand', 'Coiffeur', 'Garage'). Each term is searched in every location below, so you can cover many categories in one run.

## `locations` (type: `array`):

Swiss cities, cantons, or postal codes to search in (e.g. 'Zürich', 'Genève', 'Bern', 'Basel', '8000', 'TI'). Each location is combined with every search term above. Leave empty to search across all of Switzerland.

## `startUrls` (type: `array`):

Paste search.ch result-page URLs directly from your browser. Use this when you have already built a search on the site and want to scrape exactly those results. When provided, the search terms and locations above are ignored.

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

Language version of search.ch to use for labels and result pages.

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

When enabled, the actor also opens each business's public profile page to add its email address when search.ch publishes it. This is slower because it fetches one extra page per business — leave it off if you only need the core fields (name, category, phone, website, address, ratings).

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

Hard cap on the total number of listings collected across all searches. Default 100 — increase for bigger runs, or set to 0 for no cap (an internal safety limit of 50,000 results still applies to prevent runaway pagination). Note: search.ch returns up to about 200 businesses per search word + location pairing, so to collect more, add more locations or search words. Each listing is billed at the per-result rate.

## `maxPagesPerSearch` (type: `integer`):

Safety valve limiting how many result pages to fetch for each individual search (search.ch shows roughly 10 listings per page). Set to 0 for no per-search page limit — only the Maximum Results cap above applies.

## Actor input object example

```json
{
  "searchTerms": [
    "Restaurant"
  ],
  "locations": [
    "Zürich"
  ],
  "startUrls": [],
  "language": "de",
  "includeDetails": false,
  "maxResults": 100,
  "maxPagesPerSearch": 0
}
```

# Actor output Schema

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

Table of businesses with the most useful fields — name, category, phone, city, canton, rating, and profile link.

## `details` (type: `string`):

Full per-business rows with website, email (when 'Include email addresses' is on), componentized address, canton, ratings, query context, and source page.

# 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": [
        "Restaurant"
    ],
    "locations": [
        "Zürich"
    ],
    "startUrls": [],
    "language": "de",
    "includeDetails": false,
    "maxResults": 100,
    "maxPagesPerSearch": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/search-ch-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": ["Restaurant"],
    "locations": ["Zürich"],
    "startUrls": [],
    "language": "de",
    "includeDetails": False,
    "maxResults": 100,
    "maxPagesPerSearch": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/search-ch-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": [
    "Restaurant"
  ],
  "locations": [
    "Zürich"
  ],
  "startUrls": [],
  "language": "de",
  "includeDetails": false,
  "maxResults": 100,
  "maxPagesPerSearch": 0
}' |
apify call solidcode/search-ch-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/search-ch-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "search.ch Swiss Business Directory Scraper",
        "description": "[💰 $0.06 / 1K] Extract Swiss business leads from search.ch — name, category, phones, website, email, full address, canton, ratings, and profile links. Search any category across multiple Swiss cities at once, or paste result-page URLs.",
        "version": "1.0",
        "x-build-id": "GXJS7Ucb2zu94DhV3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~search-ch-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-search-ch-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/solidcode~search-ch-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-search-ch-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/solidcode~search-ch-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-search-ch-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": "Search Terms",
                        "type": "array",
                        "description": "Keywords, business categories, company names, or professions to look up on search.ch (e.g. 'Restaurant', 'Zahnarzt', 'Treuhand', 'Coiffeur', 'Garage'). Each term is searched in every location below, so you can cover many categories in one run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Swiss cities, cantons, or postal codes to search in (e.g. 'Zürich', 'Genève', 'Bern', 'Basel', '8000', 'TI'). Each location is combined with every search term above. Leave empty to search across all of Switzerland.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Result-Page URLs",
                        "type": "array",
                        "description": "Paste search.ch result-page URLs directly from your browser. Use this when you have already built a search on the site and want to scrape exactly those results. When provided, the search terms and locations above are ignored.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "de",
                            "fr",
                            "it",
                            "en"
                        ],
                        "type": "string",
                        "description": "Language version of search.ch to use for labels and result pages.",
                        "default": "de"
                    },
                    "includeDetails": {
                        "title": "Include email addresses (opens each profile page)",
                        "type": "boolean",
                        "description": "When enabled, the actor also opens each business's public profile page to add its email address when search.ch publishes it. This is slower because it fetches one extra page per business — leave it off if you only need the core fields (name, category, phone, website, address, ratings).",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the total number of listings collected across all searches. Default 100 — increase for bigger runs, or set to 0 for no cap (an internal safety limit of 50,000 results still applies to prevent runaway pagination). Note: search.ch returns up to about 200 businesses per search word + location pairing, so to collect more, add more locations or search words. Each listing is billed at the per-result rate.",
                        "default": 100
                    },
                    "maxPagesPerSearch": {
                        "title": "Maximum Pages per Search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Safety valve limiting how many result pages to fetch for each individual search (search.ch shows roughly 10 listings per page). Set to 0 for no per-search page limit — only the Maximum Results cap above applies.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
