# Messe Stuttgart Exhibitor Scraper (`solidcode/messe-stuttgart-scraper`) Actor

\[💰 $4.00 / 1K] Extract exhibitor lists from any Messe Stuttgart trade fair — company names, addresses, emails, phones, websites, social links, hall/stand locations, contact persons, and product categories.

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

## Pricing

from $4.00 / 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Stuttgart Exhibitor Scraper

Turn any Messe Stuttgart trade-fair exhibitor list into a clean, structured dataset — company contacts, hall and stand locations, named contact people, social profiles, and full product-category taxonomies for every exhibitor at the show. Paste a directory link and get a spreadsheet-ready file in minutes. Built for B2B sales teams, event marketers, and market researchers who need exhibitor contact data from Messe Stuttgart fairs without copying directory pages one company at a time.

### Why This Scraper?

- **Full company contact block on every exhibitor** — company name, postal address, country, email, phone, and website, not just a list of names.
- **Hall and stand location for every exhibitor** — know exactly where each company sits on the show floor before you set foot in the hall.
- **Named contact people with role, email, and phone** — reach the actual decision-maker instead of a generic info@ inbox.
- **Three-level product-category taxonomy** — every exhibitor tagged down to `categoryLevel1 / 2 / 3`, so you can segment leads by what they actually sell.
- **Six social networks captured** — LinkedIn, Facebook, Instagram, X (Twitter), YouTube, and Pinterest URLs pulled into dedicated fields.
- **Works across Messe Stuttgart fairs that publish an online exhibitor directory** — CMT, AMB, R+T, Vision, interbad, SÜFFA, and more; the tool auto-detects each fair's directory from the link you paste, with zero per-fair setup.
- **Two output shapes, one toggle** — one row per exhibitor (categories grouped) or one row per product category (flattened for filtering and pivot tables in any spreadsheet).
- **Queue several fairs in a single run** — paste multiple directory links to build one combined multi-event dataset instead of running the tool once per show.
- **Paste-a-link simplicity** — no fair IDs, no logins, and no free-plan exhibitor caps; grab the entire directory or a small capped preview.

### Use Cases

**Lead Generation & Sales Prospecting**
- Build a ready-to-import lead list of every company exhibiting at your target fair
- Capture named contact people with role, email, and phone for warm outreach
- Segment prospects by product category before a show to plan booth visits
- Enrich cold outreach with each company's hall and stand for on-site meetings

**Market & Competitive Research**
- Map the full competitive landscape of an industry as it appears at a leading fair
- Track which companies exhibit across multiple Messe Stuttgart events year over year
- Analyse exhibitor mix by country to gauge international participation
- Size a category by counting exhibitors tagged to specific product taxonomies

**Event & Sales Planning**
- Plan a route through the halls using per-exhibitor hall and stand data
- Prioritise booth visits by matching exhibitor categories to your buying interests
- Prepare account lists for the sales team ahead of a fair
- Compare exhibitor rosters across competing shows to decide where to attend

**CRM Enrichment & Data Integration**
- Enrich existing CRM records with fresh contact details, websites, and social links
- Feed exhibitor data into dashboards, lead-scoring tools, or outreach sequences
- Keep an industry contact database current with each new fair edition
- Standardise exhibitor data from several fairs into one consistent schema

### Getting Started

#### Single Fair

The simplest run — paste one exhibitor-directory link and preview the first 100 companies:

