# AllEvents Events Scraper (`fetch_cat/allevents-events-scraper`) Actor

Scrape public AllEvents listings by city, keyword, category, or URL for event research, marketing, newsletters, and lead generation.

- **URL**: https://apify.com/fetch\_cat/allevents-events-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.12 / 1,000 item extracteds

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

## AllEvents Events Scraper

Extract public event listings from AllEvents into a clean dataset for local marketing, event research, newsletters, venue monitoring, and lead generation.

Use it to collect event titles, dates, venues, addresses, organizer names, interest counts, images, ticket links, categories, and source URLs by city, category, keyword, or specific AllEvents listing URLs.

### What you can do

- Track upcoming events in a city such as New York, London, or Dubai.
- Export music, comedy, business, workshop, nightlife, or free-event listings.
- Build local event calendars and community newsletters.
- Monitor venues, agencies, and event organizers for lead generation.
- Collect structured event URLs for follow-up enrichment.

### Who is it for

Event marketers, local SEO teams, tourism and community publishers, venues, agencies, and data teams that need public event listings in JSON, CSV, Excel, or API-ready formats.

### Ready-to-run examples

#### Scrape upcoming New York events

```json
{
  "city": "new york",
  "category": "all",
  "maxItems": 25
}
````

#### Scrape music events from a listing URL

```json
{
  "startUrls": [{ "url": "https://allevents.in/new-york/music" }],
  "maxItems": 50
}
```

#### Search a keyword in a city

```json
{
  "city": "london",
  "keyword": "startup",
  "category": "business",
  "maxItems": 40
}
```

### Input

| Field | Type | Description |
| --- | --- | --- |
| `startUrls` | array | Optional AllEvents listing URLs, for example city/category pages. |
| `city` | string | City name or slug used when no start URL is supplied. |
| `keyword` | string | Optional keyword to search within the selected city/category. |
| `category` | string | Category slug such as `all`, `music`, `business`, `workshops`, `comedy`, `concerts`, or `free-events`. |
| `fromDate` | string | Optional start date filter in `YYYY-MM-DD` format. |
| `toDate` | string | Optional end date filter in `YYYY-MM-DD` format. |
| `maxItems` | integer | Maximum number of events to save. |
| `proxyConfiguration` | object | Optional proxy settings. Leave disabled unless blocked. |

### Output

Each dataset item represents one event:

```json
{
  "eventId": "2400028937718757",
  "title": "Phish at Madison Square Garden",
  "eventUrl": "https://allevents.in/new-york/phish-at-madison-square-garden/2400028937718757",
  "descriptionSnippet": "Welcome to Phish at Madison Square Garden...",
  "startDateTime": "2026-07-22T00:30:00.000Z",
  "endDateTime": "2026-07-29T04:59:00.000Z",
  "venueName": "Madison Square Garden",
  "venueAddress": "Madison Square Garden, 4 Pennsylvania Plaza, New York, NY 10001, United States",
  "city": "New York",
  "price": null,
  "currency": null,
  "interestedCount": 12,
  "imageUrl": "https://cdn-ip.allevents.in/...",
  "organizerName": "Vivid Events",
  "category": "trips-adventures",
  "tags": ["adventure"],
  "ticketUrl": null,
  "latitude": 40.750504,
  "longitude": -73.993439,
  "sourceUrl": "https://allevents.in/new-york/all",
  "scrapedAt": "2026-07-07T08:30:00.000Z"
}
```

### Pricing

This actor uses pay-per-event pricing: a $0.005 start fee per run plus a tiered per-event fee for each saved event. Current event prices are FREE $0.00023, BRONZE $0.0002, SILVER $0.000156, GOLD $0.00012, PLATINUM $0.00008, and DIAMOND $0.000056.

### API usage

#### cURL

```bash
curl "https://api.apify.com/v2/acts/<ANNA_APIFY_USERNAME>/allevents-events-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"city":"new york","category":"all","maxItems":25}'
```

Get dataset items from a run:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('<ANNA_APIFY_USERNAME>/allevents-events-scraper').call({
  city: 'new york',
  category: 'all',
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('<ANNA_APIFY_USERNAME>/allevents-events-scraper').call(run_input={
    'city': 'new york',
    'category': 'all',
    'maxItems': 25,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### MCP and agents

Use this actor with Apify MCP-compatible agents:

```text
https://mcp.apify.com/?tools=<ANNA_APIFY_USERNAME>/allevents-events-scraper
```

Add it to Claude Desktop or Claude Code:

```bash
claude mcp add apify-allevents-events --url "https://mcp.apify.com/?tools=<ANNA_APIFY_USERNAME>/allevents-events-scraper"
```

Example MCP server configuration:

```json
{
  "mcpServers": {
    "apify-allevents-events": {
      "url": "https://mcp.apify.com/?tools=<ANNA_APIFY_USERNAME>/allevents-events-scraper"
    }
  }
}
```

Example prompts:

- “Find 30 upcoming startup events in London and include venue addresses.”
- “Export New York music events with event URLs and organizers.”
- “Create a CSV of free events in Chicago for next weekend.”

### Tips

- Start with `maxItems` between 25 and 100 to validate your query.
- Use a city/category URL when you already know the exact AllEvents page you want.
- Use `keyword` for focused lead-generation searches such as `startup`, `fitness`, or `real estate`.
- Leave proxy settings disabled unless AllEvents blocks your environment.

### Legality

This actor extracts publicly available event listing data. Use the results responsibly, respect AllEvents terms, and make sure your use case complies with applicable privacy, marketing, and data protection laws.

### Limits and notes

- The actor only extracts publicly available AllEvents listing data.
- Availability and field completeness depend on what AllEvents exposes for each event.
- Some events may not include price, currency, tickets, or organizer fields.
- Date filters are passed to the source when supplied, but AllEvents may still rank or group events by its own relevance rules.

### Related actors

- [Google Maps Lead Finder](https://apify.com/<ANNA_APIFY_USERNAME>/google-maps-lead-finder)
- [Luma Events Scraper](https://apify.com/<ANNA_APIFY_USERNAME>/luma-events-scraper)
- [Meetup Scraper](https://apify.com/<ANNA_APIFY_USERNAME>/meetup-scraper)

### FAQ

#### Do I need an AllEvents account?

No. The actor works with public event listing pages.

#### Can I scrape one specific city?

Yes. Set `city`, or provide a city listing URL in `startUrls`.

#### Can I export to CSV or Excel?

Yes. Apify datasets can be downloaded as JSON, CSV, Excel, XML, RSS, and more.

#### What should I include in a support request?

Please include the run ID or run URL, input JSON, expected output, and actual output so we can reproduce the issue quickly.

### Support

If a run fails or the output looks wrong, open an Apify issue with the run URL and input JSON.

### Changelog

- 0.1.0 — Initial version for public AllEvents city/category/keyword listings.

# Actor input Schema

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

Optional AllEvents city or category URLs. Examples: https://allevents.in/new-york/all or https://allevents.in/london/music

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

City to scrape when no start URL is supplied. Use the public city name or slug.

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

Optional keyword to search within the selected city/category.

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

AllEvents category slug such as all, music, business, workshops, comedy, concerts, or free-events.

## `fromDate` (type: `string`):

Optional start date filter in YYYY-MM-DD format.

## `toDate` (type: `string`):

Optional end date filter in YYYY-MM-DD format.

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

Maximum number of event records to save.

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

Optional proxy settings. Leave disabled unless your run is blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://allevents.in/new-york/all"
    }
  ],
  "city": "new york",
  "category": "all",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://allevents.in/new-york/all"
        }
    ],
    "city": "new york",
    "category": "all",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/allevents-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://allevents.in/new-york/all" }],
    "city": "new york",
    "category": "all",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/allevents-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://allevents.in/new-york/all"
    }
  ],
  "city": "new york",
  "category": "all",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/allevents-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AllEvents Events Scraper",
        "description": "Scrape public AllEvents listings by city, keyword, category, or URL for event research, marketing, newsletters, and lead generation.",
        "version": "0.1",
        "x-build-id": "NsjIn3LU3mrtfcQcx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~allevents-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-allevents-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/fetch_cat~allevents-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-allevents-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/fetch_cat~allevents-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-allevents-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": "AllEvents listing URLs",
                        "type": "array",
                        "description": "Optional AllEvents city or category URLs. Examples: https://allevents.in/new-york/all or https://allevents.in/london/music",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City to scrape when no start URL is supplied. Use the public city name or slug.",
                        "default": "new york"
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Optional keyword to search within the selected city/category."
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "AllEvents category slug such as all, music, business, workshops, comedy, concerts, or free-events.",
                        "default": "all"
                    },
                    "fromDate": {
                        "title": "From date",
                        "type": "string",
                        "description": "Optional start date filter in YYYY-MM-DD format."
                    },
                    "toDate": {
                        "title": "To date",
                        "type": "string",
                        "description": "Optional end date filter in YYYY-MM-DD format."
                    },
                    "maxItems": {
                        "title": "Maximum events",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of event records to save.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Leave disabled unless your run is blocked."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
