# AllEvents Scraper (`automation-lab/allevents-scraper`) Actor

Extract AllEvents event listings with dates, venues, addresses, interest counts, images, descriptions, and ticket links from public pages.

- **URL**: https://apify.com/automation-lab/allevents-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation, Marketing
- **Stats:** 4 total users, 2 monthly users, 94.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## AllEvents Scraper

Extract public event listings from AllEvents city, category, search, and event detail pages.

### What does AllEvents Scraper do?

AllEvents Scraper turns public AllEvents pages into structured event records.
It reads listing pages such as `https://allevents.in/new-york/all`, follows event links when enrichment is enabled, and saves clean dataset rows with dates, venues, ticket links, images, descriptions, and interest counts.

### Who is it for?

- 🎟️ Event marketers monitoring local calendars.
- 🏙️ Tourism teams building city event feeds.
- 📣 Agencies finding sponsorship and partnership opportunities.
- 🧲 Lead generation teams prospecting organizers and venues.
- 📰 Publishers creating weekly event roundups.
- 🧪 Data teams comparing event availability across cities.

### Why use this actor?

AllEvents pages are useful but not ideal for spreadsheets or automated workflows.
This actor extracts event cards and JSON-LD detail data into a dataset that can be exported to CSV, JSON, Excel, Google Sheets, or your own API pipeline.

### What data can you extract?

| Field | Description |
| --- | --- |
| `eventId` | AllEvents numeric event identifier when available |
| `title` | Event title |
| `url` | Canonical event URL |
| `startDate` | ISO start date from detail JSON-LD |
| `endDate` | ISO end date when present |
| `dateText` | Human-readable listing date |
| `venueName` | Venue or place name |
| `streetAddress` | Street address from detail pages |
| `city` | Event city |
| `region` | State or region |
| `country` | Country code or name |
| `latitude` / `longitude` | Geo coordinates when AllEvents exposes them |
| `organizerName` | Organizer or host name when available |
| `ticketUrl` | Ticket or registration link when present |
| `priceText` | Price label or free indicator |
| `interestedCount` | Count parsed from interested/going text |
| `imageUrl` | Event image or banner |
| `description` | Detail-page description |
| `sourceUrl` | Input page that produced the record |
| `scrapedAt` | Timestamp of extraction |

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

The actor uses pay-per-event pricing.
You pay a small `$0.005` start fee for each run and then a per-record event charge for each saved event.
The default Free-tier item price is `$0.0000575` per event, with lower per-event prices on paid Apify plans.

| Example run | Events saved | Estimated Free-plan cost |
| --- | ---: | ---: |
| Trial city scan | 20 events | `$0.0062` |
| Weekly category monitor | 100 events | `$0.0108` |
| Larger city export | 1,000 events | `$0.0625` |

Formula: `$0.005 start + events × $0.0000575` on the Free plan.
That means the Apify Free plan can usually cover many small test runs; for example, roughly 160 trial runs of 20 events or about 150,000 saved events before Apify platform usage limits and any proxy costs are considered.
Use a small `maxItems` value for trial runs, then increase the limit for production feeds.

### Input options

| Input | Type | Default | Notes |
| --- | --- | --- | --- |
| `startUrls` | array | New York all-events page | City, category, search, or event URLs |
| `maxItems` | integer | 20 | Maximum records across all starts |
| `includeDetails` | boolean | true | Fetch event detail pages for richer fields |
| `proxyConfiguration` | object | optional | Use Apify Proxy only if needed |

### How to scrape a city page

1. Open the actor on Apify.
2. Add an AllEvents city URL, for example `https://allevents.in/new-york/all`.
3. Keep `includeDetails` enabled for addresses and descriptions.
4. Set `maxItems` to a small number for the first run.
5. Start the actor.
6. Download the dataset from the Storage tab.

### How to scrape category pages

Use any public AllEvents category or filtered listing URL as a start URL.
The actor detects event cards on the page and saves event records until `maxItems` is reached.

### How to scrape event detail URLs

You can paste direct event URLs too.
When a start URL is already an event page, the actor extracts the JSON-LD event object and saves one enriched record.

### Output example

```json
{
  "eventId": "2400028937718757",
  "title": "Phish at Madison Square Garden",
  "url": "https://allevents.in/new-york/phish-at-madison-square-garden/2400028937718757",
  "startDate": "2026-07-22T19:30:00-05:00",
  "venueName": "Madison Square Garden",
  "city": "New York",
  "country": "US",
  "interestedCount": 12,
  "sourceUrl": "https://allevents.in/new-york/all"
}
````

### Tips for better results

- ✅ Start with one city or category page.
- ✅ Keep `maxItems` low during setup.
- ✅ Enable detail fetching when you need addresses, coordinates, and descriptions.
- ✅ Disable detail fetching for faster lightweight listing scans.
- ✅ Use specific category URLs when you need niche events.

### Integrations

Use this actor to feed:

- CRM lead lists for venue and organizer outreach.
- City guides and local newsletters.
- Sponsorship prospecting dashboards.
- Event monitoring spreadsheets.
- Content calendars for social media teams.
- Internal data warehouses via Apify webhooks.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/allevents-scraper').call({
  startUrls: [{ url: 'https://allevents.in/new-york/all' }],
  maxItems: 20,
  includeDetails: true
});

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

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/allevents-scraper').call(run_input={
    'startUrls': [{'url': 'https://allevents.in/new-york/all'}],
    'maxItems': 20,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~allevents-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://allevents.in/new-york/all"}],"maxItems":20,"includeDetails":true}'
```

