# Messe Frankfurt Exhibitor List Scraper (`automation-lab/messe-frankfurt-exhibitor-list-scraper`) Actor

Scrape Messe Frankfurt exhibitor leads with booth, country, category, contact, website, and profile data for fair planning.

- **URL**: https://apify.com/automation-lab/messe-frankfurt-exhibitor-list-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, 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

## Messe Frankfurt Exhibitor List Scraper

Scrape public Messe Frankfurt exhibitor-search pages into clean company lead records.

The actor is designed for sales teams, agencies, sponsors, logistics providers, market researchers, and event operations teams that need structured exhibitor data from Messe Frankfurt fair websites such as Ambiente.

### What does this actor do?

It reads Messe Frankfurt exhibitor search pages, discovers the public fair identifier used by the website, calls the same public exhibitor API used by the page, and saves each exhibitor as a structured dataset item.

You can collect company names, profile URLs, hall and stand information, countries, cities, addresses, contact fields where available, product categories, keywords, and timestamps.

### Why use it?

Messe Frankfurt exhibitor lists are valuable for lead generation and event planning, but copying them manually is slow and error-prone.

This actor automates that workflow and gives you export-ready data for spreadsheets, CRMs, BI tools, or enrichment pipelines.

### Typical use cases

- Build exhibitor lead lists before a trade fair.
- Segment exhibitors by country or city.
- Plan booth visits by hall and stand.
- Find potential distributors, partners, or suppliers.
- Prepare outreach campaigns for event sponsors.
- Monitor which companies participate in a fair.
- Enrich internal account lists with event-presence signals.

### Supported websites

The default input targets Ambiente:

`https://ambiente.messefrankfurt.com/frankfurt/en/exhibitor-search.html`

Other Messe Frankfurt exhibitor-search pages with the same public search component can be used through `startUrls`.

### Input options

#### Exhibitor search URLs

Add one or more Messe Frankfurt exhibitor-search page URLs. The actor discovers the fair ID and language from each page.

#### Fair IDs

Advanced users can pass Messe Frankfurt fair IDs directly, for example `AMBIENTE`. If this field is set, URL discovery is skipped.

#### Search query

Use `query` to filter by company, product, category, or related text supported by the source website.

#### Maximum exhibitors

Use `maxItems` to control the run size and cost.

#### Page size

Use `pageSize` to control API pagination. The actor caps this to a safe value.

#### Fetch profile details

Enable `includeDetails` when you need richer descriptions, categories, and contact details from exhibitor profile endpoints.

#### Request delay

Use `delayMs` to slow down large runs, especially with detail enrichment enabled.

### Example input

