# 10times Events Scraper — Trade Shows, Conferences & Venues (`khadinakbar/10times-events-scraper`) Actor

Scrape trade shows, conferences, and exhibitions from 10times.com (200K+ events, 100+ industries). Flat records with ISO dates, venue + GPS, organizer, categories, visitor estimates, and event URL. Three input modes (URLs / search / city). MCP-ready, residential proxy, JSON-LD.

- **URL**: https://apify.com/khadinakbar/10times-events-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 event scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## 10times Events Scraper — Trade Shows, Conferences & Exhibitions

Scrape trade shows, conferences, exhibitions, and workshops from **10times.com** — the largest B2B events database (200,000+ events across 100+ industries). Returns flat, MCP-ready records per event: ISO dates, venue with GPS coordinates, organizer, industry categories, attendance estimates, and the canonical 10times URL.

Three input modes (URL, search, city), Cloudflare-grade residential proxies by default, and JSON-LD-first extraction for resilient field coverage.

### What you get

| Field | Type | Description |
|---|---|---|
| `eventId` | string | 10times URL slug (stable primary key per edition) |
| `eventName` | string | Event title |
| `eventUrl` | string | Canonical detail URL |
| `startDate` / `endDate` | ISO 8601 | Start and end dates |
| `status` | enum | `EventScheduled`, `EventCancelled`, `EventPostponed` |
| `eventType` | enum | `tradeshow` / `conference` / `workshop` / `festival` / `event` |
| `frequency` | string | Recurrence (Annual, Biennial, One-time, …) |
| `description` | string | Plain-text description |
| `language` | string | Primary language code |
| `isOnline` / `attendanceMode` | bool / enum | Virtual flag + Schema.org attendance mode |
| `venueName`, `address`, `city`, `region`, `country`, `countryCode`, `postalCode`, `lat`, `lng` | mixed | Full venue with GPS coords |
| `organizerName`, `organizerUrl`, `organizerWebsite` | string | Organizer details (B2B lead surface) |
| `categories` | array | Industry tags (e.g. `['Technology', 'Consumer Electronics']`) |
| `productTags` | array | Product/topic tags from the detail page |
| `visitorEstimate`, `exhibitorEstimate` | string | Audience size when published |
| `rating`, `followers`, `score` | numbers | Social signals when available |
| `priceInfo`, `currency` | string | Pricing summary |
| `imageUrl` | string | Event cover image |
| `scrapedAt` | ISO 8601 | Scrape timestamp (UTC) |

Typical record size: **~400 tokens** — built to fit inside an AI agent's context window without crowding out reasoning.

### When to use this Actor

- **B2B sales prospecting** — find decision-makers attending or organizing relevant events
- **Sponsorship and exhibitor research** — qualify events by visitor estimate, frequency, rating
- **Competitive intelligence** — track where competitors exhibit
- **Event-tech aggregation** — build niche directories with structured data
- **AI agent workflows** — "find me fintech conferences in Berlin in Q3 2026"

### When NOT to use this Actor

- For ticket sales / cultural events with paid tickets, use the `eventbrite-events-scraper` instead
- For Facebook event discovery, see `data-slayer/facebook-search-events`
- For LinkedIn event scraping, use `linkedin-jobs-scraper` (events live under LinkedIn Events; not currently supported here)

### Pricing — Pay Per Event (premium tier)

| Event | Price | Notes |
|---|---|---|
| `apify-actor-start` | **$0.00005** | Charged once per run (per GB of memory) |
| `event-scraped` | **$0.005** | Charged once per event returned in the dataset |

**Typical run cost:**
- 50 events: ~$0.25
- 500 events: ~$2.50
- 1,000 events: ~$5.00

Both **PPE** and **Pay-Per-Usage** are enabled on this Actor — buyers can pick either at run time. PPE gives you predictable per-event billing; Pay-Per-Usage suits heavy users running multi-thousand-event jobs.

### Input — three modes (pick one)

#### Mode 1: Start URLs
Paste 10times URLs directly. Supports event detail pages, city listings, category listings, and search URLs.

