# 10times Events Scraper (`literal_jacktree/10times-events-scraper`) Actor

Extract public 10times event listings, organizer data, venue details, and attendance signals into a structured dataset. Best-effort live extraction, with anti-bot related empty-run edge cases still being tightened.

- **URL**: https://apify.com/literal\_jacktree/10times-events-scraper.md
- **Developed by:** [Janice](https://apify.com/literal_jacktree) (community)
- **Categories:** Business, Lead generation, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

Extract public 10times event listings into a clean dataset for lead generation, market research, sponsorship scouting, and organizer tracking.

### Current launch note

This actor is live as an early public release. It already validates inputs and returns normalized output when rows are detected, but live 10times anti-bot responses can currently cause false-green empty datasets on some runs. Treat broad live scraping as best-effort until challenge detection is tightened.

### What it returns

Each dataset item can include:

- Event name and 10times URL
- Start date, end date, and display date
- Venue name and venue address
- City, state, and country
- Organizer name and organizer URL
- Estimated visitors and exhibitors when 10times exposes them
- Category tags, event type, pricing, rating, followers, and review count
- Optional event description

### Input

#### Minimal run

```json
{
  "startUrl": "https://10times.com/events"
}
````

#### Filtered lead-gen run

```json
{
  "startUrl": "https://10times.com/events",
  "keyword": "manufacturing",
  "city": "Chicago",
  "industry": "industrial products",
  "dateFrom": "2026-05-01",
  "dateTo": "2026-12-31",
  "maxPages": 2,
  "includeDescription": true
}
```

#### Search URL run

```json
{
  "startUrl": "https://10times.com/events?kw=healthcare",
  "maxPages": 1,
  "includeDescription": false
}
```

### Output shape

See `test-data/sample-output.json` for a full example.

Key fields:

- `name`
- `url`
- `startDate`, `endDate`, `dateLabel`
- `venueName`, `venueAddress`
- `city`, `state`, `country`
- `organizerName`, `organizerUrl`
- `estimatedVisitors`, `estimatedExhibitors`
- `categories`
- `eventType`, `pricing`, `pricingDetail`
- `rating`, `followers`, `reviewsCount`
- `description`

### Validation and error handling

The actor fails fast on invalid inputs and gives a clear message for:

- non-10times `startUrl` values
- malformed `dateFrom` or `dateTo`
- `dateFrom` later than `dateTo`
- `maxPages` outside the 1 to 25 range

Pagination is best-effort. If page 2+ gets blocked or returns an error, the actor keeps the successful results from earlier pages and stops cleanly.

### Good fits

- building event prospect lists
- tracking trade show calendars by city or category
- finding organizer and venue targets
- enriching sales research with attendance and exhibitor estimates

### Limits

- Public-page scraper only
- Output depends on fields exposed in 10times HTML or embedded JSON
- Pagination beyond page 1 can be blocked by anti-bot defenses, so deeper scraping is best-effort
- Live anti-bot responses can currently produce empty datasets without a hard failure in some cases
- Some cloud runs can currently finish green with an empty dataset if 10times serves an anti-bot response that slips past detection

### Local development

```bash
npm install
npm run health
npm run test:local
```

### Store positioning

Short pitch: Public 10times event data, cleaned and filterable, without hand-copying listings.

Launch caution: position this as a best-effort public-page scraper, not a guaranteed always-populated feed, until non-empty cloud smoke tests are reconfirmed.

#### Example input

![10times Events Scraper example input](./screenshots/10times-events-input.png)

#### Example output

![10times Events Scraper example output](./screenshots/10times-events-output.png)

See `STORE_COPY.md` for store title, subtitle, bullets, and launch copy.

# Actor input Schema

## `startUrl` (type: `string`):

10times events or search URL to start from.

## `keyword` (type: `string`):

Optional keyword to match against event name, categories, organizer, type, and description.

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

Optional city substring to keep in the final dataset.

## `industry` (type: `string`):

Optional category substring to keep in the final dataset.

## `dateFrom` (type: `string`):

Optional earliest event start date in YYYY-MM-DD format.

## `dateTo` (type: `string`):

Optional latest event start date in YYYY-MM-DD format.

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

Best-effort page limit. Pagination beyond page 1 can be blocked by 10times anti-bot defenses.

## `includeDescription` (type: `boolean`):

Include embedded JSON event descriptions when available.

## Actor input object example

```json
{
  "startUrl": "https://10times.com/events",
  "maxPages": 1,
  "includeDescription": true
}
```

# 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 = {
    "startUrl": "https://10times.com/events"
};

// Run the Actor and wait for it to finish
const run = await client.actor("literal_jacktree/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 = { "startUrl": "https://10times.com/events" }

# Run the Actor and wait for it to finish
run = client.actor("literal_jacktree/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 '{
  "startUrl": "https://10times.com/events"
}' |
apify call literal_jacktree/10times-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "10times Events Scraper",
        "description": "Extract public 10times event listings, organizer data, venue details, and attendance signals into a structured dataset. Best-effort live extraction, with anti-bot related empty-run edge cases still being tightened.",
        "version": "0.1",
        "x-build-id": "PKz74i6ksmV4OD720"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/literal_jacktree~10times-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-literal_jacktree-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/literal_jacktree~10times-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-literal_jacktree-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/literal_jacktree~10times-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-literal_jacktree-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",
                "required": [
                    "startUrl"
                ],
                "properties": {
                    "startUrl": {
                        "title": "10times listing URL",
                        "type": "string",
                        "description": "10times events or search URL to start from."
                    },
                    "keyword": {
                        "title": "Keyword filter",
                        "type": "string",
                        "description": "Optional keyword to match against event name, categories, organizer, type, and description."
                    },
                    "city": {
                        "title": "City filter",
                        "type": "string",
                        "description": "Optional city substring to keep in the final dataset."
                    },
                    "industry": {
                        "title": "Industry/category filter",
                        "type": "string",
                        "description": "Optional category substring to keep in the final dataset."
                    },
                    "dateFrom": {
                        "title": "Start date from",
                        "type": "string",
                        "description": "Optional earliest event start date in YYYY-MM-DD format."
                    },
                    "dateTo": {
                        "title": "Start date to",
                        "type": "string",
                        "description": "Optional latest event start date in YYYY-MM-DD format."
                    },
                    "maxPages": {
                        "title": "Maximum pages",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Best-effort page limit. Pagination beyond page 1 can be blocked by 10times anti-bot defenses.",
                        "default": 1
                    },
                    "includeDescription": {
                        "title": "Include description",
                        "type": "boolean",
                        "description": "Include embedded JSON event descriptions when available.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
