# Local.ch Business Directory Scraper (`automation-lab/local-ch-business-directory-scraper`) Actor

Extract Swiss business leads from Local.ch: names, contacts, ratings, addresses, websites, social links, and coordinates.

- **URL**: https://apify.com/automation-lab/local-ch-business-directory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

## Local.ch Business Directory Scraper

Extract Swiss business leads from Local.ch search results. The actor collects company names, profile URLs, categories, subtitles, addresses, phone numbers, emails, websites, social links, ratings, opening status, coordinates, thumbnails, and premium-listing flags.

### What It Does

Local.ch Business Directory Scraper turns Local.ch search pages into clean structured business data. Use it for Swiss lead generation, local market mapping, sales prospecting, recruiting research, location intelligence, and contact enrichment.

### Typical Use Cases

- Build lead lists for Swiss restaurants, dentists, agencies, hotels, trades, clinics, and service providers.
- Collect phone, email, website, and social profile coverage for outreach preparation.
- Map local business density by city, region, canton, or postal code.
- Compare Local.ch ratings and review counts across Swiss markets.
- Enrich existing CRM records with Local.ch profile URLs and public contact details.

### Who Is It For

This actor is for sales teams, growth agencies, recruiters, local SEO teams, market researchers, founders, and data teams that need structured Swiss business-directory data from Local.ch without manually copying search results.

### Input Options

You can run the actor with direct Local.ch URLs, structured searches, or the quick search fields.

### Local.ch Search URLs

Paste one or more Local.ch result URLs in `startUrls`.

```json
{
  "startUrls": [
    "https://www.local.ch/en/q?what=Restaurant&where=Zurich"
  ],
  "maxResults": 50
}
````

### Structured Searches

Use `searches` when you want several category and location combinations in one run.

```json
{
  "searches": [
    { "what": "Restaurant", "where": "Zurich" },
    { "what": "Dentist", "where": "Geneva" }
  ],
  "maxResults": 100
}
```

### Quick Search

Use `what` and `where` for a single search.

```json
{
  "what": "Architect",
  "where": "Basel",
  "maxResults": 25
}
```

### Pagination

The actor follows Local.ch pagination links and stops when it reaches `maxResults`, `maxPagesPerSearch`, or the end of available result pages.

### Result Limits

`maxResults` is the total number of unique businesses saved across all input searches. Duplicate Local.ch business IDs are saved only once per run.

### Language

Set `language` to `en`, `de`, `fr`, or `it`. This controls the Local.ch path used for generated searches and profile URLs.

### Output Fields

Each saved item contains:

- `search_url`
- `query`
- `city_or_region`
- `business_name`
- `profile_url`
- `category`
- `subtitles`
- `address`
- `phone`
- `email`
- `website`
- `social_links`
- `rating_average`
- `rating_count`
- `opening_status`
- `latitude`
- `longitude`
- `thumbnail_url`
- `is_premium`

### Example Output

```json
{
  "search_url": "https://www.local.ch/en/q?what=Restaurant&where=Zurich",
  "query": "Restaurant",
  "city_or_region": "Zurich",
  "business_name": "Restaurant Kindli",
  "profile_url": "https://www.local.ch/en/d/zurich/8001/restaurant/restaurant-kindli-CwBn7y7fwlbv85oZUYly1A",
  "category": "restaurant",
  "subtitles": [],
  "address": "Strehlgasse 24, 8001 Zurich, ZH, CH",
  "phone": "043 888 76 76",
  "email": "restaurant@kindli.ch",
  "website": "https://www.kindli.ch/restaurant",
  "social_links": ["https://www.instagram.com/kindlizuerich/"],
  "rating_average": 4.5,
  "rating_count": 10,
  "opening_status": "OPEN_UNTIL",
  "latitude": 47.372335,
  "longitude": 8.541026,
  "thumbnail_url": "https://images.services.local.ch/...",
  "is_premium": true
}
```

### Data Source

The actor reads public Local.ch search result pages. It extracts the structured data embedded in the initial HTML response.

### Contact Fields

Local.ch may expose several contact types. The actor stores the first phone, first email, first website, and all social media links found in the listing payload.

### Ratings

Ratings are included when Local.ch provides a visible rating summary. Listings without ratings return `null` for `rating_average` and `rating_count`.

### Coordinates

Latitude and longitude are included when Local.ch provides coordinates in the listing payload. Some listings may not include coordinates.

### Premium Listings

`is_premium` indicates whether Local.ch marks the listing as premium in the search payload.

### Costs

The actor charges one run-start event and one result event per saved business listing. BRONZE users pay `$0.005` per run plus `$0.000039864` per listing. Use small `maxResults` values while testing.

### Pricing

Pricing uses Apify pay-per-event billing. A run has a small start charge, and each saved Local.ch business listing is charged through the `result` event. Higher Apify tiers receive the standard tier discounts configured on the actor.

### Recommended Settings

Start with:

- `maxResults`: 20
- `maxPagesPerSearch`: 3
- one city and one category

Increase limits after validating that the output matches your workflow.

### Swiss Market Examples

Useful searches include:

- Restaurant in Zurich
- Dentist in Geneva
- Plumber in Basel
- Architect in Bern
- Hotel in Lausanne
- Electrician in Lucerne
- Lawyer in Lugano

### Export Formats

Apify datasets can be exported as JSON, CSV, Excel, XML, RSS, or HTML table formats.

### Automation

Schedule runs to refresh Swiss business lead lists, monitor rating changes, or periodically collect new listings for a category and region.

### API Usage

Run the actor from Node.js:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/local-ch-business-directory-scraper').call({
  what: 'Restaurant',
  where: 'Zurich',
  maxResults: 20,
  maxPagesPerSearch: 1,
  language: 'en'
});

console.log(run.defaultDatasetId);
```

