# TradeFairDates Events Scraper (`automation-lab/tradefairdates-events-scraper`) Actor

Extract trade fair and exhibition events from TradeFairDates with dates, venues, organizer details, and official websites.

- **URL**: https://apify.com/automation-lab/tradefairdates-events-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **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

## TradeFairDates Events Scraper

Scrape trade fair, exhibition, and conference listings from TradeFairDates into a clean Apify dataset.

### What does TradeFairDates Events Scraper do?

TradeFairDates Events Scraper extracts public event listings from TradeFairDates listing pages and optionally opens each event detail page for richer structured data.

It is built for trade-show research, exhibitor lead generation, market mapping, and event calendar workflows.

### Who is it for?

- 📈 Sales teams building trade fair prospect lists
- 🧭 Market researchers tracking events by country or category
- 🏭 Manufacturers looking for exhibition opportunities
- 🤝 Agencies planning event-based outreach campaigns
- 🗓️ Event teams maintaining internal calendars

### Why use this scraper?

TradeFairDates pages include public data about event names, dates, venues, cities, countries, descriptions, visitor restrictions, and organizer details. This Actor turns those pages into structured JSON, CSV, Excel, or API-ready results.

### What data can you extract?

| Field | Description |
| --- | --- |
| `name` | Event or trade fair name |
| `url` | TradeFairDates detail URL |
| `datesText` | Human-readable date text from listings |
| `startDate` | ISO start date from JSON-LD when available |
| `endDate` | ISO end date from JSON-LD when available |
| `city` | Event city |
| `country` | Event country |
| `venue` | Venue or exhibition center |
| `venueAddress` | Public venue street/address when available |
| `category` | Listing category or sector label |
| `description` | Public event description |
| `visitorRestriction` | Visitor access note, such as professional visitors only |
| `organizerName` | Organizer name from detail page |
| `organizerUrl` | Organizer website when public |
| `eventWebsite` | Official event website when public |
| `sourceListingUrl` | Listing page where the event was found |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape TradeFairDates events?

This Actor uses pay-per-event pricing. The validated Bronze price is about $0.0855 per 1,000 saved events plus a $0.005 run start fee, with lower per-result prices on higher Apify plans. Cloud validation showed the realistic 120-result run cost $0.00246 in platform usage.

### How to use

1. Open the Actor on Apify.
2. Paste one or more TradeFairDates listing URLs.
3. Set the maximum number of events.
4. Keep detail pages enabled for richer dates, organizer, and venue fields.
5. Run the Actor.
6. Export the dataset as JSON, CSV, Excel, XML, or HTML.

### Input options

#### Start URLs

Use TradeFairDates listing pages such as country, city, or category pages. Example:

```json
[
  { "url": "https://www.tradefairdates.com/Trade-Shows-Germany-Z55-S1.html" }
]
````

#### Maximum events

Controls how many event rows are saved across all start URLs.

#### Open detail pages

When enabled, the Actor follows each event URL and extracts JSON-LD fields such as start date, end date, venue address, and organizer.

#### Maximum pages per start URL

Controls pagination depth. Keep this low for test runs, then increase for production collection.

### Output example

```json
{
  "name": "Interschutz Hanover",
  "url": "https://www.tradefairdates.com/Interschutz-M4488/Hanover.html",
  "datesText": "01. - 06. June 2026",
  "startDate": "2026-06-01",
  "endDate": "2026-06-06",
  "city": "Hanover",
  "country": "DE",
  "venue": "Hannover Messegelände",
  "description": "International Exhibition for Rescue, Fire Prevention, Disaster Relief, Safety and Security",
  "organizerName": "Deutsche Messe AG",
  "eventWebsite": "https://www.interschutz.de",
  "sourceListingUrl": "https://www.tradefairdates.com/Trade-Shows-Germany-Z55-S1.html",
  "scrapedAt": "2026-06-02T00:00:00.000Z"
}
```

### Tips for best results

- ✅ Start with a country or category listing URL.
- ✅ Use `maxEvents` for predictable run size.
- ✅ Enable detail pages when you need organizer or venue address fields.
- ✅ Increase pagination only after a small successful test.
- ✅ Export CSV for sales operations and enrichment workflows.

### Integrations

Use the dataset with:

- CRM imports for event-based lead routing
- Google Sheets via Apify integrations
- Make or Zapier workflows for notifications
- Internal BI dashboards for event coverage
- Enrichment tools that append exhibitor or company data

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tradefairdates-events-scraper').call({
  startUrls: [{ url: 'https://www.tradefairdates.com/Trade-Shows-Germany-Z55-S1.html' }],
  maxEvents: 25,
  includeDetails: true
});

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

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY_APIFY_TOKEN')
run = client.actor('automation-lab/tradefairdates-events-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.tradefairdates.com/Trade-Shows-Germany-Z55-S1.html'}],
    'maxEvents': 25,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~tradefairdates-events-scraper/runs?token=MY_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.tradefairdates.com/Trade-Shows-Germany-Z55-S1.html"}],"maxEvents":25,"includeDetails":true}'
```

