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

Every upcoming event Dice (dice.fm) lists for a city, from concerts to club nights, with the time, venue, price and sold-out status on each row. Filter by dates, event type, price or keywords, or schedule it to get only newly announced events.

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

## Pricing

from $0.75 / 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.
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?

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

Dice Events Scraper returns the events Dice (dice.fm) lists for a city, from gigs and club nights to comedy and talks. Each row has the start and end time, venue with address and coordinates, ticket price, sale status including sold out, lineup, promoter and age limit. Type a city such as `london` or `paris`, set the dates and click **Start**. A run covers every upcoming event Dice lists for the city, 6,154 for London on 11 October 2026. Genres and the list of ticket types are not in the data. It costs $1.50 per 1,000 events on the Free plan ($0.75 on Business), and the $5 of monthly credit in Apify's Free plan covers about 3,300 events.

### What data does it return?

| Field | Description |
|---|---|
| `eventId`, `url` | Dice's 24-character event ID and the event page on dice.fm. |
| `title` | Event name as the promoter wrote it, such as `Tiny Vipers + Chantal Acda + Red River Dialect`. |
| `status`, `soldOut`, `secondaryStatus` | Sale status from Dice: `on-sale`, `sold-out`, `off-sale` or `announced` (not on sale yet). `soldOut` is `true` for `sold-out`. `secondaryStatus` adds `waiting-list`, `rescheduled`, `postponed`, `cancelled` or `pre-sale` when Dice shows it. |
| `startAt`, `endAt`, `doorsOpenAt`, `timezone` | Local times with the UTC offset, such as `2026-10-11T19:30:00+01:00`, and the time zone, such as `Europe/London`. `isMultiDay` is `true` for events over several days. |
| `announcedAt`, `saleStartAt`, `saleEndAt` | When Dice announced the event and when ticket sales open and close. |
| `venueName`, `venueRoom`, `venueAddress`, `venueUrl` | The venue, the room or stage when Dice names one, the street address and the venue page on dice.fm. |
| `venueCapacity` | Capacity Dice shows for the venue, such as `75`. Often `null`. |
| `city`, `country`, `countryCode` | Where Dice places the venue, such as `London`, `United Kingdom` and `GB`. A venue on the edge of a city can carry its own town, such as `Stratford` for an event listed under London. |
| `latitude`, `longitude` | Coordinates of the venue in decimal degrees. |
| `lineup` | Performers with a Dice artist profile, in Dice's order. |
| `lineupNotes` | The other lines of the lineup, acts without a profile and timings, with the local time when given, such as `22:00 Curfew`. |
| `promoter`, `presentedBy` | The promoter Dice bills the event to and the credit line on the page, such as `Presented by Mirror TV.` |
| `eventTypes` | Dice's event types: `gig`, `dj`, `party`, `comedy`, `theatre`, `art`, `talks`, `workshop`, `film`, `sport`, `foodanddrink`, `social`, `artistsigning`, `playback` or `podcast`. |
| `price`, `currency`, `priceText` | Ticket price as a number in the event's currency, such as `12.5` and `GBP`, and as Dice shows it, such as `£12.50`, `from €16.00` or `Free`. |
| `priceIsFrom`, `hasMultipleTicketTypes` | `priceIsFrom` is `true` when `price` is the lowest of several ticket prices. `hasMultipleTicketTypes` tells whether the event sells more than one kind of ticket. |
| `ageRestriction`, `minimumAge` | The age rule in the event's language, such as `This is an 18+ event.` or `Réservé aux plus de 18 ans`, and the age as a number: `0` for all ages, `null` when Dice gives no rule. |
| `imageUrl` | The event artwork. |
| `description` | The promoter's full text about the event, `null` when **Include the description** is off. |
| `source` | What brought the event into the run: `city:london` for a city, `url` for an event link. |
| `scrapedAt` | When the event was read, as an ISO 8601 UTC timestamp. |

### How to scrape Dice events

1. Enter one or more **Cities** the way Dice writes them at the end of its event links, such as `london`, `paris`, `new-york`, `los-angeles`, `berlin` or `barcelona`. Names such as `New York` or `München` work too.
2. Fill **Start date** and **End date** with days in the event's local calendar. Both take `YYYY-MM-DD` or a day counted from the run, like `today`, `tomorrow` or `+30`. With both empty, the run covers everything Dice has announced.
3. Narrow the results if you need to: **Event types**, **Keywords (any of)**, **Minimum price** and **Maximum price** in the local currency, and **Sold-out events** (include them, only them, or leave them out).
4. To follow particular events, paste their dice.fm links into **Event links**. Linked events are returned whatever the filters say.
5. Set **Maximum events** and click **Start**. The events appear in the **Output** tab, soonest first, and download as CSV, Excel or JSON. The run's counts are in the `SUMMARY` record of its key-value store. Over the API, an input looks like this:

```json
{
  "cities": ["london", "manchester"],
  "dateFrom": "today",
  "dateTo": "+14",
  "eventTypes": ["gig", "dj"],
  "soldOut": "exclude",
  "maxItems": 2000
}
```