### MCP usage

Connect the actor to Claude through Apify MCP:

`https://mcp.apify.com/?tools=automation-lab/allevents-scraper`

Claude Code CLI setup:

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

Claude Desktop JSON config:

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

Example prompts:

- "Scrape 20 New York AllEvents listings and summarize the most common venues."
- "Find free public events from this AllEvents category URL."
- "Create a CSV-ready list of upcoming event titles, dates, venues, and ticket links."

### Data quality notes

AllEvents exposes more fields for some events than others.
Listing pages usually include title, URL, venue, date text, image, and interest count.
Detail pages often add structured start dates, full address, coordinates, and descriptions.
Optional fields may be `null` when the source page does not publish them.

### Performance notes

The actor uses HTTP requests and Cheerio parsing, not a browser.
This keeps runs lightweight and cost-efficient.
For fastest runs, set `includeDetails` to false.
For richest data, keep `includeDetails` true.

### Proxy notes

AllEvents public pages usually work without a proxy or with standard Apify datacenter proxy settings.
If your location is blocked, configure Apify Proxy in the advanced input section.
Residential proxies are not the default recommendation.

### Legality

This actor extracts publicly available information from public AllEvents pages.
You are responsible for using the data in accordance with applicable laws, AllEvents terms, and privacy rules.
Avoid collecting personal data unless you have a lawful basis and a legitimate use case.

### FAQ

#### Why did I get fewer events than `maxItems`?

The source page may have fewer visible event cards, or duplicate events may have been skipped.
Try another city/category page or increase the source coverage with more start URLs.

#### Why are some fields empty?

Some AllEvents records do not publish every field.
Enable `includeDetails` to get the richest available data from event detail pages.

#### Can I scrape multiple cities?

Yes. Add multiple AllEvents city URLs to `startUrls` and set a higher `maxItems` limit.

#### Does it require login?

No. The actor is designed for public pages that can be viewed without an AllEvents account.

### Troubleshooting

If a run returns no items, check that the start URL is a public AllEvents listing or event URL.
If a run is slow, lower `maxItems` or disable detail fetching.
If requests are blocked, enable Apify Proxy and retry with a small limit.

### Related scrapers

- https://apify.com/automation-lab/10times-events-scraper
- https://apify.com/automation-lab/eventbrite-scraper
- https://apify.com/automation-lab/google-maps-reviews-scraper
- https://apify.com/automation-lab/website-emails-scraper

### Changelog

Initial version extracts AllEvents listing cards and event detail JSON-LD into structured event records.

### Support

Open an Apify issue if you find a public AllEvents page that the actor cannot parse.
Include the start URL, run ID, and a short description of the expected events.

### Storage

Results are written to the default Apify dataset.
You can export them as JSON, CSV, XML, RSS, Excel, or HTML from Apify Storage.

### Reliability checklist

The actor skips duplicate event URLs.
It keeps partial listing data if an individual detail page fails.
It records the original source URL for each item.
It uses clear null values for unavailable fields.

### Version

Current build: `0.1`.

# Actor input Schema

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

AllEvents city, category, search, or event detail URLs to scrape.

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

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

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

Open each event page to enrich listings with JSON-LD details such as full address, coordinates, image, end date, and description.

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

Optional Apify Proxy settings. Datacenter proxies are usually enough for AllEvents.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://allevents.in/new-york/all"
    }
  ],
  "maxItems": 20,
  "includeDetails": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://allevents.in/new-york/all"
        }
    ],
    "maxItems": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/allevents-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" }],
    "maxItems": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/allevents-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"
    }
  ],
  "maxItems": 20,
  "includeDetails": true
}' |
apify call automation-lab/allevents-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AllEvents Scraper",
        "description": "Extract AllEvents event listings with dates, venues, addresses, interest counts, images, descriptions, and ticket links from public pages.",
        "version": "0.1",
        "x-build-id": "sdK03kC2VAFxISPwg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~allevents-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-allevents-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~allevents-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-allevents-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~allevents-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-allevents-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🎟️ AllEvents URLs",
                        "type": "array",
                        "description": "AllEvents city, category, search, or event detail URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum events",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of event records to save across all start URLs.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Fetch event detail pages",
                        "type": "boolean",
                        "description": "Open each event page to enrich listings with JSON-LD details such as full address, coordinates, image, end date, and description.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Datacenter proxies are usually enough for AllEvents."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```