### MCP usage

Connect this Actor through Apify MCP:

```text
https://mcp.apify.com/?tools=automation-lab/tradefairdates-events-scraper
```

Claude Code CLI setup:

```bash
claude mcp add apify-tradefairdates https://mcp.apify.com/?tools=automation-lab/tradefairdates-events-scraper
```

Desktop JSON configuration example:

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

MCP example prompts:

- "Use MCP to run the TradeFairDates scraper, collect 50 German trade fairs from this URL, and summarize top sectors."
- "Run the TradeFairDates MCP tool and return only organizer names, event websites, and venue cities."
- "Create a CSV-ready event calendar from these TradeFairDates pages using the Apify MCP tool."

### Data quality notes

TradeFairDates detail pages often include JSON-LD. The Actor prefers that structured data when available and falls back to visible listing text when detail fields are missing.

### Pagination

The Actor follows the `rel=next` pagination link. Use `maxPagesPerStartUrl` to limit breadth and control costs.

### Error handling

If a detail page fails, the Actor keeps the listing data instead of dropping the event. If a listing URL fails, it logs a warning and continues with the next URL.

### Legality and responsible use

This Actor extracts publicly available information. You are responsible for using the data in compliance with TradeFairDates terms, applicable laws, privacy rules, and outreach regulations.

### FAQ

#### Does it require a TradeFairDates account?

No. The Actor is designed for public listing and detail pages that are visible without login.

#### Can it scrape exhibitor lists?

This MVP focuses on event and trade fair listings. Exhibitor extraction would be a separate feature if the source exposes public exhibitor pages.

#### Why are some organizer fields empty?

Some TradeFairDates pages do not publish every organizer/contact field. The Actor only returns fields visible in public HTML or JSON-LD.

#### What if I get fewer results than requested?

The selected listing URL may have fewer available events or pagination may be capped by `maxPagesPerStartUrl`. Increase pagination or add more start URLs.

### Related scrapers

- https://apify.com/automation-lab/10times-events-scraper
- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/eventbrite-scraper

### Changelog

#### 0.1

Initial version for public TradeFairDates event listing and detail extraction.

### Support

If a public TradeFairDates page does not extract correctly, share the run URL and input so we can inspect the page shape.

### Development notes

This Actor uses HTTP requests and Cheerio. It does not require Playwright for the current public listing pages.

### Store readiness

The Actor includes low prefill values, structured dataset schema, PPE charge events, and HTTP-only memory settings.

### Example start URL

`https://www.tradefairdates.com/Trade-Shows-Germany-Z55-S1.html`

### Result formats

Use Apify dataset export options for JSON, CSV, XLSX, XML, RSS, or HTML table exports.

# Actor input Schema

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

TradeFairDates listing pages such as country/category result pages. Detail pages linked from listings are followed automatically when details are enabled.

## `maxEvents` (type: `integer`):

Maximum number of event records to save across all start URLs.

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

Follow each event detail URL to extract structured dates, organizer, venue address, and official website when available.

## `maxPagesPerStartUrl` (type: `integer`):

How many paginated listing pages to follow for each start URL.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tradefairdates.com/Trade-Shows-Germany-Z55-S1.html"
    }
  ],
  "maxEvents": 20,
  "includeDetails": true,
  "maxPagesPerStartUrl": 1
}
```

# 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://www.tradefairdates.com/Trade-Shows-Germany-Z55-S1.html"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tradefairdates-events-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://www.tradefairdates.com/Trade-Shows-Germany-Z55-S1.html" }] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tradefairdates-events-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://www.tradefairdates.com/Trade-Shows-Germany-Z55-S1.html"
    }
  ]
}' |
apify call automation-lab/tradefairdates-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradeFairDates Events Scraper",
        "description": "Extract trade fair and exhibition events from TradeFairDates with dates, venues, organizer details, and official websites.",
        "version": "0.1",
        "x-build-id": "a2dbElbiCIt32LKpA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~tradefairdates-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-tradefairdates-events-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~tradefairdates-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-tradefairdates-events-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~tradefairdates-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-tradefairdates-events-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": "TradeFairDates listing pages such as country/category result pages. Detail pages linked from listings are followed automatically when details are enabled.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxEvents": {
                        "title": "Maximum events",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of event records to save across all start URLs.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Open detail pages",
                        "type": "boolean",
                        "description": "Follow each event detail URL to extract structured dates, organizer, venue address, and official website when available.",
                        "default": true
                    },
                    "maxPagesPerStartUrl": {
                        "title": "Maximum pages per start URL",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many paginated listing pages to follow for each start URL.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