```json
{
  "startUrls": [
    "https://10times.com/ces-las-vegas",
    "https://10times.com/berlin",
    "https://10times.com/conferences"
  ],
  "maxItems": 100
}
````

#### Mode 2: Search query

Free-text search across all of 10times. Combine with country and date filters.

```json
{
  "searchQuery": "fintech",
  "country": "DE",
  "startDate": "2026-06-01",
  "endDate": "2026-12-31",
  "maxItems": 50
}
```

#### Mode 3: City slug

Browse all events in a given city. Combine with industry category, event type, and dates.

```json
{
  "city": "berlin",
  "eventType": "conference",
  "category": "technology",
  "maxItems": 50
}
```

#### All input fields

- `startUrls` — array of 10times URLs (mutually exclusive with searchQuery + city)
- `searchQuery` — free-text keyword
- `city` — city slug (e.g. `berlin`, `new-york-us`, `dubai-ae`)
- `country` — ISO 3166-1 alpha-2 (`US`, `GB`, `DE`, …) or `WW` for worldwide
- `eventType` — `all` / `tradeshow` / `conference` / `workshop` / `festival`
- `category` — industry slug (`technology`, `medical`, `food`, …)
- `startDate` / `endDate` — YYYY-MM-DD
- `onlineOnly` — boolean
- `maxItems` — integer (default 50, max 10,000)
- `includeDetails` — boolean (fetch detail pages for organizer, description, estimates)
- `proxyConfiguration` — Apify proxy override (defaults to RESIDENTIAL)

### Output

JSON dataset, one event per record. Sample:

```json
{
  "eventId": "ces-las-vegas",
  "eventName": "CES 2026",
  "eventUrl": "https://10times.com/ces-las-vegas",
  "startDate": "2026-01-06",
  "endDate": "2026-01-09",
  "status": "EventScheduled",
  "eventType": "tradeshow",
  "frequency": "Annual",
  "description": "The most powerful tech event in the world...",
  "isOnline": false,
  "attendanceMode": "OfflineEventAttendanceMode",
  "venueName": "Las Vegas Convention Center",
  "city": "Las Vegas",
  "region": "NV",
  "country": "United States",
  "countryCode": "US",
  "lat": 36.1316,
  "lng": -115.1521,
  "organizerName": "Consumer Technology Association",
  "categories": ["Consumer Electronics", "Technology"],
  "visitorEstimate": "100,000+",
  "exhibitorEstimate": "4,000+",
  "rating": 4.5,
  "priceInfo": "Paid",
  "currency": "USD",
  "imageUrl": "https://10times.com/img/ces-2026.jpg",
  "scrapedAt": "2026-05-13T09:42:00.000Z"
}
```

### Usage examples

#### Apify CLI

```bash
apify call khadinakbar/10times-events-scraper --input='{"city":"berlin","eventType":"conference","maxItems":20}'
```

#### Apify API (HTTP)

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~10times-events-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQuery":"fintech","country":"DE","maxItems":50}'
```