```json
{
  "startUrls": [
    { "url": "https://ambiente.messefrankfurt.com/frankfurt/en/exhibitor-search.html" }
  ],
  "maxItems": 100,
  "pageSize": 50,
  "includeDetails": false,
  "delayMs": 100
}
````

### Example query input

```json
{
  "startUrls": [
    { "url": "https://ambiente.messefrankfurt.com/frankfurt/en/exhibitor-search.html" }
  ],
  "query": "furniture",
  "maxItems": 50,
  "includeDetails": true
}
```

### Output fields

Each dataset item represents one exhibitor.

### Field: fairId

The Messe Frankfurt fair identifier, for example `AMBIENTE`.

### Field: fairName

The public event or fair name returned by the source.

### Field: eventStartDate

The fair start date when available.

### Field: eventEndDate

The fair end date when available.

### Field: exhibitorId

The source exhibitor ID.

### Field: rewriteId

The source profile slug used in Messe Frankfurt profile URLs.

### Field: exhibitorName

The exhibitor or company name.

### Field: description

A plain-text profile description when available.

### Field: profileUrl

A link to the public Messe Frankfurt exhibitor profile.

### Field: hall

The hall value returned by the fair website.

### Field: stand

The booth or stand value returned by the fair website.

### Field: hallStand

A combined hall and stand field for quick spreadsheet filtering.

### Field: country

The exhibitor country name.

### Field: countryCode

The source country code, usually ISO-3 when available.

### Field: city

The exhibitor city.

### Field: zip

The postal code.

### Field: street

The street address.

### Field: phone

The public phone number when available.

### Field: fax

The public fax number when available.

### Field: email

The public email address when available.

### Field: website

The public website URL when available or detected in the profile text.

### Field: productCategories

A list of product category names associated with the exhibitor.

### Field: keywords

Keywords returned by the source profile.

### Field: productsCount

Number of products listed by the source profile when available.

### Field: sourceUrl

The input page used to discover or represent the fair.

### Field: scrapedAt

ISO timestamp for when the record was saved.

### Data quality notes

The actor returns data that is publicly available on Messe Frankfurt websites. Some exhibitors do not publish emails, websites, phone numbers, or complete addresses. Those fields will be `null` when the source does not provide them.

### Detail enrichment notes

The search API already returns useful exhibitor records. Enabling `includeDetails` fetches each profile individually and can improve descriptions, categories, and contact fields.

For large runs, start without detail enrichment, then enable it if you need richer profiles.

### Pagination

The actor keeps requesting pages until it reaches `maxItems`, the source returns no more results, or the current fair is complete.

### Cost control

Set `maxItems` to a small value for first tests. Increase it after confirming the output matches your workflow.

### Responsible use

Use this actor for legitimate business research, event planning, and lead preparation. Respect applicable privacy, marketing, and anti-spam laws when using contact data.

### Tips for CRM import

Export the dataset as CSV or Excel. Use `exhibitorName`, `website`, `email`, and `country` for deduplication and enrichment.

### Tips for booth planning

Sort by `hallStand`, then group by `country` or `productCategories` to prepare route plans.

### Tips for market research

Use `productCategories` and `keywords` to identify segments represented at a fair.

### Limitations

The actor depends on the current Messe Frankfurt public exhibitor-search API. If Messe Frankfurt changes its frontend or API contract, the actor may require an update.

### Troubleshooting

If a run returns fewer records than expected, check `maxItems`, `query`, and whether the source fair currently has published exhibitors.

### FAQ: Can I scrape multiple fairs?

Yes. Add multiple exhibitor search URLs or pass multiple fair IDs.

### FAQ: Does it require login?

No. It uses public exhibitor data exposed by the fair website.

### FAQ: Does it scrape private attendee data?

No. It extracts public exhibitor/company information.

### FAQ: Can I use the API directly?

Yes. Run the actor through Apify API and download the default dataset.

### Output example

```json
{
  "fairId": "AMBIENTE",
  "fairName": "Ambiente 2026",
  "exhibitorName": "Example GmbH",
  "hallStand": "3.0, G32",
  "country": "Germany",
  "city": "Frankfurt am Main",
  "email": "info@example.com",
  "website": "https://www.example.com",
  "productCategories": ["Interior Design"],
  "sourceUrl": "https://ambiente.messefrankfurt.com/frankfurt/en/exhibitor-search.html"
}
```

### Changelog

Initial version: HTTP-first Messe Frankfurt exhibitor extraction with optional profile enrichment.

### Who is it for?

This actor is for sales development teams, event sponsors, booth-service vendors, logistics providers, trade-fair consultants, distributors, sourcing teams, and analysts who need structured Messe Frankfurt exhibitor data instead of manual copying.

### Pricing

The actor uses pay-per-event pricing. A small run-start event covers fixed startup work, and a per-exhibitor event is charged for saved exhibitor records. Use `maxItems` to control spend before running larger fair exports.

### API usage

You can run the actor from the Apify API, Apify client libraries, or the Apify Console. Replace the token and actor ID with your own values.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/messe-frankfurt-exhibitor-list-scraper').call({
  startUrls: [{ url: 'https://ambiente.messefrankfurt.com/frankfurt/en/exhibitor-search.html' }],
  maxItems: 100,
  pageSize: 50,
  includeDetails: false,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/messe-frankfurt-exhibitor-list-scraper').call(run_input={
    'startUrls': [{'url': 'https://ambiente.messefrankfurt.com/frankfurt/en/exhibitor-search.html'}],
    'maxItems': 100,
    'pageSize': 50,
    'includeDetails': False,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~messe-frankfurt-exhibitor-list-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://ambiente.messefrankfurt.com/frankfurt/en/exhibitor-search.html"}],"maxItems":100,"pageSize":50,"includeDetails":false}'
```

### MCP

If you use Apify through an MCP-enabled assistant, provide the actor ID `automation-lab/messe-frankfurt-exhibitor-list-scraper` and the same JSON input shown above. The assistant can start the run, wait for completion, and read the default dataset.

Add the Apify MCP server with this CLI command:

```bash
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors automation-lab/messe-frankfurt-exhibitor-list-scraper
```

Example MCP server JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "automation-lab/messe-frankfurt-exhibitor-list-scraper"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

MCP example prompts:

Example prompts for MCP usage:

- "Use the Apify MCP server to run the Messe Frankfurt Exhibitor List Scraper for Ambiente and return 100 exhibitors."
- "Use MCP to find design-related Ambiente exhibitors and summarize their booth locations."
- "Use the MCP actor tool to export Messe Frankfurt exhibitor leads with websites and emails as CSV-ready dataset rows."