### Example output

A sold-out gig from a London run on 11 October 2026. The description is shortened here and ends with ` ...`; in the dataset it is the promoter's whole text.

```json
{
  "eventId": "6a042f885ff8da00017900c8",
  "url": "https://dice.fm/event/yowo6x-tiny-vipers-chantal-acda-red-river-dialect-11th-oct-sjq-london-tickets",
  "title": "Tiny Vipers + Chantal Acda + Red River Dialect",
  "status": "sold-out",
  "soldOut": true,
  "secondaryStatus": "waiting-list",
  "startAt": "2026-10-11T19:30:00+01:00",
  "endAt": "2026-10-11T23:00:00+01:00",
  "timezone": "Europe/London",
  "doorsOpenAt": "2026-10-11T19:30:00+01:00",
  "isMultiDay": false,
  "announcedAt": "2026-05-26T09:00:00+01:00",
  "saleStartAt": "2026-05-26T14:00:00+01:00",
  "saleEndAt": "2026-10-11T17:00:00+01:00",
  "venueName": "SJQ",
  "venueRoom": null,
  "venueAddress": "10A Bradbury Street, London N16 8JN",
  "venueUrl": "https://dice.fm/venue/sjq-4pqp",
  "venueCapacity": 75,
  "city": "London",
  "country": "United Kingdom",
  "countryCode": "GB",
  "latitude": 51.548677,
  "longitude": -0.0767180999999937,
  "lineup": [
    "Chantal Acda",
    "Tiny Vipers",
    "Red River Dialect"
  ],
  "lineupNotes": [],
  "promoter": "Mirror TV",
  "presentedBy": "Presented by Mirror TV.",
  "eventTypes": [
    "gig"
  ],
  "price": 12.5,
  "priceIsFrom": false,
  "currency": "GBP",
  "priceText": "£12.50",
  "hasMultipleTicketTypes": false,
  "ageRestriction": "This is an 18+ event.",
  "minimumAge": 18,
  "imageUrl": "https://dice-media.imgix.net/attachments/2026-05-12/e49e9354-96e9-4ac5-bccc-df9b3f21c2d7.jpg?rect=0%2C400%2C2000%2C1200",
  "description": "MIRROR TV IS HAPPY TO PRESENT!\n\nTINY VIPERS - CHANTAL ACDA - RED RIVER DIALECT (SOLO)\n\nSeattle’s Jesy Fortino has performed under the name Tiny Vipers since her teen years. ...",
  "source": "city:london",
  "scrapedAt": "2026-10-11T13:42:40.654Z"
}
```

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

| | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| 1,000 events | $1.50 | $1.20 | $0.975 | $0.75 |

You pay only for the events in the table. There is no start fee, and compute time and proxies are included.

A whole-city run for London on 11 October 2026 returned 6,154 events, which costs $9.231 on the Free plan and $4.6155 on Business. The 702 London events of the week from 11 to 17 October come to $1.053 on the Free plan. Events that your filters drop are read but not charged, and in the new-only mode the events returned before are skipped without being read.

### Limits

- Only upcoming events that Dice lists in its sitemaps are covered: 21,531 on 11 October 2026. Past events and hidden events are not available.
- Each event is read from its own page at about two per second. On 11 October 2026 the whole of London, 6,154 events, took 55 minutes, and the 50 events of the form's example took 33 seconds.
- Event types, keywords, prices and sold-out status are checked after an event is read, so a narrow filter takes as long as the same run without it: DJ events in Paris and Berlin over 14 days meant reading 252 events to return 19. The date range and the new-only mode work before reading and do shorten runs.
- Dice shows genres only as filters on its city pages, so there is no genre field. Put a genre into **Keywords (any of)** to match it in the title, lineup or description.
- Dice loads ticket types, their prices and their availability through its app, which the actor does not use. You get the lowest price, the sale status and whether there are several ticket types.
- The date range is first checked against the day in each event's link. In the London run of 11 October 2026 that day matched the real start date for 6,152 of 6,154 events; the other two had taken place in September and were still listed. If Dice ever kept an old day in the link of a rescheduled event, a date range could skip it.
- If Dice answers with a Cloudflare challenge, the actor stops sending requests, keeps the events it already has and says so in the run's status message.

### How cities are matched

Every Dice event link ends with the event's town, for example `https://dice.fm/event/yowo6x-...-sjq-london-tickets`. The actor reads Dice's sitemaps, keeps the links that end with your city and then reads those events. Organizers sometimes write the town in their own language, so common spellings are added for you: `london` also covers `londra`, `milan` covers `milano`, `new-york` covers `new-york-city`, and `munich` covers `mnchen`, Dice's spelling of München. Counted this way, Dice listed 6,154 upcoming events for London, 1,404 for New York, 948 for Paris and 225 for Berlin on 11 October 2026.

Towns next to a big city that organizers name on their own stay separate, for example `brooklyn`, `segrate` next to Milan or `montreuil` next to Paris; add them as extra cities. When Dice has no events under a city, the log says so and suggests close matches from Dice's links, and a run where no city matches stops with that message.