#### Apify Node.js SDK

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/10times-events-scraper').call({
    city: 'singapore',
    eventType: 'tradeshow',
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient(token="...")
run = client.actor("khadinakbar/10times-events-scraper").call(run_input={
    "searchQuery": "medical devices",
    "country": "US",
    "maxItems": 50,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

#### As an MCP tool (Claude / GPT / Gemini)

This Actor is exposed at `apify--10times-events-scraper` on the Apify MCP server. Add `https://mcp.apify.com?tools=khadinakbar/10times-events-scraper` to your MCP client; agents call it like any other tool.

### How it works (technical notes)

- **Discovery:** listing pages (city, category, search) are parsed for outbound event-detail URLs. Two sources are merged: JSON-LD blocks (when present) and DOM anchor scraping with a strict pattern (`https://10times.com/<slug>` where slug is a single segment).
- **Extraction:** each detail page is scanned for `application/ld+json` blocks with `@type: Event` (or subtypes — `BusinessEvent`, `ExhibitionEvent`, `Festival`, etc.). 10times publishes Schema.org `Event` schema reliably; the JSON-LD is the primary structured surface for dates, venue, geo, organizer, offers.
- **Enrichment:** DOM fallback fills 10times-specific fields not in JSON-LD (visitor/exhibitor estimates, rating, followers, frequency, product tags).
- **Anti-bot:** 10times sits behind Cloudflare (server: cloudflare, cf-ray header confirmed). Residential proxies are mandatory and the default. Session pool with `maxUsageCount: 25` plus `Sec-Fetch-*` headers, real `User-Agent`, and `Accept-Language` aligned to a real browser. 403/429/503 retire the session and retry.
- **Pagination:** listing pages use `?page=N` query parameter. Crawler keeps requesting next page until `maxItems` is met or the listing is exhausted.
- **Filters:** `eventType`, `category`, `startDate`, `endDate`, and `onlineOnly` are applied client-side after detail enrichment to avoid relying on undocumented URL-parameter behavior.

### FAQ

**Q: Why do I sometimes see 0 events on a city page?**
A: Some 10times city slugs differ from the obvious spelling (e.g. `new-york-us`, not `new-york`). When in doubt, paste the URL directly into `startUrls` — your browser address bar is the source of truth.

**Q: Does this work for past events?**
A: 10times lists historical events under the same URL pattern. Pass an older event slug in `startUrls` and you'll get the same structured record.

**Q: How does this compare to other 10times scrapers on the Store?**
A: Two direct competitors exist — `zen-studio/10times-events-scraper` (129 users, $0.003–0.00349/event, 12-input UI, hard-coded city ID enum) and `crawlerbros/tentimes-events-scraper` (4 users, $0.002/result + $0.005 start, no MCP framing). This Actor: simpler 3-input model, MCP-ready flat output, premium-tier reliability target (>95% success rate), full Schema.org `@type` coverage including BusinessEvent / ExhibitionEvent / Festival.

**Q: Why no `ticketTiers` array?**
A: 10times rarely publishes structured per-tier pricing. Most events show a single price summary or "Paid"/"Free" tag. We capture the summary in `priceInfo` and parsed currency in `currency` — that's the entire pricing signal available.

**Q: Can I use this for organizer-only lookups?**
A: Not currently. Each run starts from event listings. If you need to enumerate all events organized by a specific company, build a list of event URLs from the organizer's 10times page and pass them as `startUrls`.

**Q: Does it handle Cloudflare challenge pages?**
A: Yes — challenges are detected as 403/503 responses, the failing session is retired, and a fresh residential IP is selected. If all sessions in the pool fail consistently, the failure surfaces in the run summary as a `blocked` count rather than silently retrying forever.

### Cross-sell — pairs well with

- [`khadinakbar/universal-lead-finder`](https://apify.com/khadinakbar/universal-lead-finder) — turn organizer names into B2B leads
- [`khadinakbar/b2b-lead-finder-enrichment`](https://apify.com/khadinakbar/b2b-lead-finder-enrichment) — enrich attending companies
- [`khadinakbar/linkedin-profile-email-scraper`](https://apify.com/khadinakbar/linkedin-profile-email-scraper) — get attendee/organizer emails from LinkedIn
- [`khadinakbar/eventbrite-events-scraper`](https://apify.com/khadinakbar/eventbrite-events-scraper) — complement with smaller / cultural events
- [`khadinakbar/google-maps-leads-scraper`](https://apify.com/khadinakbar/google-maps-leads-scraper) — pair venue cities with local lead lists

### Legal & compliance

This Actor extracts publicly available event listings from 10times.com without bypassing authentication or paywalls. You are responsible for compliance with 10times' Terms of Service, GDPR / CCPA, and any local data-protection law applicable to your use of the output. Organizer / venue contact data is business-purpose information; treat any future personal-data extraction with explicit consent. We do not scrape RSVP lists, attendee directories, or any data behind login.

### Built by Khadin Akbar

Part of the [khadinakbar Apify portfolio](https://apify.com/khadinakbar) — 50+ production scrapers across lead generation, social media, e-commerce, and SEO. Built with Claude Code and Claude Opus 4.7.

# Actor input Schema

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

Direct 10times URLs to scrape. Accepts event detail pages (e.g. 'https://10times.com/ces-las-vegas'), city listing pages ('https://10times.com/berlin', 'https://10times.com/new-york-us'), category listings ('https://10times.com/conferences', 'https://10times.com/technology-events'), or search URLs ('https://10times.com/?query=fintech'). Mutually exclusive with searchQuery and city — use this for fully custom filtering 10times exposes in its UI but this Actor's inputs do not surface.

## `searchQuery` (type: `string`):

Free-text keyword to search 10times (e.g. 'fintech', 'medical devices', 'sustainability'). Combined with country and eventType filters when provided. Leave empty when using startUrls or browsing by city alone. NOT an event slug and NOT a full URL — for those use startUrls.

## `city` (type: `string`):

10times city slug used in URLs (e.g. 'berlin', 'new-york-us', 'london-uk', 'singapore', 'dubai-ae', 'sao-paulo-br'). Combined with eventType, category, and date filters. Leave empty when using startUrls or searchQuery. NOT a free-text city name — must be the URL slug 10times uses on its city pages.

## `country` (type: `string`):

Two-letter ISO country code to scope a search query to one country (e.g. 'US', 'DE', 'GB', 'IN', 'AE'). Use 'WW' or leave blank for worldwide. Ignored when city is set (city already implies country). NOT a country name — must be the ISO 3166-1 alpha-2 code.

## `eventType` (type: `string`):

Filter by event format. 'tradeshow' = exhibitions and trade fairs, 'conference' = paid speaker conferences, 'workshop' = hands-on training, 'festival' = public/cultural events. Applied client-side on discovered events. Defaults to 'all'.

## `category` (type: `string`):

Industry filter applied to event categories and description tags. Leave 'all' to include every industry. Use this with city/searchQuery to narrow by sector (e.g. 'technology' + 'berlin' = Berlin tech events). NOT a free-text industry name — must be one of the listed slugs.

## `startDate` (type: `string`):

Only return events starting on or after this date. Format YYYY-MM-DD (e.g. '2026-06-01'). Leave empty for all upcoming events. NOT a date range — pair with endDate to bound on both sides.

## `endDate` (type: `string`):

Only return events starting on or before this date. Format YYYY-MM-DD (e.g. '2026-12-31'). Leave empty for no upper bound. Pair with startDate for a bounded date window.

## `onlineOnly` (type: `boolean`):

Restrict results to virtual/online events. Defaults to false (both in-person and online included).

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

Maximum number of events to return. 10times listing pages show ~30 events per page; this Actor paginates until maxItems is met or the listing is exhausted. Default 50 keeps run cost low for typical agent calls (~$0.25). Set higher for bulk extraction. Hard ceiling 10000.

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

Fetch each event's detail page to extract full description, organizer details, visitor/exhibitor estimates, and rating. When false, returns only listing-page fields (still includes name, dates, venue, URL). Adds one HTTP request per event but no extra event charge.

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

Apify proxy settings. Defaults to RESIDENTIAL group — 10times sits behind Cloudflare and datacenter IPs are reliably blocked. Override only if you have a tested alternative.

## Actor input object example

```json
{
  "searchQuery": "fintech",
  "city": "berlin",
  "country": "WW",
  "eventType": "all",
  "category": "all",
  "startDate": "2026-06-01",
  "endDate": "2026-12-31",
  "onlineOnly": false,
  "maxItems": 50,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `events` (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 = {
    "maxItems": 50,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/10times-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 = {
    "maxItems": 50,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/10times-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 '{
  "maxItems": 50,
  "includeDetails": true
}' |
apify call khadinakbar/10times-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "10times Events Scraper — Trade Shows, Conferences & Venues",
        "description": "Scrape trade shows, conferences, and exhibitions from 10times.com (200K+ events, 100+ industries). Flat records with ISO dates, venue + GPS, organizer, categories, visitor estimates, and event URL. Three input modes (URLs / search / city). MCP-ready, residential proxy, JSON-LD.",
        "version": "0.1",
        "x-build-id": "aO21fc4510MGb8AzS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~10times-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-10times-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/khadinakbar~10times-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-10times-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/khadinakbar~10times-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-10times-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",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Direct 10times URLs to scrape. Accepts event detail pages (e.g. 'https://10times.com/ces-las-vegas'), city listing pages ('https://10times.com/berlin', 'https://10times.com/new-york-us'), category listings ('https://10times.com/conferences', 'https://10times.com/technology-events'), or search URLs ('https://10times.com/?query=fintech'). Mutually exclusive with searchQuery and city — use this for fully custom filtering 10times exposes in its UI but this Actor's inputs do not surface.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text keyword to search 10times (e.g. 'fintech', 'medical devices', 'sustainability'). Combined with country and eventType filters when provided. Leave empty when using startUrls or browsing by city alone. NOT an event slug and NOT a full URL — for those use startUrls."
                    },
                    "city": {
                        "title": "City slug",
                        "type": "string",
                        "description": "10times city slug used in URLs (e.g. 'berlin', 'new-york-us', 'london-uk', 'singapore', 'dubai-ae', 'sao-paulo-br'). Combined with eventType, category, and date filters. Leave empty when using startUrls or searchQuery. NOT a free-text city name — must be the URL slug 10times uses on its city pages."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "WW",
                            "US",
                            "GB",
                            "DE",
                            "FR",
                            "ES",
                            "IT",
                            "NL",
                            "AU",
                            "CA",
                            "JP",
                            "IN",
                            "BR",
                            "MX",
                            "CN",
                            "SG",
                            "AE",
                            "ZA",
                            "KR",
                            "ID",
                            "TH"
                        ],
                        "type": "string",
                        "description": "Two-letter ISO country code to scope a search query to one country (e.g. 'US', 'DE', 'GB', 'IN', 'AE'). Use 'WW' or leave blank for worldwide. Ignored when city is set (city already implies country). NOT a country name — must be the ISO 3166-1 alpha-2 code.",
                        "default": "WW"
                    },
                    "eventType": {
                        "title": "Event type",
                        "enum": [
                            "all",
                            "tradeshow",
                            "conference",
                            "workshop",
                            "festival"
                        ],
                        "type": "string",
                        "description": "Filter by event format. 'tradeshow' = exhibitions and trade fairs, 'conference' = paid speaker conferences, 'workshop' = hands-on training, 'festival' = public/cultural events. Applied client-side on discovered events. Defaults to 'all'.",
                        "default": "all"
                    },
                    "category": {
                        "title": "Industry category",
                        "enum": [
                            "all",
                            "technology",
                            "it",
                            "business",
                            "medical",
                            "health",
                            "education",
                            "industrial",
                            "building",
                            "auto",
                            "banking",
                            "food",
                            "entertainment",
                            "apparel",
                            "science",
                            "sports",
                            "travel"
                        ],
                        "type": "string",
                        "description": "Industry filter applied to event categories and description tags. Leave 'all' to include every industry. Use this with city/searchQuery to narrow by sector (e.g. 'technology' + 'berlin' = Berlin tech events). NOT a free-text industry name — must be one of the listed slugs.",
                        "default": "all"
                    },
                    "startDate": {
                        "title": "Start date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only return events starting on or after this date. Format YYYY-MM-DD (e.g. '2026-06-01'). Leave empty for all upcoming events. NOT a date range — pair with endDate to bound on both sides."
                    },
                    "endDate": {
                        "title": "End date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only return events starting on or before this date. Format YYYY-MM-DD (e.g. '2026-12-31'). Leave empty for no upper bound. Pair with startDate for a bounded date window."
                    },
                    "onlineOnly": {
                        "title": "Online events only",
                        "type": "boolean",
                        "description": "Restrict results to virtual/online events. Defaults to false (both in-person and online included).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max events",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of events to return. 10times listing pages show ~30 events per page; this Actor paginates until maxItems is met or the listing is exhausted. Default 50 keeps run cost low for typical agent calls (~$0.25). Set higher for bulk extraction. Hard ceiling 10000.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Include detail-page enrichment",
                        "type": "boolean",
                        "description": "Fetch each event's detail page to extract full description, organizer details, visitor/exhibitor estimates, and rating. When false, returns only listing-page fields (still includes name, dates, venue, URL). Adds one HTTP request per event but no extra event charge.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Defaults to RESIDENTIAL group — 10times sits behind Cloudflare and datacenter IPs are reliably blocked. Override only if you have a tested alternative.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
