# Dice Events Scraper (`mrdoe/dice-events-scraper`) Actor

- **URL**: https://apify.com/mrdoe/dice-events-scraper.md
- **Developed by:** [MrDoe](https://apify.com/mrdoe) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Extract event listings and full event detail pages from [DICE](https://dice.fm) - the ticketing platform behind club nights, live gigs, DJ sets, and independent venue shows across London and cities worldwide. Point it at a city and get back structured event data: artist lineups, venue details, pricing, and ticket availability - ready for API access, scheduled monitoring, and integration into your own tools.

### What does DICE Event Scraper do?

This Actor browses DICE's live event listings for any city or place name and pulls back a clean, structured row per event - or fetches one specific event page in full depth, including the complete artist lineup and set times. No login or account is required. Run it once for a one-off export, or schedule it on Apify to keep a city or genre under continuous watch, with automatic proxy rotation and retries handled for you.

### Why use DICE Event Scraper?

DICE is built around music, club nights, and live entertainment rather than general ticketing - which makes it a focused, high-signal data source for:

- **Music and nightlife discovery** - build local "what's on" feeds for a city, genre, or club scene.
- **Artist and lineup tracking** - every event detail row includes the full billed lineup with set times, so you can follow where an artist is playing next.
- **Ticket availability monitoring** - watch a show move from on-sale to sold out or waiting-list, useful for resale/demand research or fan alerts.
- **Venue research** - see which venues a promoter or genre concentrates around in a given city.
- **Pricing and calendar tracking** - watch ticket price ranges and upcoming dates over time.

### What makes this different

- **Lineup-first data.** Event detail rows include the full billed artist lineup with each act's set time, not just a headline act name.
- **Real ticket-status signal.** Every row reports whether an event is on sale, sold out, or on a waiting list - not just a static "available" flag.
- **Genre-level filtering.** Narrow a city's listings by broad category (gigs, DJ, comedy, theatre, and more) or drill into a specific music genre.
- **Works for any city, not a fixed list.** Type any city or place name and the Actor resolves it live - no need to pick from a hardcoded location list.

### Data table

| Field                                              | Description                                                             |
| -------------------------------------------------- | ----------------------------------------------------------------------- |
| `name`                                             | Event title                                                             |
| `url`                                              | Public event page                                                       |
| `startDate` / `endDate` / `timezone`               | Event date and time                                                     |
| `venueName` / `address` / `latitude` / `longitude` | Venue details                                                           |
| `city` / `countryCode` / `countryName`             | Event location                                                          |
| `price` / `priceFrom` / `currency`                 | Ticket price (a fixed price, or the lowest tier when there are several) |
| `availability` / `soldOut`                         | Current ticket status - on sale, sold out, or waiting list              |
| `category` / `categoryTitle`                       | Event category (e.g. `music:gig` / "Gigs")                              |
| `genre`                                            | The genre tag used for the search, when set                             |
| `lineup`                                           | Full billed artist lineup with set times (event detail rows only)       |
| `promoterName`                                     | The promoter or venue presenting the event                              |
| `description`                                      | Event description                                                       |
| `ticketTypesAvailable`                             | Whether the event offers more than one ticket tier                      |

### How to use DICE Event Scraper

1. Click **Try for free** (or **Start**) to open the Input tab.
2. Choose an **Operation**: "Browse events" for a list of events, or "Event details" for one specific event.
3. For browsing, enter a **City or place**, optionally a **Category** and **Genre tag**, then set **Max items**.
4. For event details, paste one or more DICE event URLs, or leave it blank to fetch a live sample event.
5. Click **Start** and open the **Dataset** tab when the run finishes to view, filter, or export your results (JSON, CSV, Excel, HTML, and more).
6. For ongoing monitoring, save your input as a **Task** and add a **Schedule** so it runs automatically - e.g. daily for a city or genre.

### Input

| Field                    | Type              | Description                                                                              |
| ------------------------ | ----------------- | ---------------------------------------------------------------------------------------- |
| `operation`              | Select            | `search` (browse events) or `eventDetails` (one event in full)                           |
| `location`               | String (optional) | A city or place name, e.g. `London`, `Manchester`, `Brooklyn`. Defaults to London        |
| `category`               | Select (optional) | One of DICE's event categories, e.g. `music:gig`                                         |
| `genre`                  | String (optional) | A specific genre tag within a category, e.g. `gig:techno`. Requires a Category to be set |
| `maxItems`               | Integer           | Caps rows returned by the browse operation. Default `20`                                 |
| `eventUrl` / `eventUrls` | String / Array    | One or many DICE event URLs, for the event-details operation                             |
| `proxyConfiguration`     | Object            | Apify Proxy settings (default works out of the box)                                      |

See the Input tab for the full list with live validation.

### Output

Each dataset row is one event. A browsed listing row looks like:

```json
{
    "_operation": "search",
    "status": "ok",
    "name": "Bonobo - Distance In Static - Live",
    "url": "https://dice.fm/event/6a9830f0afef6b00011be599",
    "startDate": "2027-02-26T18:30:00+00:00",
    "venueName": "Alexandra Palace",
    "address": "Alexandra Palace, Alexandra Palace Way, London N22 7AY",
    "city": "London",
    "countryName": "United Kingdom",
    "priceFrom": 46.25,
    "currency": "GBP",
    "availability": "waiting-list",
    "soldOut": false
}
```

An event-details row adds the full lineup and description:

```json
{
    "_operation": "eventDetails",
    "status": "ok",
    "name": "Bloc Party: Live Performance (Early Matinee)",
    "url": "https://dice.fm/event/l879pw-bloc-party-live-performance-early-matinee-15th-sep-rough-trade-east-london-london-tickets",
    "venueName": "Rough Trade East London",
    "address": "The Old Truman Brewery, 150 Brick Lane, London E1 6QL",
    "priceFrom": 21.21,
    "currency": "GBP",
    "availability": "sold-out",
    "soldOut": true,
    "category": "music:gig",
    "categoryTitle": "Gigs",
    "lineup": [
        { "name": "Bloc Party", "type": "artist", "isHeadliner": null, "performingTime": "2026-09-15T15:45:00+01:00" }
    ],
    "promoterName": "Rough Trade",
    "ticketTypesAvailable": true
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Usage examples

- **Track London techno nights:** `location: "London"`, `category: "music:gig"`, `genre: "gig:techno"`.
- **Build a citywide "what's on" feed:** leave `category` blank to get the most popular events near any location.
- **Watch a show for a sellout:** run "Event details" against the event's URL on a schedule and alert when `soldOut` flips to `true`.
- **Follow an artist's tour:** run "Event details" against each tour-date URL to collect every stop's venue, date, and lineup slot.

### Known limitations

- Coverage is limited to events actually listed on DICE - it doesn't include events sold through other platforms.
- `lineup` is only populated on event-detail rows; browse rows return the core event fields for speed across many results.
- A city or place with very little DICE activity may return fewer results than a major market - this reflects real event volume on the platform, not an Actor limitation.
- Price fields reflect ticket face value; some events add a booking fee at checkout that isn't reflected here.

### FAQ

**Do I need a DICE account or API key?** No - the Actor works anonymously against publicly listed event pages.

**Can I search by exact venue instead of city?** Not directly - search by the city the venue is in, then filter the results by `venueName`.

**What genres can I filter by?** DICE supports hundreds of genre tags (e.g. `gig:techno`, `gig:jazz`, `gig:hiphop`, `gig:indie`). Set a Category first, then a matching Genre tag to narrow further.

**Something looks wrong or missing?** Open an issue on the Actor's Issues tab - reports are read and actioned. Custom extensions to this Actor's scope are also available on request.

### Legal

This Actor extracts data that is already publicly available on DICE's website. It is intended for legitimate research, market monitoring, and personal use cases. You are responsible for using the collected data in compliance with applicable laws and DICE's own terms of service.

# Actor input Schema

## `operation` (type: `string`):

Which DICE data to scrape. One operation per run.

## `location` (type: `string`):

A city, town, or place name to browse for events, e.g. "London", "Manchester", "Brooklyn". Used by the "Browse events" operation. Leave blank to browse London.

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

Filter to one DICE event category. Leave blank for all categories (popular events near the chosen location).

## `genre` (type: `string`):

A specific DICE genre tag to narrow results further within a category, e.g. "gig:techno", "gig:jazz", "gig:hiphop". Only applied when a Category above is also set. Leave blank to include every genre in the category.

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

Caps total rows returned for the "Browse events" operation (event details always returns one row per event). The first 10 rows of any run are free. Leave blank to use the default of 20.

## `eventUrl` (type: `string`):

A DICE event page URL, e.g. https://dice.fm/event/some-event-tickets. Used by the "Event details" operation. Leave blank to fetch a live sample event.

## `eventUrls` (type: `array`):

Many DICE event URLs in one run. Wins over "Event URL" when filled.

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

Proxy settings for the run. DICE serves both operations over plain HTTP with no bot-verification challenge, so Apify's default proxy works well.

## Actor input object example

```json
{
  "operation": "search",
  "location": "London",
  "category": "",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("mrdoe/dice-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 = { "proxyConfiguration": { "useApifyProxy": True } }

# Run the Actor and wait for it to finish
run = client.actor("mrdoe/dice-events-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call mrdoe/dice-events-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mrdoe/dice-events-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/M3nSs5Zac9rcwMtxP/builds/PfhhE2Uh8OCFZGXRR/openapi.json