Run the actor from Python:

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/local-ch-business-directory-scraper").call(
    run_input={
        "what": "Restaurant",
        "where": "Zurich",
        "maxResults": 20,
        "maxPagesPerSearch": 1,
        "language": "en",
    }
)

print(run["defaultDatasetId"])
```

Run the actor with cURL:

```bash
curl "https://api.apify.com/v2/acts/automation-lab~local-ch-business-directory-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "what": "Restaurant",
    "where": "Zurich",
    "maxResults": 20,
    "maxPagesPerSearch": 1,
    "language": "en"
  }'
```

### MCP

Use this actor from MCP clients through the Apify MCP server. The actor-specific MCP endpoint is:

```text
https://mcp.apify.com?tools=automation-lab/local-ch-business-directory-scraper
```

#### Claude Code MCP setup

Register the actor-specific Apify MCP server in Claude Code:

```bash
claude mcp add local-ch-business-directory-scraper \
  --transport http \
  "https://mcp.apify.com?tools=automation-lab/local-ch-business-directory-scraper" \
  --header "Authorization: Bearer $APIFY_TOKEN"
```

#### Claude Desktop MCP setup

Add the Apify MCP server to `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "local-ch-business-directory-scraper": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/local-ch-business-directory-scraper",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

#### Cursor and VS Code MCP setup

Use the same HTTP server configuration in `.cursor/mcp.json`, `.vscode/mcp.json`, or the MCP settings file used by your client:

```json
{
  "mcpServers": {
    "local-ch-business-directory-scraper": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/local-ch-business-directory-scraper",
      "headers": {
        "Authorization": "Bearer ${APIFY_TOKEN}"
      }
    }
  }
}
```

#### MCP prompts

Example prompt 1:

```text
Run automation-lab/local-ch-business-directory-scraper for restaurants in Zurich with maxResults 20. Return business_name, phone, website, city_or_region, and rating.
```

Example prompt 2:

