# Messe Munich Exhibitor Scraper (`automation-lab/messe-munich-exhibitor-scraper`) Actor

Extract Messe München exhibitor leads: companies, booths, contacts, emails, websites, addresses, categories, and profile URLs from public directories.

- **URL**: https://apify.com/automation-lab/messe-munich-exhibitor-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **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 Munich Exhibitor Scraper

Extract exhibitor lead data from public Messe München / JL Medien event directories.

Use this actor to turn public exhibitor lists for events such as electronica, ISPO, EXPO REAL, automatica, and other Messe München portals into a clean dataset with company names, profile URLs, booth numbers, contact details, websites, descriptions, and event context.

### What does Messe Munich Exhibitor Scraper do?

Messe Munich Exhibitor Scraper collects public exhibitor records from Messe München exhibitor portals.

It can start from a directory URL or a specific exhibitor profile URL.

For each exhibitor, it saves a structured row in the Apify dataset.

When profile detail extraction is enabled, the actor also visits each public exhibitor profile page.

That profile visit can add phone numbers, email addresses, websites, addresses, descriptions, logos, and image URLs when the source page publishes them.

### Who is it for?

Sales teams use it to build prospect lists before and after trade shows.

Business development teams use it to identify companies exhibiting in a target industry.

Marketing agencies use it to enrich event-account lists for campaign planning.

Event-networking tools use it to import public exhibitor directories into their own workflows.

Market researchers use it to monitor which companies appear at Messe München shows over time.

Recruiters and partnership teams can also use it to discover companies active in specific event categories.

### Why use this actor?

🎪 It is built for Messe München exhibitor portals.

📇 It extracts lead-generation fields, not just links.

⚡ It uses HTTP extraction, so it is lightweight and does not require a browser for normal runs.

🌐 Proxy use is optional because the tested pages are public HTML.

🧾 Output is a normal Apify dataset, ready for export to CSV, JSON, Excel, Google Sheets, or an API workflow.

### Supported Messe München URLs

Use public exhibitor directory URLs such as:

`https://exhibitors.electronica.de/ausstellerportal/2024/aussteller/`

You can also provide public exhibitor profile URLs.

The actor is designed for the JL Medien / Messe München portal structure where list pages contain `/ausstellerdetails/` profile links.

If an event uses a substantially different technology stack, start with a small test run.

### What data can you extract?

The actor can save the following fields when available:

| Field | Description |
| --- | --- |
| `companyName` | Exhibitor company name |
| `eventName` | Event inferred from the exhibitor portal host |
| `eventYear` | Event year inferred from the URL or page title |
| `profileUrl` | Public exhibitor profile URL |
| `sourceUrl` | Directory or profile URL used as input |
| `booth` | Booth number such as `C5.159` |
| `hall` | Hall prefix inferred from booth, such as `C5` |
| `exhibitorType` | Public exhibitor type label |
| `location` | List or profile location text |
| `address` | Full public address from the profile |
| `country` | Country parsed from the location/address |
| `phone` | Public phone number |
| `email` | Public email address |
| `website` | Public company website |
| `description` | Public summary or profile text |
| `categories` | Public category/class tags when available |
| `productTags` | Public product or service terms when available |
| `logoUrl` | Main exhibitor logo URL |
| `imageUrls` | Related public image URLs |
| `scrapedAt` | ISO timestamp for the scrape |

### How much does it cost to scrape Messe Munich exhibitors?

This actor uses pay-per-event pricing.

There is a small run-start event and a per-exhibitor result event.

Pricing is set from measured cloud costs with tiered per-result discounts.

For small tests, keep `maxItems` low.

For full directories, increase `maxItems` to the volume you need.

### How to use Messe Munich Exhibitor Scraper

1. Open the actor on Apify.

2. Paste one or more public Messe München exhibitor directory URLs into **Start URLs**.

3. Set **Maximum exhibitors**.

