# DICE Events Scraper: Gigs, Clubs & Tickets (`reventadata/dice-scraper`) Actor

Scrape dice.fm events by city: gigs, club nights, comedy and theatre in date order. Dates, venue, ticket status and price in clean columns. Filter by category, date range, keyword, price and on-sale. No proxy or login needed.

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

## Pricing

from $1.00 / 1,000 events

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## DICE Events Scraper

> **Unofficial.** This Actor is not affiliated with, authorised by, endorsed by, or in any
> way officially connected to DICE FM Holdings Limited or dice.fm. "DICE" is a trademark of its
> respective owner and is used here only to describe what this tool reads. It reads the same
> public event listings the dice.fm website shows.

DICE Events Scraper pulls upcoming gigs, club nights, comedy, theatre, talks and other ticketed
events from dice.fm, city by city, in date order. Every row is one event with its dates, venue,
ticket status and price.

### What does it do?

For each city you name, it walks DICE's own event search from the start date onward, page by
page, until it has the number of events you asked for or the site has no more. You can narrow
the search by category (`music:gig`, `culture:comedy`, a sub-genre such as `gig:jazz`) and by
date range on the site, and by keyword, price ceiling and ticket status after the fetch.

### Why use it?

- **Structured columns.** Dates, venue name and address, status, currency and price are separate
  fields, not text to parse. Times keep the venue's UTC offset.
- **Whole cities, not 30 events.** The site's city page shows 30 "popular" events. This Actor
  pages through the full date-ordered catalogue (a large city holds thousands of upcoming events).
- **No proxy and no browser.** It reads one JSON endpoint (plus one page for the city list) over plain HTTP, so runs are fast and
  cheap.
- **Public data only.** Nothing from behind a login. Venue names and addresses and event titles
  are in the rows.

### How to use it

1. Put one or more cities in `cities`, written as DICE shows them. London and Southampton exist in
   two countries, so write `London, GB`, `London, CA`, `Southampton, GB` or `Southampton, US`.
   Any other city needs no country (`Paris`, `New York`, `Berlin`). A name the site does not know
   stops the run and prints every valid one.
2. Optionally set `categories`, `dateFrom` and `dateTo`, `keywords`, `maxPrice` and `onlyOnSale`.
3. Set `maxItems` and run. Download the dataset as JSON, CSV, Excel or NDJSON.

#### Input

| Field | Type | Description |
|---|---|---|
| `cities` | array | DICE cities to read. Required. |
| `categories` | array | DICE tags, one search per city and tag. Empty means every category. |
| `dateFrom` | string | First day, `YYYY-MM-DD`. Empty means today (UTC). |
| `dateTo` | string | Last day, `YYYY-MM-DD`. Empty means two years after the start. |
| `keywords` | array | Keep events whose name, one-liner or venue contains any of these. |
| `maxPrice` | number | Keep events whose cheapest ticket is at or under this, in the event's currency. |
| `onlyOnSale` | boolean | Keep only events with status `on-sale`. |
| `maxItems` | integer | Stop after this many events. |
| `proxyConfiguration` | object | Optional proxy. Off by default; the site answered without one. |

Main category tags: `music:gig`, `culture:comedy`, `music:dj`, `music:party`, `culture:social`,
`culture:art`, `culture:theatre`, `culture:talks`, `culture:workshop`, `culture:film`,
`culture:sport`, `culture:foodanddrink`, `music:artistsigning`, `music:playback`,
`culture:podcast`, `culture:wellbeing`. A tag the site does not know returns no events.

#### Sample input

```json
{
    "cities": ["London, GB"],
    "categories": ["culture:comedy"],
    "maxItems": 50
}
```

#### Output

Each dataset item is one event:

| Field | Type | Description |
|---|---|---|
| `id` | string | DICE event id. |
| `url` | string | Event page; it redirects to the canonical address. |
| `name` | string | Event title. |
| `status` | string | `on-sale`, `sold-out`, `announced` or `off-sale`. |
| `startDate`, `endDate` | string | ISO 8601 with the venue's UTC offset. |
| `timezone` | string | IANA time zone of the event. |
| `isMultiDay` | boolean | True for events spanning several days. |
| `announcedAt`, `onSaleAt`, `onSaleEndsAt`, `preSaleAt` | string / null | Ticket timeline, ISO 8601. |
| `venue`, `venueAddress`, `venueSpace`, `venueId` | string / null | First venue. |
| `city`, `country`, `countryCode` | string / null | Location of the first venue. |
| `venues` | array | Every venue of the event. |
| `currency` | string / null | Currency code as the site gives it, for example `GBP`, `USD` or `EUR`. |
| `price` | number / null | Ticket price when the event has a single price. |
| `priceFrom` | number / null | Lowest ticket price when the event has several. |
| `oneLiner` | string / null | The organiser's one-line description. |
| `imageUrl` | string / null | Square event image. |
| `acquisitionType` | string / null | `purchase`, or `competition` for a prize draw. |
| `searchCity`, `searchCategory` | string | The search that returned the event. |
| `scrapedAt` | string | ISO 8601 time of the scrape. |

#### Sample output

One row from a run of the sample input above (2026-10-21, run `6YNBNpkZthfcmLh1v`):