### Legality

This actor collects public exhibitor/company information exposed on Messe Frankfurt websites. It does not bypass login pages or collect private attendee data. You are responsible for using exported contact data lawfully, including complying with marketing, privacy, and anti-spam rules in your jurisdiction.

### MCP setup

You can connect Apify to an MCP-compatible desktop assistant and run this actor from natural-language prompts.

### MCP CLI add command

```bash
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors automation-lab/messe-frankfurt-exhibitor-list-scraper
```

### MCP JSON config

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--actors",
        "automation-lab/messe-frankfurt-exhibitor-list-scraper"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

### MCP example prompts

- "Run the Messe Frankfurt Exhibitor List Scraper for Ambiente and return the first 100 exhibitors."
- "Find Ambiente exhibitors matching design and summarize their countries and booth locations."
- "Export Messe Frankfurt exhibitor leads with websites and emails to a dataset I can download as CSV."

### MCP workflow tip

Ask your MCP assistant to run a small `maxItems` test first. After you confirm the fields, increase `maxItems` for the full exhibitor export.

# Actor input Schema

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

Messe Frankfurt exhibitor search pages. The actor discovers the fair/event ID from each URL.

## `fairIds` (type: `array`):

Advanced: Messe Frankfurt find event variables, e.g. AMBIENTE. If set, URL discovery is skipped.

## `query` (type: `string`):

Optional keyword to search exhibitors by company, product, or category.

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

Maximum exhibitor records to save.

## `pageSize` (type: `integer`):

Number of exhibitors requested from the Messe Frankfurt API per page.

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

Open each exhibitor profile API for richer descriptions, categories, and contact fields. Slower but more complete.

## `delayMs` (type: `integer`):

Polite delay between API requests. Increase if you scrape large fairs with profile details enabled.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://ambiente.messefrankfurt.com/frankfurt/en/exhibitor-search.html"
    }
  ],
  "fairIds": [],
  "maxItems": 20,
  "pageSize": 50,
  "includeDetails": false,
  "delayMs": 100
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://ambiente.messefrankfurt.com/frankfurt/en/exhibitor-search.html"
        }
    ],
    "fairIds": [],
    "query": "",
    "maxItems": 20,
    "pageSize": 50,
    "includeDetails": false,
    "delayMs": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/messe-frankfurt-exhibitor-list-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": [{ "url": "https://ambiente.messefrankfurt.com/frankfurt/en/exhibitor-search.html" }],
    "fairIds": [],
    "query": "",
    "maxItems": 20,
    "pageSize": 50,
    "includeDetails": False,
    "delayMs": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/messe-frankfurt-exhibitor-list-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": [
    {
      "url": "https://ambiente.messefrankfurt.com/frankfurt/en/exhibitor-search.html"
    }
  ],
  "fairIds": [],
  "query": "",
  "maxItems": 20,
  "pageSize": 50,
  "includeDetails": false,
  "delayMs": 100
}' |
apify call automation-lab/messe-frankfurt-exhibitor-list-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Messe Frankfurt Exhibitor List Scraper",
        "description": "Scrape Messe Frankfurt exhibitor leads with booth, country, category, contact, website, and profile data for fair planning.",
        "version": "0.1",
        "x-build-id": "7hS08riqU2HSW4R2I"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~messe-frankfurt-exhibitor-list-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-messe-frankfurt-exhibitor-list-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~messe-frankfurt-exhibitor-list-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-messe-frankfurt-exhibitor-list-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~messe-frankfurt-exhibitor-list-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-messe-frankfurt-exhibitor-list-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": "Exhibitor search URLs",
                        "type": "array",
                        "description": "Messe Frankfurt exhibitor search pages. The actor discovers the fair/event ID from each URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "fairIds": {
                        "title": "Fair IDs (optional)",
                        "type": "array",
                        "description": "Advanced: Messe Frankfurt find event variables, e.g. AMBIENTE. If set, URL discovery is skipped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Optional keyword to search exhibitors by company, product, or category."
                    },
                    "maxItems": {
                        "title": "Maximum exhibitors",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum exhibitor records to save.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "Page size",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of exhibitors requested from the Messe Frankfurt API per page.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Fetch profile details",
                        "type": "boolean",
                        "description": "Open each exhibitor profile API for richer descriptions, categories, and contact fields. Slower but more complete.",
                        "default": false
                    },
                    "delayMs": {
                        "title": "Request delay (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Polite delay between API requests. Increase if you scrape large fairs with profile details enabled.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```