4. Keep **Include profile details** enabled if you need email, phone, website, and address fields.

5. Leave proxy disabled unless your network is blocked.

6. Start the run.

7. Export the dataset when the run finishes.

### Input configuration

#### Start URLs

Provide directory or profile URLs.

Directory URLs are best for collecting many exhibitors.

Profile URLs are useful when you already have specific companies to enrich.

#### Maximum exhibitors

Controls the maximum number of saved records across all provided URLs.

Use a small value for the first run.

Use a larger value for complete lead lists.

#### Include profile details

When enabled, the actor visits each profile URL and extracts public contact fields.

When disabled, the actor saves faster list-level records with fewer contact details.

#### Proxy configuration

Proxy is optional.

The tested Messe München pages are public and work with normal HTTP requests.

If you see network-level blocks from your environment, enable Apify Proxy and retry with a small `maxItems` value.

### Example input

```json
{
  "startUrls": [
    {
      "url": "https://exhibitors.electronica.de/ausstellerportal/2024/aussteller/"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Example output

```json
{
  "eventName": "electronica",
  "eventYear": "2024",
  "companyName": "AKTINA CDS GmbH",
  "booth": "C5.159",
  "hall": "C5",
  "country": "Deutschland",
  "phone": "+49 6103 83980-0",
  "email": "info@aktina-cds.com",
  "website": "https://www.aktina-cds.com/",
  "profileUrl": "https://exhibitors.electronica.de/ausstellerportal/2024/aussteller/ausstellerdetails/aktina-cds-gmbh/?elb=807.1100.9354.1.111&uls=2"
}
```

### Tips for best results

Start with `maxItems` set to 10 or 20.

Review the dataset fields.

Then run a larger extraction.

Use `includeDetails: false` only when you need a quick directory scan without contact enrichment.

Use direct event directory URLs rather than the event home page.

### Pagination support

The actor follows the public list pagination form used by the exhibitor portal.

It reads the first result page from the directory HTML.

Then it requests additional pages from the public `page.cfm` endpoint until it reaches `maxItems` or the list ends.

### Integrations

Export the dataset to CSV for CRM import.

Send rows to Google Sheets using Apify integrations.

Connect the actor to Zapier or Make for lead routing.

Use webhooks to trigger enrichment after each finished run.

Use the Apify API to schedule periodic event-directory checks.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/messe-munich-exhibitor-scraper').call({
  startUrls: [{ url: 'https://exhibitors.electronica.de/ausstellerportal/2024/aussteller/' }],
  maxItems: 20,
  includeDetails: true,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/messe-munich-exhibitor-scraper').call(run_input={
    'startUrls': [{'url': 'https://exhibitors.electronica.de/ausstellerportal/2024/aussteller/'}],
    'maxItems': 20,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~messe-munich-exhibitor-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://exhibitors.electronica.de/ausstellerportal/2024/aussteller/"}],"maxItems":20,"includeDetails":true}'
```

### MCP usage

You can use this actor through Apify MCP tools in Claude Code or Claude Desktop.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/messe-munich-exhibitor-scraper`

Claude Code setup:

```bash
claude mcp add apify-messe-munich "https://mcp.apify.com/?tools=automation-lab/messe-munich-exhibitor-scraper"
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify-messe-munich": {
      "url": "https://mcp.apify.com/?tools=automation-lab/messe-munich-exhibitor-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the first 50 exhibitors from this Messe München directory and return companies with email addresses."

- "Run the Messe Munich Exhibitor Scraper for electronica 2024 and summarize countries represented."

- "Export Messe exhibitor leads with booth numbers and websites."

### Data quality notes

The actor saves only data that is publicly visible on the source pages.

Some exhibitors may not publish email, phone, or website fields.

Some event portals expose richer category labels than others.

Booth and hall values depend on the event page markup.

### FAQ

#### Can I scrape Messe München directories without logging in?