```text
Use the Local.ch business directory scraper with {"startUrls":["https://www.local.ch/en/q?what=Dentist&where=Geneva"],"maxResults":25,"maxPagesPerSearch":2,"language":"en"} and summarize the saved listings by city_or_region.
```

Example prompt 3:

```text
Find Swiss accounting firms in Basel with Local.ch, limit the run to 30 listings, and return only records that include a website or phone number.
```

For MCP workflows, pass the same input schema fields (`startUrls`, `searches`, `what`, `where`, `maxResults`, `maxPagesPerSearch`, `language`, `maxRequestRetries`).

### Data Quality Notes

Local.ch decides which contacts are public for each listing. Some records have rich contact data, while others may include only a name, category, and locality.

### Troubleshooting

If a run returns fewer records than expected, increase `maxPagesPerSearch`, check that the Local.ch search URL returns results in a browser, and confirm that `maxResults` is not lower than the number you need.

### Privacy

Use the exported data responsibly. Follow applicable privacy, outreach, and marketing rules for Switzerland and your own jurisdiction.

### Legality

The actor extracts public Local.ch search result data. You are responsible for using the data lawfully, respecting Local.ch terms, and following applicable privacy, marketing, and data-protection requirements.

### Limitations

The actor extracts data available on search result pages. It does not log in, bypass private access controls, or collect non-public information.

### FAQ

Can I scrape multiple cities in one run? Yes. Add several objects to `searches` or several URLs to `startUrls`.

Does every listing include email and website data? No. Local.ch only exposes contact fields that are public for each listing.

Can I use German, French, or Italian Local.ch pages? Yes. Set `language` to `de`, `fr`, or `it`.

Why did I get fewer results than Local.ch shows? Increase `maxPagesPerSearch` and `maxResults`; Local.ch may also return duplicate or partial entries that the actor deduplicates by ID.

### Related scrapers

Other automation-lab business directory and lead-generation scrapers:

- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder)
- [11880 Local Business Directory Scraper](https://apify.com/automation-lab/11880-local-business-directory-scraper)
- [Hotfrog Business Directory Scraper](https://apify.com/automation-lab/hotfrog-business-directory-scraper)
- [PagineGialle Scraper](https://apify.com/automation-lab/paginegialle-scraper)
- [Website Contact Finder](https://apify.com/automation-lab/website-contact-finder)

### Changelog

Initial version extracts public Local.ch business listings from HTTP search result pages.

### Support

Open an Apify issue with the run ID, input, and expected Local.ch result page when reporting a problem.

### Field Reference

`search_url` is the source URL used for extraction.

`query` is the keyword or category supplied by the input or inferred from Local.ch URL parts.

`city_or_region` is the input location or parsed Local.ch locality.

`business_name` is the public Local.ch listing title.

`profile_url` is the Local.ch business profile URL.

`category` is the main Local.ch URL category slug.

`subtitles` contains Local.ch subtitle lines.

`address` is a formatted address string.

`phone` is the first phone or mobile contact.

`email` is the first email contact.

`website` is the first website contact.

`social_links` contains public social media URLs.

`rating_average` is the visible average rating.

`rating_count` is the visible number of ratings.

`opening_status` is the Local.ch opening status token.

`latitude` and `longitude` are listing coordinates when available.

`thumbnail_url` is a Local.ch logo or thumbnail image URL.

`is_premium` is the Local.ch premium listing flag.

# Actor input Schema

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

Direct Local.ch search/category URLs, for example https://www.local.ch/en/q?what=Restaurant\&where=Zurich or canonical /en/q/zurich/restaurant URLs.

## `searches` (type: `array`):

Search combinations to run on Local.ch.

## `what` (type: `string`):

Single business category or keyword. Used when structured searches are not provided.

## `where` (type: `string`):

Single Swiss city, canton, region, or postal code. Used with the quick search field.

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

Maximum number of unique business listings to save across all searches.

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

Maximum Local.ch result pages to fetch for each search URL or search combination.

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

Local.ch language path to use when building structured search URLs.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed requests.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.local.ch/en/q?what=Restaurant&where=Zurich"
  ],
  "searches": [
    {
      "what": "Restaurant",
      "where": "Zurich"
    },
    {
      "what": "Dentist",
      "where": "Geneva"
    }
  ],
  "what": "Restaurant",
  "where": "Zurich",
  "maxResults": 20,
  "maxPagesPerSearch": 3,
  "language": "en",
  "maxRequestRetries": 3
}
```

# Actor output Schema

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

Swiss business listings extracted from Local.ch search results.

# 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 = {
    "startUrls": [
        "https://www.local.ch/en/q?what=Restaurant&where=Zurich"
    ],
    "searches": [
        {
            "what": "Restaurant",
            "where": "Zurich"
        },
        {
            "what": "Dentist",
            "where": "Geneva"
        }
    ],
    "what": "Restaurant",
    "where": "Zurich",
    "maxResults": 20,
    "maxPagesPerSearch": 3,
    "language": "en",
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/local-ch-business-directory-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 = {
    "startUrls": ["https://www.local.ch/en/q?what=Restaurant&where=Zurich"],
    "searches": [
        {
            "what": "Restaurant",
            "where": "Zurich",
        },
        {
            "what": "Dentist",
            "where": "Geneva",
        },
    ],
    "what": "Restaurant",
    "where": "Zurich",
    "maxResults": 20,
    "maxPagesPerSearch": 3,
    "language": "en",
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/local-ch-business-directory-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 '{
  "startUrls": [
    "https://www.local.ch/en/q?what=Restaurant&where=Zurich"
  ],
  "searches": [
    {
      "what": "Restaurant",
      "where": "Zurich"
    },
    {
      "what": "Dentist",
      "where": "Geneva"
    }
  ],
  "what": "Restaurant",
  "where": "Zurich",
  "maxResults": 20,
  "maxPagesPerSearch": 3,
  "language": "en",
  "maxRequestRetries": 3
}' |
apify call automation-lab/local-ch-business-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Local.ch Business Directory Scraper",
        "description": "Extract Swiss business leads from Local.ch: names, contacts, ratings, addresses, websites, social links, and coordinates.",
        "version": "0.1",
        "x-build-id": "14z7kfzcOm0R2WPlo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~local-ch-business-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-local-ch-business-directory-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~local-ch-business-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-local-ch-business-directory-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~local-ch-business-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-local-ch-business-directory-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": {
                    "startUrls": {
                        "title": "Local.ch search URLs",
                        "type": "array",
                        "description": "Direct Local.ch search/category URLs, for example https://www.local.ch/en/q?what=Restaurant&where=Zurich or canonical /en/q/zurich/restaurant URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searches": {
                        "title": "Structured searches",
                        "type": "array",
                        "description": "Search combinations to run on Local.ch.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "what": {
                                    "title": "What",
                                    "type": "string",
                                    "description": "Business category or keyword.",
                                    "example": "Restaurant"
                                },
                                "where": {
                                    "title": "Where",
                                    "type": "string",
                                    "description": "Swiss city, canton, region, or postal code.",
                                    "example": "Zurich"
                                }
                            },
                            "required": [
                                "what"
                            ]
                        }
                    },
                    "what": {
                        "title": "What",
                        "type": "string",
                        "description": "Single business category or keyword. Used when structured searches are not provided."
                    },
                    "where": {
                        "title": "Where",
                        "type": "string",
                        "description": "Single Swiss city, canton, region, or postal code. Used with the quick search field."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of unique business listings to save across all searches.",
                        "default": 50
                    },
                    "maxPagesPerSearch": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum Local.ch result pages to fetch for each search URL or search combination.",
                        "default": 5
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "de",
                            "fr",
                            "it"
                        ],
                        "type": "string",
                        "description": "Local.ch language path to use when building structured search URLs.",
                        "default": "en"
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed requests.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
