# Dice.fm Scraper (`hoholabs/dicefm-scraper`) Actor

Fetch events from Dice.fm by city, artist, venue, genre, or date range. No API key required.

- **URL**: https://apify.com/hoholabs/dicefm-scraper.md
- **Developed by:** [Hoho](https://apify.com/hoholabs) (community)
- **Categories:** Travel
- **Stats:** 31 total users, 4 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Dice.fm Scraper

No API key. No account. Look up an artist's or venue's upcoming shows, browse a city's events, search by name, filter by genre or date — or pull the full worldwide city and venue directories. Clean JSON back.

Fetches event data from [Dice.fm](https://dice.fm): dates, venues, lineups, ticket types, pricing, images, and genre tags.

### Why this scraper?

- **No Dice.fm account or API key required**
- **Six query modes** — artist events, venue events, browse (city/country/genre/date filters), text search, and the city + venue directories
- **Rich event data** — dozens of fields per event including ticket pricing, lineup with set times, multiple image formats, age limits, and sold-out status
- **Exact artist, venue & city filtering** — every result is genuinely scoped to what you asked for (not a fuzzy keyword match), with full pagination

### What you can fetch

- **Artist events** — all upcoming shows for a specific artist, filtered exactly by artist ID
- **Venue events** — all upcoming events at a specific venue, filtered exactly by venue ID
- **Browse events** — filter by city, country, date range, and/or genre/type tag
- **Search events** — full-text search across event names, artists, and venues
- **City directory** — the ~79 cities Dice operates in, with names and IDs
- **Venue directory** — ~5,000 venues worldwide with names, coordinates, and IDs

> **How artist / venue / city lookup works:** you pass a name, and the scraper
> resolves it to Dice's internal ID before fetching that ID's exact event list —
> artists and venues via Dice's search, cities via the city directory. Name
> resolution is fuzzy, so an obscure artist/venue may not resolve — if it doesn't,
> you get an empty result with the `resolved` id `null`. You can pass a numeric
> Dice ID (artist/venue) or a city ID directly to skip resolution. Get city IDs
> from `queryType=cities`, venue IDs from `queryType=venues`.

> **Not supported (confirmed genuinely dead upstream):** filtering by status,
> sold-out, or sort order. Dice's public events API has no working parameter for
> these in any form (checked singular, plural, and ID variants). Results come
> date-ascending by default. See `core/api.md` for the full investigation.

### Usage

Choose a `queryType` and provide the appropriate inputs.

#### Get all upcoming shows for an artist

```json
{ "queryType": "artist", "performer": "Bicep" }
```

#### Get all events at a venue

```json
{ "queryType": "venue", "venue": "Public Records" }
```

#### Browse events in a city

```json
{ "queryType": "browse", "city": "London" }
```

#### Browse events across a country

```json
{ "queryType": "browse", "country": "GB", "genreTag": "gig:techno" }
```

#### Browse events in a date range

```json
{ "queryType": "browse", "dateFrom": "2026-04-01", "dateTo": "2026-04-30" }
```

#### Search events by name

```json
{ "queryType": "search", "q": "jazz festival" }
```

#### Get the city or venue directory

```json
{ "queryType": "cities" }
```

### Input fields

| Field | Type | Description |
|---|---|---|
| `queryType` | select | `browse` (default), `search`, `artist`, `venue`, `cities`, or `venues` |
| `q` | string | Text to search. Required for `queryType=search` |
| `performer` | string | Artist name (e.g. `Bicep`), or a numeric Dice artist ID to skip name lookup. Required for `queryType=artist` |
| `venue` | string | Venue name (e.g. `Public Records`), or a numeric Dice venue ID (from `queryType=venues`) to skip name lookup. Required for `queryType=venue` |
| `city` | string | Filter browse by city — a city name (e.g. `London`, `New York`) or a Dice city ID (from `queryType=cities`) — **honored** |
| `country` | string | Filter browse by ISO-2 country code (e.g. `GB`, `US`, `DE`) — returns events across all of that country's Dice cities — **honored** |
| `dateFrom` | string | Start of date range in `YYYY-MM-DD` format — **honored** (works with artist/venue/browse) |
| `dateTo` | string | End of date range in `YYYY-MM-DD` format — **honored** |
| `genreTag` | string | Filter by genre tag (e.g. `gig:techno`, `gig:hardrock`, `culture:foodanddrink`) — **honored** |
| `typeTag` | string | Filter by top-level type tag (e.g. `music:gig`, `culture:sport`) — **honored** |
| `page` | integer | Page number for pagination (default 1) — **honored** |
| `pageSize` | integer | Results per page (default 50, max 50) — **honored** |

### Output

Each run pushes one item per event (or venue) to the dataset.

> **Note on `queryType=search`:** search results come from a different upstream
> endpoint than the others, so a few fields are always empty for search results
> specifically: `description`, `age_limit`, `ticket_types`, `genre_tags`.
> Everything else (dates, venue, artists, pricing, images, URL) is populated.
> Use `queryType=browse`, `artist`, or `venue` for full ticket-type detail —
> those come through the events API with the complete event object.

> **Note on `resolved` (artist / venue / city-filtered modes):** `queryType=artist`,
> `queryType=venue`, and any `browse` with a `city`/`country` filter include a
> `resolved` object showing which Dice ID(s) the name mapped to — e.g.
> `{ "artistId": "620", "name": "Bicep" }` or
> `{ "city": "London", "country": null, "cityIds": ["54d8a23438fe5d27d500001c"] }`.
> If nothing resolved, the ID(s) are `null`/empty and `data` is empty (the filter
> is never silently dropped).

> **Note on `artists` and `price` (browse results):** in practice, Dice.fm's
> browse feed returns `[]` for `artists` and `null` for `price` on the large
> majority of events (confirmed across 100+ live events) — most listings carry
> their lineup in `lineup` instead and their pricing in `ticket_types`. Fields
> are documented as-is (not removed) since they're real, populated fields on
> `queryType=search` results and on some browse events.

#### Event item

| Field | Description |
|---|---|
| `id` | Dice.fm event ID |
| `name` | Event name |
| `date` | Start date/time (ISO 8601, UTC) |
| `date_end` | End date/time — set for multi-day events |
| `timezone` | IANA timezone (e.g. `Europe/London`) |
| `status` | `on-sale`, `off-sale`, or `cancelled` |
| `sold_out` | Whether the event is sold out |
| `venue` | Venue name |
| `venues` | Array of venue objects with ID, name, city, and Dice.fm URL |
| `location` | Object with street, city, state, zip, country, lat, lng |
| `cities` | Array of city objects with code, name, and country |
| `description` | Full event description |
| `age_limit` | Age restriction text (e.g. `18+`) |
| `presented_by` | Presenter/organizer |
| `artists` | Array of artist objects on the bill — see empty-fields note above |
| `lineup` | Array of lineup entries with set times |
| `ticket_types` | Array of ticket types with face value, fees, and total price |
| `price` | Base ticket price (null if free, variable, or not exposed — see note above) |
| `currency` | Currency code (e.g. `USD`, `GBP`) |
| `genre_tags` | Genre tags (e.g. `gig:techno`, `gig:hardrock`) |
| `type_tags` | Event type tags (e.g. `music:gig`, `culture:sport`) |
| `event_images` | Object with landscape, portrait, square, and brand image URLs |
| `url` | Dice.fm event link |
| `flags` | Feature flags (e.g. `qr-code`, `going_ahead`, `cancelled`) |

#### Venue item (queryType=venues)

| Field | Description |
|---|---|
| `venue_id` | Dice.fm venue ID (string, not numeric) |
| `name` | Venue name |
| `bundle_url` | Dice.fm venue slug |
| `location.full_address` | Full street address |
| `location.city.name` | City name |
| `location.country` | Country |
| `location.lat` / `location.long` | Coordinates |
| `location.place` | IANA timezone (e.g. `America/New_York`) |

#### City item (queryType=cities)

| Field | Description |
|---|---|
| `id` | Dice.fm city ID — pass as `city` to `queryType=browse` |
| `name` | City name (e.g. `London`) |
| `perm_name` | City slug |
| `country_code` | ISO-2 country code (e.g. `GB`) — pass as `country` to browse |
| `country_name` | Country name |
| `location.lat` / `location.lng` | Coordinates |
| `location.place` | IANA timezone |

### Use cases

- **City event feeds** — browse everything happening in a city (`queryType=browse`, `city=`) or across a whole country (`country=`)
- **Artist tour tracking** — pull an artist's full upcoming Dice show list by name (`queryType=artist`), exactly filtered
- **Venue calendars** — pull a venue's full upcoming schedule (`queryType=venue`) by name or ID
- **Concert discovery apps** — combine city, genre, and date filters to power location-aware feeds
- **Ticket monitoring** — watch sold-out status and ticket availability across an artist's, venue's, or city's events
- **Event aggregation** — combine Dice.fm with other scrapers for cross-platform coverage
- **Analytics** — genre trends by city, promoter activity

***

This scraper is not affiliated with Dice.fm. Please use responsibly and in accordance with Dice.fm's terms of service.

# Actor input Schema

## `queryType` (type: `string`):

What to fetch: browse events (city/genre/date filters), city directory, search events by name, events by artist/performer, events by venue, venue directory.

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

Filter by city name or slug (e.g. london, new-york, berlin).

## `country` (type: `string`):

Filter by country code (e.g. US, GB, DE).

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

Start of date range in YYYY-MM-DD format (e.g. 2026-04-01).

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

End of date range in YYYY-MM-DD format (e.g. 2026-04-30).

## `status` (type: `string`):

Filter by event status: active or cancelled.

## `soldOut` (type: `boolean`):

If false, return only events with tickets available.

## `featured` (type: `boolean`):

If true, return only featured events.

## `genreTag` (type: `string`):

Filter by genre tag (e.g. music:hiphop, music:electronic, culture:foodanddrink).

## `typeTag` (type: `string`):

Filter by type tag.

## `sort` (type: `string`):

Sort results. Use date for oldest first or -date for newest first.

## `page` (type: `integer`):

Page number for pagination (1-based, default 1).

## `pageSize` (type: `integer`):

Number of results per page (default 50, max 50).

## `q` (type: `string`):

Text to search for in event names. Required for queryType=search.

## `performer` (type: `string`):

Artist or performer name (e.g. LCD Soundsystem). Required for queryType=artist.

## `venue` (type: `string`):

Venue name (exact) or numeric Dice venue id from the venue directory.

## Actor input object example

```json
{
  "queryType": "browse",
  "city": "london",
  "status": "",
  "sort": "",
  "page": 1,
  "pageSize": 50
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("hoholabs/dicefm-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("hoholabs/dicefm-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 '{}' |
apify call hoholabs/dicefm-scraper --silent --output-dataset

```

## MCP server setup

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