Yes. The actor is designed for public exhibitor directories and public profile pages. It does not use private account or favorites features.

#### Does this actor work for every Messe event?

It works best with Messe München / JL Medien exhibitor portals that expose `/ausstellerdetails/` profile links. If you have a new event URL, run a small test first.

### Troubleshooting

#### Why are email or phone fields empty?

The exhibitor may not publish those fields on the public profile page.

Make sure **Include profile details** is enabled.

#### Why did I get fewer results than expected?

The directory may contain fewer public records than your `maxItems` value, or the provided URL may point to a filtered list.

Try the main exhibitor directory URL for the event.

#### Should I enable proxy?

Leave proxy disabled first.

Enable Apify Proxy only if your run fails due to network blocking.

### Legality and responsible use

This actor extracts publicly available business directory information.

You are responsible for using the data according to applicable laws, event website terms, privacy rules, and anti-spam regulations.

Do not use extracted contact details for unlawful outreach.

Respect opt-out requests and local compliance requirements.

### Related scrapers

Explore related Automation Lab actors:

- https://apify.com/automation-lab/map-your-show-exhibitor-scraper

- https://apify.com/automation-lab/messe-frankfurt-exhibitor-scraper

- https://apify.com/automation-lab/messe-duesseldorf-exhibitor-scraper

- https://apify.com/automation-lab/koelnmesse-exhibitor-scraper

### Limitations

The actor is optimized for Messe München / JL Medien exhibitor portals.

It does not log in.

It does not access favorites, private account features, or non-public lead tools.

It does not bypass CAPTCHAs or authentication walls.

### Changelog

Initial version:

- HTTP/Cheerio list extraction.

- Public profile contact enrichment.

- Pagination through the portal form endpoint.

- Dataset schema for exhibitor leads.

### Support

If a public Messe München directory URL does not work, provide the exact URL and a short description of the missing fields.

Start with a small `maxItems` value when reporting reproducibility issues.

# Actor input Schema

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

One or more public Messe München exhibitor directory or exhibitor profile URLs, such as electronica, ISPO, EXPO REAL, automatica, or other JL Medien portals.

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

Maximum number of exhibitor records to save across all start URLs. Keep this low for a quick test run.

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

Visit each exhibitor profile page to extract phone, email, website, address, categories, product tags, and images when available.

## `proxyConfiguration` (type: `object`):

Optional proxy settings. Leave disabled unless your network is blocked; the public Messe pages usually work over normal HTTP.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://exhibitors.electronica.de/ausstellerportal/2024/aussteller/"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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://exhibitors.electronica.de/ausstellerportal/2024/aussteller/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/messe-munich-exhibitor-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://exhibitors.electronica.de/ausstellerportal/2024/aussteller/" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/messe-munich-exhibitor-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://exhibitors.electronica.de/ausstellerportal/2024/aussteller/"
    }
  ]
}' |
apify call automation-lab/messe-munich-exhibitor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Messe Munich Exhibitor Scraper",
        "description": "Extract Messe München exhibitor leads: companies, booths, contacts, emails, websites, addresses, categories, and profile URLs from public directories.",
        "version": "0.1",
        "x-build-id": "OCRkA6KQhrM85q2gk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~messe-munich-exhibitor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-messe-munich-exhibitor-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-munich-exhibitor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-messe-munich-exhibitor-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-munich-exhibitor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-messe-munich-exhibitor-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "One or more public Messe München exhibitor directory or exhibitor profile URLs, such as electronica, ISPO, EXPO REAL, automatica, or other JL Medien portals.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum exhibitors",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of exhibitor records to save across all start URLs. Keep this low for a quick test run.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Include profile details",
                        "type": "boolean",
                        "description": "Visit each exhibitor profile page to extract phone, email, website, address, categories, product tags, and images when available.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Leave disabled unless your network is blocked; the public Messe pages usually work over normal HTTP.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