```json
{
    "id": "6a8c830ec583f90001cae794",
    "url": "https://dice.fm/event/6a8c830ec583f90001cae794",
    "name": "2/3rds of a Threesome (& Friends)",
    "status": "on-sale",
    "startDate": "2026-10-22T18:30:00+01:00",
    "endDate": "2026-10-22T19:30:00+01:00",
    "timezone": "Europe/London",
    "isMultiDay": false,
    "announcedAt": "2026-08-24T18:30:00+01:00",
    "onSaleAt": "2026-08-24T18:30:00+01:00",
    "onSaleEndsAt": "2026-10-22T18:30:00+01:00",
    "preSaleAt": null,
    "venue": "The Bill Murray",
    "venueAddress": "39 Queen's Head St, London N1 8NQ, UK",
    "venueSpace": null,
    "venueId": "1799",
    "city": "London",
    "country": "United Kingdom",
    "countryCode": "GB",
    "venues": [{"id": "1799", "name": "The Bill Murray", "address": "39 Queen's Head St, London N1 8NQ, UK", "space": null, "city": "London", "country": "United Kingdom", "countryCode": "GB"}],
    "currency": "GBP",
    "price": 22.21,
    "priceFrom": null,
    "oneLiner": "Musical comedy variety spectacle",
    "imageUrl": "https://dice-media.imgix.net/attachments/2026-08-24/9f3e42d7-b325-47fb-961f-140209834ea8.jpg?rect=951%2C0%2C3810%2C3810",
    "acquisitionType": "purchase",
    "searchCity": "London, GB",
    "searchCategory": "culture:comedy",
    "scrapedAt": "2026-10-21T21:16:43+00:00"
}
```

### Good to know

- **Nearby towns are included.** DICE returns events within a radius of the city centre, so a
  London search also holds venues in Luton, Chelmsford and Guildford. The `city` field says where
  each venue is; `searchCity` says which search found it.
- **An event appears once per run**, even when it matches several categories or cities.
- **Keywords, price and ticket status are applied after the fetch.** A rare keyword in a big city
  reads many pages before it fills `maxItems`; a run with no match ends with an error rather than
  an empty dataset.
- **Prices are the card prices**: the lowest tier, not a ticket-by-ticket breakdown. Event
  descriptions, line-ups and ticket tiers are not included.
- **Currencies.** The site stores prices in hundredths and the Actor divides by 100. That was
  checked against prices shown on the site in GBP and EUR. USD events (943 in one sample) use the
  same field but were not compared with a page; a currency with no minor unit would need a check.
- **Dates are the venue's local time** with its UTC offset. The default start day is today in UTC.

### How much does it cost to scrape dice.fm?

Pay-per-event: **$0.001 per event** saved to the dataset (**$1.00 per 1,000 events**), plus
**$0.00005** charged once when the run starts. No subscription. Keyword, price and on-sale filters
run before a row is saved, so events they drop are not charged.

# Actor input Schema

## `cities` (type: `array`):

DICE cities to read, by the name the site shows: Paris, New York, Berlin, Barcelona and the rest of its 98 cities. London and Southampton exist in two countries, so write them with the country: London, GB or London, CA. A misspelt or ambiguous name stops the run and lists every valid one. Each city also returns venues in nearby towns, as the site does.

## `categories` (type: `array`):

Optional DICE tags, one search per city and tag. Main shelves: music:gig, culture:comedy, music:dj, music:party, culture:social, culture:art, culture:theatre, culture:talks, culture:workshop, culture:film, culture:sport, culture:foodanddrink, music:artistsigning, music:playback, culture:podcast, culture:wellbeing. Sub-genres work too, for example gig:jazz. A tag the site does not know returns nothing. Leave empty for every category.

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

First day to include, written YYYY-MM-DD. Leave empty to start today (UTC).

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

Last day to include, written YYYY-MM-DD. Leave empty for two years after the start date.

## `keywords` (type: `array`):

Optional. Keep only events whose name, one-line description or venue contains any of these words or phrases (accents and capitals ignored). Applied after the fetch, so a rare keyword in a big city reads many pages.

## `maxPrice` (type: `number`):

Optional. Keep only events whose cheapest ticket costs this much or less, in the event's own currency (pounds, euros, dollars). Events with no price shown are dropped when this is set. Applied after the fetch.

## `onlyOnSale` (type: `boolean`):

Keep only events whose status is on-sale. Sold-out, announced and off-sale events are dropped. Applied after the fetch.

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

Stop after this many events across all cities and categories. Events come in date order within each city and category.

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

Proxy settings. dice.fm answered without a proxy in testing, so this is off by default.

## Actor input object example

```json
{
  "cities": [
    "London, GB"
  ],
  "onlyOnSale": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Events scraped from dice.fm.

# 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 = {
    "cities": [
        "London, GB"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("reventadata/dice-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 = {
    "cities": ["London, GB"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("reventadata/dice-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 '{
  "cities": [
    "London, GB"
  ],
  "maxItems": 20
}' |
apify call reventadata/dice-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,reventadata/dice-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/aYEkIPh9tzOq61Yb2/builds/0IFrTIF0L7cuOb1bB/openapi.json