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

Export public IFA Berlin exhibitor leads with company names, countries, show areas, halls, stands, logos, profile URLs, and descriptions. No login required.

- **URL**: https://apify.com/automation-lab/messe-berlin-exhibitor-list-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/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 Berlin Exhibitor List Scraper

Export the public **IFA Berlin exhibitor list** as clean company and booth data.
This lightweight IFA exhibitor scraper collects names, countries, show areas, halls, stands, profile links, logos, and descriptions without a login or browser.
Use the ready-made input to get five current exhibitors, then scale to a full event lead list.

- 🎪 Built for the verified IFA Berlin 2026 exhibitor directory
- 📍 Preserves every booth location when one company has multiple stands
- 🔎 Optionally enriches every exhibitor from its public profile
- ⚡ Uses direct HTTP for low cost and fast scheduled refreshes
- 📦 Exports to JSON, CSV, Excel, XML, RSS, and API integrations

### What does Messe Berlin Exhibitor List Scraper do?

[Messe Berlin Exhibitor List Scraper](https://apify.com/automation-lab/messe-berlin-exhibitor-list-scraper) turns the public [IFA exhibitor directory](https://www.ifa-berlin.com/exhibitors) into structured lead records.
It follows listing pagination, deduplicates canonical profile URLs, and can open each profile for complete descriptions and authoritative location data.

Unlike a browser-based crawler, this Actor reads the server-rendered directory directly.
That means no login, API key, or expensive browser session is required for the supported IFA surface.
V1 intentionally supports IFA Berlin rather than claiming unverified templates from other Messe Berlin events.

### Who is it for?

**Event sales and partnership teams**

- Build a prospect list before IFA opens.
- Segment exhibitors by show area, country, hall, or stand.
- Refresh booth assignments as the event approaches.

**Agencies and B2B lead researchers**

- Discover brands attending a major consumer technology fair.
- Enrich CRM accounts with event participation and booth context.
- Prioritize outreach by category and geography.

**Exhibitors and sponsors**

- Map neighboring companies in the same hall.
- Compare category presence and event positioning.
- Prepare partner, media, or competitor meeting lists.

**Data and market-intelligence teams**

- Archive exhibitor snapshots for year-over-year comparisons.
- Feed public event data into a warehouse or dashboard.
- Monitor additions and booth changes with scheduled runs.

### Why use this Messe Berlin exhibitor extractor?

- ✅ **Useful lead records:** get company, country, category, booth, profile, logo, and description fields.
- ✅ **Multiple booths preserved:** `boothLocations`, `halls`, and `stands` remain arrays.
- ✅ **No duplicate profiles:** canonical profile URLs are the record identity.
- ✅ **Resilient enrichment:** one unavailable profile does not discard listing-card data.
- ✅ **Small first run:** the prefilled input returns only five exhibitors.
- ✅ **Optional proxies:** direct access is the default, but Apify Proxy remains available.
- ✅ **Automation ready:** schedule runs, send webhooks, or consume datasets over API.
- ✅ **No code required:** configure the Actor from the Apify Console form.

### What IFA exhibitor data can you extract?

| Data group | Fields | Example |
|---|---|---|
| Event | `eventName`, `eventYear`, `sourceUrl` | IFA Berlin, 2026 |
| Company | `companyName`, `country` | Acer Inc., Taiwan |
| Category | `showAreas` | Computing & Gaming |
| Booth | `boothLocations`, `halls`, `stands` | CityCube Hall A, A5 |
| Profile | `profileUrl`, `description` | Canonical IFA profile and company summary |
| Media | `logoUrl` | Public exhibitor logo/image URL |
| Freshness | `scrapedAt` | ISO 8601 timestamp |

Listing-only mode normally fills company, category, booth, country, profile URL, and card image.
Profile enrichment adds the full public description and uses the profile's canonical fields.
Optional fields are omitted when the source does not publish them; arrays remain arrays for predictable filtering.

### How much does it cost to scrape IFA Berlin exhibitors?

This Actor uses **pay-per-event** pricing.
The current price is a $0.005 run-start charge plus a tiered fee for each unique exhibitor saved.
All Apify platform compute is included.

| Plan tier | Price per exhibitor |
|---|---:|
| Free | $0.00010913 |
| Bronze | $0.000094896 |
| Silver | $0.000074019 |
| Gold | $0.000056938 |
| Platinum | $0.000037959 |
| Diamond | $0.000026571 |

**Computed actor-charge examples** (the $0.005 start charge + exhibitors × the applicable per-exhibitor rate): Free costs about $0.0159 for 100 exhibitors or $0.1141 for 1,000; Bronze costs about $0.0145 or $0.0999; Silver costs about $0.0124 or $0.0790; Gold costs about $0.0107 or $0.0619.
With $5 of free Apify credits, the current Free-tier rate covers roughly 45,700 enriched exhibitors after run-start charges—many complete IFA directory exports at current size.

Actual totals are capped by your Actor input and optional Apify maximum-charge setting.
The pricing table is kept synchronized with the Actor charge-event configuration.

### How to scrape the IFA Berlin exhibitor list

1. Open [Messe Berlin Exhibitor List Scraper](https://apify.com/automation-lab/messe-berlin-exhibitor-list-scraper).
2. Keep the prefilled `https://www.ifa-berlin.com/exhibitors` directory URL.
3. Choose the maximum exhibitors and listing pages.
4. Leave profile enrichment enabled for descriptions and canonical profile details.
5. Click **Start** and wait for the run to finish.
6. Open the Dataset tab to review companies and booth locations.
7. Export the dataset to JSON, CSV, Excel, or your integration.

Start with one page and five exhibitors.
For a larger export, increase both `maxPages` and `maxItems`; the Actor stops as soon as either boundary is reached.

### Input parameters

| Parameter | Type | Default | Purpose |
|---|---|---:|---|
| `listingUrl` | string | IFA exhibitors URL | Public English IFA directory, with optional filters |
| `maxItems` | integer | 20 | Maximum unique exhibitor records to save |
| `maxPages` | integer | 1 | Maximum directory pages to request |
| `enrichProfiles` | boolean | true | Open profiles for descriptions and canonical data |
| `proxyConfiguration` | object | direct connection | Optional Apify or custom proxy settings |

The directory URL must use an `ifa-berlin.com` host and an `/exhibitors` path.
The Actor preserves existing query filters and controls the `page` parameter itself.
Maximum limits protect runs from accidental unbounded crawling.

**Small enriched sample**

```json
{
  "listingUrl": "https://www.ifa-berlin.com/exhibitors",
  "maxPages": 1,
  "maxItems": 5,
  "enrichProfiles": true
}
````

**Faster listing-card export**

```json
{
  "listingUrl": "https://www.ifa-berlin.com/exhibitors",
  "maxPages": 10,
  "maxItems": 200,
  "enrichProfiles": false
}
```

**Paginated enriched export**

```json
{
  "listingUrl": "https://www.ifa-berlin.com/exhibitors",
  "maxPages": 5,
  "maxItems": 100,
  "enrichProfiles": true
}
```

### Output example

Each dataset item represents one exhibitor company.
Multiple locations are preserved instead of flattening or dropping additional stands.

```json
{
  "eventName": "IFA Berlin",
  "eventYear": 2026,
  "sourceUrl": "https://www.ifa-berlin.com/exhibitors",
  "profileUrl": "https://www.ifa-berlin.com/exhibitors/acer",
  "companyName": "Acer Inc.",
  "showAreas": ["Computing & Gaming"],
  "boothLocations": [
    { "hall": "CityCube Hall A", "stand": "A5" }
  ],
  "halls": ["CityCube Hall A"],
  "stands": ["A5"],
  "country": "Taiwan",
  "description": "Founded in 1976, Acer is one of the world's top ICT companies...",
  "logoUrl": "https://drive.ifa-berlin.com/drive/...png.webp",
  "scrapedAt": "2026-07-15T02:00:00.000Z"
}
```

Download the full nested item as JSON, or use the flattened `halls` and `stands` arrays for spreadsheet filters.
The dataset view links profile, source, and logo URL fields directly.

### Listing-only versus enriched profiles

Choose `enrichProfiles: false` when you need a quick directory snapshot and card-level fields are sufficient.
This requires only listing-page requests and is useful for frequent monitors.

Choose `enrichProfiles: true` when descriptions, canonical links, and profile-authoritative values matter.
The Actor requests each profile sequentially and retains card data if one enrichment request fails.

Both modes emit the same exhibitor entity shape in one dataset.
There is no mixed record type or discriminator to clean up downstream.

### Tips for reliable exhibitor lead exports

- 🔹 Start with five items to verify the fields you need.
- 🔹 Increase `maxPages` when `maxItems` is larger than one directory page.
- 🔹 Keep enrichment off for high-frequency change monitoring, then enrich final snapshots.
- 🔹 Schedule snapshots under distinct dataset names when comparing dates externally.
- 🔹 Use profile URL as your CRM deduplication key.
- 🔹 Join `halls` and `stands` by index only for display; use `boothLocations` for exact pairs.
- 🔹 If the source changes templates, inspect run logs and debug KV records.
- 🔹 Avoid residential proxy groups unless your own network requires them.

### Integrations and automation workflows

**IFA exhibitors → Google Sheets**

Schedule a weekly run, connect the default dataset to Google Sheets, and let a sales team tag owners and outreach status.

**IFA exhibitors → HubSpot or Salesforce**

Use profile URL as an external ID, company name as the account name, and booth data as event-campaign context.

**IFA exhibitors → Slack or Discord**

Compare a new snapshot with your previous export and notify a channel when new exhibitors appear.

**IFA exhibitors → Make or Zapier**

Trigger a run before campaign planning, iterate dataset items, and create enrichment or research tasks only for selected show areas.

**IFA exhibitors → data warehouse**

Pull JSON through the dataset API into BigQuery, Snowflake, or PostgreSQL for year-over-year participation analysis.

**Webhooks**

Attach a run-success webhook to launch downstream deduplication immediately after the dataset is ready.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/messe-berlin-exhibitor-list-scraper').call({
  listingUrl: 'https://www.ifa-berlin.com/exhibitors',
  maxPages: 2,
  maxItems: 40,
  enrichProfiles: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

The returned run object includes dataset and key-value-store IDs.
Use them to retrieve results, logs, and debug response snapshots.

### Use the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/messe-berlin-exhibitor-list-scraper').call(run_input={
    'listingUrl': 'https://www.ifa-berlin.com/exhibitors',
    'maxPages': 2,
    'maxItems': 40,
    'enrichProfiles': True,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['companyName'], item.get('stands', []))
```

Python users can stream items rather than loading the complete dataset into memory.

### Use the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~messe-berlin-exhibitor-list-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "listingUrl": "https://www.ifa-berlin.com/exhibitors",
    "maxPages": 1,
    "maxItems": 10,
    "enrichProfiles": true
  }'
```

Poll the returned run ID or use `waitForFinish` on the API endpoint, then fetch items from the run's default dataset.
Never expose your Apify token in client-side code or a public repository.

### Use with AI agents via MCP

Messe Berlin Exhibitor List Scraper can be called by AI assistants through Apify's [Model Context Protocol integration](https://docs.apify.com/platform/integrations/mcp).
The tool-specific URL keeps agent discovery focused on this Actor.

**Claude Code**

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

**Claude Desktop, Cursor, or VS Code**

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

Authentication uses your Apify account when the client connects.

Example prompts for MCP:

- “Use `automation-lab/messe-berlin-exhibitor-list-scraper` to export 50 current IFA exhibitors with profile descriptions.”
- “Find current IFA Computing & Gaming exhibitors and group their booths by hall.”
- “Create a fresh IFA exhibitor snapshot and tell me which companies have multiple stands.”

### Data quality and limitations

The Actor supports the verified public English IFA Berlin exhibitor directory template.
It does not claim that unrelated Messe Berlin event websites use the same markup.

Records reflect what IFA publishes at run time.
Some exhibitors may omit a description, logo, country, hall, or stand.
Booth assignments can change as organizers update the event directory.

The source currently serves complete HTML without login.
If IFA introduces a challenge or new template, optional proxy configuration may help with routing, but selectors could require an Actor update.
The Actor logs a clear error when the first listing page contains no recognized cards.

### Legality and responsible IFA exhibitor scraping

Public exhibitor information can generally be collected for legitimate research, event planning, and business intelligence.
Your use must still comply with applicable law, the source website's terms, privacy requirements, and outreach rules.

Do not use the dataset for spam, harassment, unlawful profiling, or attempts to access private information.
Collect only what you need, secure exported data, honor deletion or objection rights where applicable, and consult legal counsel for regulated workflows.
This Actor accesses public pages and does not bypass login controls.

### Troubleshooting

**Why did the run return fewer exhibitors than `maxItems`?**

`maxPages` is also a hard boundary.
Increase it if the requested item count exceeds the number of cards available on the pages crawled.
Source filters can also naturally reduce the available records.

**Why is a description missing?**

Descriptions require `enrichProfiles: true`, and some companies may not publish one.
If one profile request fails, the Actor intentionally retains the useful listing record.

**Why does the first page fail with “No exhibitor cards found”?**

Confirm that `listingUrl` is an English IFA exhibitor directory URL and not an article or unrelated event page.
If the URL is correct, IFA may have changed its directory template; share the run with support so selectors can be updated.

**Should I enable a proxy?**

Usually no.
Direct anonymous HTTP is the verified route and avoids proxy bandwidth cost.
Use Apify Proxy only when your network or geography produces repeatable access errors.

### FAQ

**How fast is the IFA exhibitor scraper?**

Listing-only runs usually finish quickly because each page contains many cards.
Enriched runs take longer because they open one public profile per saved exhibitor.
The prefilled five-item run is designed to finish well under two minutes.

**How much will my run cost?**

At current pricing, Free-tier users pay $0.005 once plus $0.00010913 per saved exhibitor.
A 100-item run is approximately $0.016 before rounding.

**Does IFA provide an official exhibitor API?**

This Actor does not require one.
It structures the same public directory and profile information visible to event visitors.

**Can I scrape every Messe Berlin event?**

Not with V1.
It supports the independently tested IFA directory; other event templates need separate verification before they can be promised reliably.

**Can I run it every week?**

Yes.
Use Apify schedules and store the run timestamp with each snapshot so you can compare additions and booth changes over time.

### Related event and lead scrapers

Build a broader trade-show prospecting workflow with other Automation Lab tools:

- [Messe Frankfurt Exhibitor List Scraper](https://apify.com/automation-lab/messe-frankfurt-exhibitor-list-scraper)
- [Messe Munich Exhibitor Scraper](https://apify.com/automation-lab/messe-munich-exhibitor-scraper)
- [NürnbergMesse Exhibitor List Scraper](https://apify.com/automation-lab/nuernberg-messe-exhibitor-list-scraper)
- [Deutsche Messe Exhibitor List Scraper](https://apify.com/automation-lab/deutsche-messe-exhibitor-list-scraper)
- [Map Your Show Exhibitor Scraper](https://apify.com/automation-lab/map-your-show-exhibitor-scraper)
- [German Imprint Leads Scraper](https://apify.com/automation-lab/german-imprint-leads-scraper)

Use source-specific actors when a fair runs on a different event platform.
Do not combine unrelated source URLs in this Actor; that keeps extraction behavior and output quality predictable.

### Support

If a valid IFA exhibitor URL stops producing expected records, open an Actor issue and share the run ID.
A shared run lets support inspect input, logs, and source-template errors without exposing your Apify token.

For best diagnosis, mention whether profile enrichment and proxies were enabled, the expected company or page, and when the source was last verified in a browser.

# Actor input Schema

## `listingUrl` (type: `string`):

Add the public English IFA Berlin exhibitor listing URL. Existing filter query parameters are preserved while pages are crawled.

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

Stop after this many unique exhibitor profiles have been collected.

## `maxPages` (type: `integer`):

Set how many listing pages to crawl. Each IFA page currently contains multiple exhibitor cards.

## `enrichProfiles` (type: `boolean`):

Open every exhibitor profile to collect the full description, canonical URL, profile logo, and authoritative location fields.

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

Optionally route requests through Apify Proxy. Direct HTTP works for the currently supported public IFA directory.

## Actor input object example

```json
{
  "listingUrl": "https://www.ifa-berlin.com/exhibitors",
  "maxItems": 5,
  "maxPages": 1,
  "enrichProfiles": 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 = {
    "listingUrl": "https://www.ifa-berlin.com/exhibitors",
    "maxItems": 5,
    "maxPages": 1,
    "enrichProfiles": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/messe-berlin-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 = {
    "listingUrl": "https://www.ifa-berlin.com/exhibitors",
    "maxItems": 5,
    "maxPages": 1,
    "enrichProfiles": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/messe-berlin-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 '{
  "listingUrl": "https://www.ifa-berlin.com/exhibitors",
  "maxItems": 5,
  "maxPages": 1,
  "enrichProfiles": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/messe-berlin-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-berlin-exhibitor-list-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Messe Berlin Exhibitor List Scraper",
        "description": "Export public IFA Berlin exhibitor leads with company names, countries, show areas, halls, stands, logos, profile URLs, and descriptions. No login required.",
        "version": "0.1",
        "x-build-id": "ZpiJcvVxclm3Zhji0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~messe-berlin-exhibitor-list-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-messe-berlin-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-berlin-exhibitor-list-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-messe-berlin-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-berlin-exhibitor-list-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-messe-berlin-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",
                "required": [
                    "listingUrl"
                ],
                "properties": {
                    "listingUrl": {
                        "title": "🎪 IFA exhibitor directory URL",
                        "type": "string",
                        "description": "Add the public English IFA Berlin exhibitor listing URL. Existing filter query parameters are preserved while pages are crawled.",
                        "default": "https://www.ifa-berlin.com/exhibitors"
                    },
                    "maxItems": {
                        "title": "📇 Maximum exhibitors",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Stop after this many unique exhibitor profiles have been collected.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "📄 Maximum directory pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Set how many listing pages to crawl. Each IFA page currently contains multiple exhibitor cards.",
                        "default": 1
                    },
                    "enrichProfiles": {
                        "title": "🔎 Enrich exhibitor profiles",
                        "type": "boolean",
                        "description": "Open every exhibitor profile to collect the full description, canonical URL, profile logo, and authoritative location fields.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optionally route requests through Apify Proxy. Direct HTTP works for the currently supported public IFA directory."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```