### Getting only new events

Turn on **Return only events new since the last run** and give a **Watch name** such as `london-gigs`, or save the input as a task. The actor remembers the events it returned under that name and skips them next time without reading them, so a daily run over the next month returns what Dice announced since the day before. An event cut off by **Maximum events** is not remembered and comes in the next run.

### FAQ

#### Is it legal to scrape Dice?

The actor reads public event pages and the sitemaps Dice publishes for search engines, at about two requests per second and without logging in. It reads only pages that Dice's robots.txt allows and does not use Dice's app API. The data describes events, venues, promoters and the performers billed on public pages; nothing about ticket buyers or other users is collected. You are responsible for how you use the data.

#### Which towns can I use?

Any town that appears at the end of Dice's event links. Besides the big cities, Dice listed 661 events for `manchester`, 579 for `bristol`, 411 for `chicago`, 234 for `chelmsford` and 196 for `boise` on 11 October 2026. Small towns may have only a few events or none in a given month.

#### Can I track sold-out events and price changes?

Yes. Schedule a run over a city and dates, or over a list of event links, and compare `status`, `soldOut`, `secondaryStatus` and `price` between runs. Event links skip the filters, so a watched event stays in the output whatever its status.

### Related scrapers

- [Eventbrite Events Scraper](https://apify.com/deriverge/eventbrite-scraper)
- [Meetup Events Scraper](https://apify.com/deriverge/meetup-scraper)
- [Luma Events Scraper](https://apify.com/deriverge/luma-events-scraper)

### Support

This actor is built and maintained by deriverge s.r.o., a software company based in the Czech Republic. If a run fails or a field you need is missing, please open an issue in the **Issues** tab or write to us at info@deriverge.com. We respond in English and Czech. Runs can be scheduled in Apify Console or started from the **API** tab, which has examples for Python, JavaScript and cURL and works with Make, Zapier, n8n and the Apify MCP server. If the actor saves you time, a short review helps other people find it.

# Changelog

This Actor's version history is a separate document: https://apify.com/deriverge/dice-events-scraper/changelog.md

# Actor input Schema

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

Cities as Dice writes them at the end of its event links, for example london, paris, new-york, los-angeles, berlin or barcelona. Names such as New York or München work too, and common local spellings (londra, milano, new-york-city) are added for you. Each city returns every upcoming event Dice lists for it.

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

Optional dice.fm event links, for example https://dice.fm/event/q2x97y-suir-de-parastatic-colour-me-blood-red-24th-oct-strongroom-london-tickets. Use them alone or together with cities.

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

Keep events that start on or after this day, in the event's local time: YYYY-MM-DD, or a moving date such as today, tomorrow or +7. A saved task with moving dates keeps covering the coming days. Leave empty for every upcoming event.

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

Keep events that start on or before this day: YYYY-MM-DD, or a moving date such as +30 for a rolling month. Leave empty for no end.

## `eventTypes` (type: `array`):

Keep only these kinds of events, as Dice labels them. Leave empty for all.

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

Keep events whose title, lineup, venue, promoter or description contains any of these, for example techno, jazz or an artist name. Words of one or two letters, such as DJ, must appear as a whole word.

## `minPrice` (type: `integer`):

Keep events whose lowest ticket price is at least this much, in the event's own currency (pounds in London, euros in Paris).

## `maxPrice` (type: `integer`):

Keep events whose lowest ticket price is at most this much, in the event's own currency. Use 0 for free events only.

## `soldOut` (type: `string`):

Keep every event, only the sold-out ones, or only those still on sale or not yet on sale.

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

Adds the promoter's full event text to each row. Keywords are searched in it either way.

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

Stop after this many events, so the cost of a run stays predictable. Events are read from the soonest date onwards.

## `newOnly` (type: `boolean`):

Keeps a list of the events this watch name (or saved task) has returned and skips them next time, without reading them again. Schedule it daily for an alert on newly announced events.

## `watchName` (type: `string`):

Name of the list used by the new-only mode, for example london-techno. Runs of a saved task get one automatically.

## Actor input object example

```json
{
  "cities": [
    "london"
  ],
  "dateFrom": "today",
  "dateTo": "+7",
  "soldOut": "include",
  "includeDescription": true,
  "maxItems": 50,
  "newOnly": false
}
```

# Actor output Schema

## `events` (type: `string`):

One row per event with times, venue, price, sold-out status, lineup and promoter.

## `summary` (type: `string`):

Event links found for each city, events read and returned, and how many each filter dropped.

# 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"
    ],
    "dateFrom": "today",
    "dateTo": "+7",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/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 = {
    "cities": ["london"],
    "dateFrom": "today",
    "dateTo": "+7",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("deriverge/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 '{
  "cities": [
    "london"
  ],
  "dateFrom": "today",
  "dateTo": "+7",
  "maxItems": 50
}' |
apify call deriverge/dice-events-scraper --silent --output-dataset

```

## MCP server setup

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