# Skiddle Events Scraper (`kinaesthetic_millionaire/skiddle-events-scraper`) Actor

Extract event listings from Skiddle.com - names, venues, dates, locations, prices, images and ticket details for clubs, gigs, festivals and more.

- **URL**: https://apify.com/kinaesthetic\_millionaire/skiddle-events-scraper.md
- **Developed by:** [Parsedom Inc](https://apify.com/kinaesthetic_millionaire) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

**Extract event listings from [Skiddle.com](https://www.skiddle.com)** in seconds — no coding, no manual copy-pasting. Skiddle Events Scraper pulls event names, venues, dates, locations, prices, images, descriptions and full ticket details from any city, club, gig, or festival listing page on Skiddle, and delivers it to you as clean, ready-to-use data.

### What does Skiddle Events Scraper do?

Skiddle Events Scraper takes one or more [Skiddle](https://www.skiddle.com) listing page links — a city's clubs, gigs, festivals, or general "what's on" page — and automatically collects every event listed there: name, venue, date, location, ticket prices, images, descriptions, and a full breakdown of available ticket types. Just paste in a link, click **Start**, and download your results as JSON, CSV, Excel, or HTML — whichever format fits your workflow.

Because it runs on the Apify platform, you also get automatic scheduling, API access, and integrations with tools like Google Sheets, Zapier, Make, and Slack, so your event data can update itself on a schedule without you lifting a finger.

### Why use Skiddle Events Scraper?

Skiddle lists tens of thousands of club nights, gigs, festivals, and family events across the UK. Manually browsing listings and copying details into a spreadsheet is slow and error-prone. This actor does that work for you, instantly and accurately. Typical use cases include:

- **Event promoters and venues** tracking competitor events, pricing, and ticket availability in their area.
- **Marketing and media teams** building local "what's on" content, newsletters, or event calendars without manual research.
- **Ticket resellers and price comparison sites** monitoring ticket prices and sell-out status across many events at once.
- **Researchers and analysts** studying nightlife, live music, or festival trends by city or region over time.
- **App and website developers** who need a structured, up-to-date feed of local events to power their own product.

### How to use Skiddle Events Scraper

Getting started takes less than a minute:

1. Open the Skiddle Events Scraper page on Apify and click **Try for free** (or **Start**, if you already have it).
2. Paste in one or more Skiddle listing page links — for example a city's clubs page (`skiddle.com/clubs/London/`), gigs page, festivals page, or general "what's on" page for a location.
3. Set how many events you'd like to collect (or leave the default).
4. Click **Start** and watch the run progress live.
5. Once finished, open the **Output** tab to preview your data, or download it in your preferred format.

No account with Skiddle is required, and you don't need any technical or coding knowledge to use this actor.

### Input

Skiddle Events Scraper takes a simple input, configurable from the Input tab in Apify Console:

- **Start URLs** — one or more Skiddle listing/category pages to scrape (for example a city's clubs, gigs, festivals, or "what's on" page). Links to single, individual event pages are not supported — always use a listing page for a city or category.
- **Max Items** — the maximum number of events to collect per run. Defaults to a small number so you can try the actor out cheaply before scaling up.
- **Proxy Configuration** — uses Apify Proxy by default so your runs stay reliable; most users can leave this on its default setting.

### Output

Every event is returned as a single, structured record. Here's a simplified example of what you'll get:

```json
{
    "name": "Our House W/ Meduza & James Hype",
    "url": "https://www.skiddle.com/whats-on/London/Magazine-Open-Air/Our-House-W-Meduza--James-Hype/42147225/",
    "venue": "Magazine Open Air",
    "town": "London",
    "region": "London",
    "date": "2026-08-14",
    "minAge": 18,
    "priceMin": 52,
    "priceMax": 126.95,
    "currency": "GBP",
    "description": "Two of the most electrifying names in dance music, MEDUZA and James Hype bring their collaborative project Our House to London.",
    "image": "https://d31fr2pwly4c4s.cloudfront.net/6/3/7/2215917_7b396d8f_our-house-meduza-and-james-hype.jpg",
    "ticketsAvailable": true,
    "tickets": [
        {
            "name": "General Admission - 1st Release",
            "price": { "face": 61.95, "fee": 6.44, "total": 68.39, "currency": "GBP" },
            "soldOut": true
        }
    ]
}
````

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel, or access it directly through the Apify API for use in your own apps and dashboards.

#### Data table

| Field | Description |
| --- | --- |
| `name` | Name of the event |
| `url` | Link to the event page on Skiddle |
| `venue` | Name of the venue hosting the event |
| `town` | Town or city where the event takes place |
| `region` | Region or area of the venue |
| `date` | Event date |
| `startDate` / `endDate` | Full start and end date/time of the event |
| `minAge` | Minimum age requirement, if any |
| `priceMin` / `priceMax` | Lowest and highest ticket prices available |
| `currency` | Currency of the listed prices |
| `description` | Short description of the event |
| `image` | Event promo image |
| `ticketsAvailable` | Whether tickets are currently on sale |
| `tickets` | Full breakdown of each ticket type, price, and availability |

### How much does it cost to scrape Skiddle event data?

Skiddle Events Scraper runs on the Apify platform's pay-per-usage pricing. Apify's free plan includes monthly platform credits, which is normally enough to try the actor out and run smaller jobs at no cost. Cost scales with the number of events and listing pages you scrape — collecting a handful of events for a single city costs a fraction of a cent, while larger jobs covering many cities or the full event catalogue will use proportionally more credits. Start with a smaller **Max Items** value to estimate cost before scaling up to a full run.

### Tips for getting the best results

- Start with a specific city and category page (e.g. clubs, gigs, or festivals for one city) rather than very broad searches, to keep runs fast and focused.
- Increase **Max Items** gradually so you can gauge run time and cost before committing to a large scrape.
- Combine multiple **Start URLs** in a single run (e.g. several cities) to build a broader dataset in one go.
- Schedule the actor to run daily or weekly on Apify to keep your event data continuously up to date.

### FAQ, disclaimers, and support

**Is it legal to scrape Skiddle event data?**
Skiddle Events Scraper only collects publicly available event information already shown on Skiddle's own website. That said, you are responsible for ensuring your use of the collected data complies with Skiddle's Terms of Service and any applicable laws in your jurisdiction.

**Can I scrape a single event page instead of a listing?**
Not currently — the actor is designed to work from listing pages (a city, club, gig, or festival page), which is also the most efficient way to collect many events at once.

**What if an event is missing some fields, like price or minimum age?**
Not every event on Skiddle publishes every field. When information isn't available, the corresponding field will simply be empty or `null`.

**Something isn't working, or I need a custom feature — what do I do?**
Head to the actor's Issues tab on Apify Store to report a bug or request a feature, or reach out using the details below.

#### 🤝 Support

Need help or have questions?

- Email us at <info@parsedom.com>
- Or visit <https://parsedom.com>
- Visit our profile on Fiverr: <https://www.fiverr.com/s/rEmNqEb>
- Apify public page: <https://apify.com/kinaesthetic_millionaire>

You can also contact us if you want to build a custom actor.

Ready to scrape more listings? Add your URLs and start scraping! 🚀

# Actor input Schema

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

Provide Skiddle city/category listing pages (e.g. clubs, gigs, festivals, whats-on for a location). Individual event detail pages are not supported. Invalid URLs will be ignored.

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

Maximum number of events to scrape

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

Proxy settings used for making requests to Skiddle

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.skiddle.com/clubs/Belfast/"
    }
  ],
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.skiddle.com/clubs/Belfast/"
        }
    ],
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kinaesthetic_millionaire/skiddle-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 = {
    "startUrls": [{ "url": "https://www.skiddle.com/clubs/Belfast/" }],
    "maxItems": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("kinaesthetic_millionaire/skiddle-events-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://www.skiddle.com/clubs/Belfast/"
    }
  ],
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call kinaesthetic_millionaire/skiddle-events-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Skiddle Events Scraper",
        "description": "Extract event listings from Skiddle.com - names, venues, dates, locations, prices, images and ticket details for clubs, gigs, festivals and more.",
        "version": "1.0",
        "x-build-id": "nzvIMise6BuYkdjIa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kinaesthetic_millionaire~skiddle-events-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kinaesthetic_millionaire-skiddle-events-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/kinaesthetic_millionaire~skiddle-events-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kinaesthetic_millionaire-skiddle-events-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/kinaesthetic_millionaire~skiddle-events-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kinaesthetic_millionaire-skiddle-events-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": "Start URLs",
                        "type": "array",
                        "description": "Provide Skiddle city/category listing pages (e.g. clubs, gigs, festivals, whats-on for a location). Individual event detail pages are not supported. Invalid URLs will be ignored.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "Skiddle listing or category page URL"
                                }
                            },
                            "required": [
                                "url"
                            ]
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of events to scrape",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings used for making requests to Skiddle",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