```json
{
    "startUrls": [
        "https://www.messe-stuttgart.de/cmt/en/exhibition/exhibitors-products/exhibitor-index/#/exhibitor"
    ],
    "maxResults": 100
}
````

#### One Row per Product Category

Flatten the output so each company repeats once per product category — ideal for filtering a lead list by what exhibitors sell:

```json
{
    "startUrls": [
        "https://www.messe-stuttgart.de/amb/en/exhibition/exhibitors-products/exhibitor-index/#/exhibitor"
    ],
    "outputFormat": "category",
    "maxResults": 200
}
```

#### Multiple Fairs, Full Directories

Queue several fairs in one run and collect every exhibitor from each:

```json
{
    "startUrls": [
        "https://www.messe-stuttgart.de/cmt/en/exhibition/exhibitors-products/exhibitor-index/#/exhibitor",
        "https://www.messe-stuttgart.de/amb/en/exhibition/exhibitors-products/exhibitor-index/#/exhibitor"
    ],
    "outputFormat": "exhibitor",
    "maxResults": 0
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | Example CMT URL prefilled | One or more Messe Stuttgart exhibitor-directory (exhibitor-list) page URLs. Open the fair you want, go to its exhibitor list, and paste the page URL here. The English version of the page is recommended. Add several fairs to collect them all in one run. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `outputFormat` | select | `One row per exhibitor (categories grouped)` | How to shape the results. "One row per exhibitor (categories grouped)" keeps each company on a single row with its product categories grouped together. "One row per product category (flattened)" repeats the company on a separate row for each of its product categories — handy for spreadsheet filtering by category. |
| `maxResults` | integer | `100` | Maximum number of exhibitors to collect per run. Set to `0` to collect the entire directory. Start with 20–100 to preview the data, then increase. |

### Output

Each result is one exhibitor company profile. Here's a representative row in the default "one row per exhibitor" mode:

```json
{
    "exhibitorName": "Hymer GmbH & Co. KG",
    "profileUrl": "https://www.messe-stuttgart.de/cmt/en/exhibition/exhibitors-products/exhibitor-index/#/exhibitor/48210",
    "sourceUrl": "https://www.messe-stuttgart.de/cmt/en/exhibition/exhibitors-products/exhibitor-index/",
    "address": "Holzstraße 19, 88339 Bad Waldsee, Baden-Württemberg",
    "country": "Germany",
    "email": "info@hymer.com",
    "phone": "+49 7524 999 0",
    "website": "https://www.hymer.com",
    "hallStands": ["Hall 4 Stand B21"],
    "fairs": ["CMT 2026"],
    "socialLinkedin": "https://www.linkedin.com/company/hymer",
    "socialInstagram": "https://www.instagram.com/hymer_official",
    "socialYoutube": "https://www.youtube.com/user/HymerTV",
    "contactPersons": [
        {
            "name": "Anna Weber",
            "title": "Head of Sales",
            "email": "a.weber@hymer.com",
            "phone": "+49 7524 999 120"
        }
    ],
    "productCategories": [
        "Vehicles|Motorhomes|Integrated motorhomes",
        "Vehicles|Caravans"
    ]
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `exhibitorName` | string | Company / exhibitor name |
| `profileUrl` | string | Link to the exhibitor's profile in the fair directory |
| `sourceUrl` | string | The directory URL this exhibitor was collected from (identifies which fair) |
| `fairs` | string\[] | Fair(s) the exhibitor is attending |

#### Address & Contact

| Field | Type | Description |
|-------|------|-------------|
| `address` | string | Full postal address (street, postal code, city, region) |
| `country` | string | Company country |
| `email` | string | Company email address |
| `phone` | string | Company phone number |
| `website` | string | Company website (a scheme is added to bare hosts) |
| `contactPersons` | object\[] | Named contacts, each `{ name, title, email, phone }` |

#### Location & Categories

| Field | Type | Description |
|-------|------|-------------|
| `hallStands` | string\[] | Hall and stand location(s) at the fair, e.g. "Hall 4 Stand B21" |
| `productCategories` | string\[] | Hierarchical product-category paths, deepest leaf per path (pipe-delimited). Present in "one row per exhibitor" mode |
| `categoryLevel1` | string | Top-level product category. Present in "one row per product category" mode |
| `categoryLevel2` | string | Second-level product category (if any). Present in "one row per product category" mode |
| `categoryLevel3` | string | Third-level product category (if any). Present in "one row per product category" mode |

#### Social Links

| Field | Type | Description |
|-------|------|-------------|
| `socialLinkedin` | string | LinkedIn profile URL |
| `socialFacebook` | string | Facebook profile URL |
| `socialInstagram` | string | Instagram profile URL |
| `socialTwitter` | string | X (Twitter) profile URL |
| `socialYoutube` | string | YouTube channel URL |
| `socialPinterest` | string | Pinterest profile URL |

**Category mode.** When `outputFormat` is set to "one row per product category", each exhibitor is repeated once per deepest category path, and `productCategories` is replaced by `categoryLevel1`, `categoryLevel2`, and `categoryLevel3`. All other company fields stay identical on every row, so you can filter or pivot the whole list by category in a spreadsheet. Empty fields are dropped from each row rather than returned blank.

### Tips for Best Results

- **Paste the exhibitor-list page, not the fair homepage** — open the fair, click into its exhibitor directory, and copy that page URL. A general fair landing page has no exhibitor list to read.
- **Use the English (`/en/`) version of the directory** for consistent English category labels and field values; the German (`/de/`) directory works too if you prefer German.
- **Preview before you commit** — set `maxResults` to 20–100 on the first run to confirm the data matches your needs, then set it to `0` to pull the whole directory.
- **Build a category-segmented lead list** — switch `outputFormat` to "one row per product category" so you can filter exhibitors by exactly what they sell and hand each segment to the right salesperson.
- **Combine fairs in one run** — paste several directory links together to produce a single combined multi-event dataset, then split it by the `sourceUrl` field to see which fair each exhibitor came from.
- **Reach the right person** — the `contactPersons` field carries named people with their role, email, and phone; prioritise these over the generic company email for outreach.
- **Plan your floor route** — sort by `hallStands` to group booth visits by hall and save walking time during the show.

### Pricing

**From $4.00 per 1,000 results** — a simple flat rate that undercuts confusing per-event tiers, with progressively lower prices for Bronze, Silver, and Gold subscribers. The table shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.48 | $0.45 | $0.43 | $0.40 |
| 1,000 | $4.80 | $4.50 | $4.25 | $4.00 |
| 10,000 | $48.00 | $45.00 | $42.50 | $40.00 |
| 100,000 | $480.00 | $450.00 | $425.00 | $400.00 |

A "result" is one row in the output dataset — one row per exhibitor in the default mode, or one row per product category in flattened mode. **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, event planning, and lead generation using publicly listed exhibitor information. You are responsible for complying with applicable laws — including data-protection regulations such as the GDPR — and with Messe Stuttgart's Terms of Service. Do not use extracted contact data for spam, harassment, or any unlawful purpose, and honour opt-out and marketing-consent requirements when contacting the people and companies in your results.

# Actor input Schema

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

One or more Messe Stuttgart exhibitor-directory (exhibitor-list) page URLs. Open the fair you want on its event website, go to its exhibitor list, and paste the page URL here. The English version of the page is recommended. You can add several fairs to collect them all in one run.

## `outputFormat` (type: `string`):

How to shape the results. 'One row per exhibitor' keeps each company on a single row with its product categories grouped together. 'One row per product category' repeats the company on a separate row for each of its product categories — handy for spreadsheet filtering by category.

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

Maximum number of exhibitors to collect per run. Set to 0 to collect the entire directory. Leaving this blank uses the default of 100. Tip: start with 20–100 to preview the data, then increase.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.messe-stuttgart.de/cmt/en/exhibition/exhibitors-products/exhibitor-index/#/exhibitor"
  ],
  "outputFormat": "exhibitor",
  "maxResults": 100
}
```

# Actor output Schema

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

Key exhibitor fields: name, country, email, website, and profile link.

# 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.messe-stuttgart.de/cmt/en/exhibition/exhibitors-products/exhibitor-index/#/exhibitor"
    ],
    "outputFormat": "exhibitor",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/messe-stuttgart-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.messe-stuttgart.de/cmt/en/exhibition/exhibitors-products/exhibitor-index/#/exhibitor"],
    "outputFormat": "exhibitor",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/messe-stuttgart-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.messe-stuttgart.de/cmt/en/exhibition/exhibitors-products/exhibitor-index/#/exhibitor"
  ],
  "outputFormat": "exhibitor",
  "maxResults": 100
}' |
apify call solidcode/messe-stuttgart-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Messe Stuttgart Exhibitor Scraper",
        "description": "[💰 $4.00 / 1K] Extract exhibitor lists from any Messe Stuttgart trade fair — company names, addresses, emails, phones, websites, social links, hall/stand locations, contact persons, and product categories.",
        "version": "1.0",
        "x-build-id": "NQ3tVWZ9JdifLzauM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~messe-stuttgart-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-messe-stuttgart-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~messe-stuttgart-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-messe-stuttgart-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~messe-stuttgart-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-messe-stuttgart-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 Directory URLs",
                        "type": "array",
                        "description": "One or more Messe Stuttgart exhibitor-directory (exhibitor-list) page URLs. Open the fair you want on its event website, go to its exhibitor list, and paste the page URL here. The English version of the page is recommended. You can add several fairs to collect them all in one run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "outputFormat": {
                        "title": "Output Format",
                        "enum": [
                            "exhibitor",
                            "category"
                        ],
                        "type": "string",
                        "description": "How to shape the results. 'One row per exhibitor' keeps each company on a single row with its product categories grouped together. 'One row per product category' repeats the company on a separate row for each of its product categories — handy for spreadsheet filtering by category."
                    },
                    "maxResults": {
                        "title": "Max Exhibitors",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of exhibitors to collect per run. Set to 0 to collect the entire directory. Leaving this blank uses the default of 100. Tip: start with 20–100 to preview the data, then increase."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
