# Resident Advisor (RA) Events & Music Data Scraper (`hypebridge/resident-advisor-scraper`) Actor

Extracts events from Resident Advisor (ra.co) by city, plus the venues, promoters, artists and labels behind them and RA's news, reviews, features and podcasts. Paste an RA URL, set a result cap and download clean, structured data without an official API.

- **URL**: https://apify.com/hypebridge/resident-advisor-scraper.md
- **Developed by:** [Hypebridge](https://apify.com/hypebridge) (community)
- **Categories:** Automation, E-commerce, Integrations
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 detailed ra records

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

### What does Resident Advisor Scraper do?

**Resident Advisor Scraper** extracts events from [Resident Advisor (ra.co)](https://ra.co) by city, plus the venues, promoters, artists and labels behind them and RA's news, reviews, features and podcasts. Paste an RA URL, set a result cap and download clean, structured data without an official API.

### Why scrape Resident Advisor?

- **Nightlife and club listings**: build a city event calendar with start and end times already converted to the right UTC offset for each city.
- **Promoter and venue research**: find who runs which nights, venue capacity and coordinates, follower counts and contact links that RA shows publicly.
- **Booking and artist intelligence**: see lineups, linked artist profiles, genres and how many people marked themselves as attending.
- **Music editorial monitoring**: track RA news, album reviews, features and podcast episodes over any date range.

### What data can Resident Advisor Scraper extract?

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | String | `event`, `venue`, `promoter`, `artist`, `label`, `news`, `review`, `feature` or `podcast` |
| `title` / `name` | String | Event or article title; venue, promoter, artist or label name |
| `startsAt`, `endsAt` | String | ISO 8601 with UTC offset, plus `startsAtUtc` and the city `timezone` |
| `priceText` | String | RA's own price text, exactly as shown |
| `priceMin`, `priceMax`, `priceCurrency` | Number / String | Parsed price when it is unambiguous, with a `priceConfidence` flag |
| `venue`, `area`, `country` | Object | Where the event is, with the currency RA uses for that country |
| `artists`, `promoters`, `genres` | Array | Linked profiles and genres |
| `lineup` | Array | Full lineup including names that are not linked to an artist page (detail mode) |
| `attending`, `interestedCount` | Number | RA community interest |
| `market` | String | ISO country code of the record |
| `url`, `sourceUrl` | String | The RA page and the URL you supplied |

The full field list is on the **Output** tab.

### How to scrape Resident Advisor

1. [Create a free Apify account](https://apify.com) if you don't have one.
2. Open **Resident Advisor Scraper** and click **Try for free**.
3. Add one or more RA URLs, for example a city page such as `https://ra.co/events/uk/london`.
4. Set **Maximum records** to cap the run, and switch on **Get full event details** if you want descriptions, lineups and venue details.
5. Click **Start** and download results from the **Dataset** tab as JSON, CSV, Excel or HTML.

### Which URLs are supported?

| URL | What you get |
|-----|--------------|
| `https://ra.co/events/{country}/{city}` | Events for that city over your date range |
| `https://ra.co/events/{id}` | One event with full detail |
| `https://ra.co/clubs/{id}` | A venue |
| `https://ra.co/promoters/{id}` | A promoter |
| `https://ra.co/dj/{slug}` | An artist |
| `https://ra.co/labels/{id}` | A label |
| `https://ra.co/news/{id}`, `/reviews/{id}`, `/features/{id}`, `/podcast/{id}` | One article with full content |
| `https://ra.co/news`, `/reviews`, `/features`, `/podcasts` | Articles published in your date range |

**City pages** work for the United Kingdom (`uk`), United States (`us`), Germany (`de`), Netherlands (`nl`), Spain (`es`), Australia (`au`) and Japan (`jp`). A city page for any other country is skipped with a warning and the rest of your run continues. Event, venue, promoter, artist, label and article URLs work for any country.

Use RA's own country code in the URL: the United Kingdom is `uk`, not `gb`.

### Input

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | Array | required | RA URLs to scrape (up to 50, at most 10 city pages) |
| `maxItems` | Number | 100 | Total records across all URLs (maximum 10,000) |
| `getEventDetails` | Boolean | true | Add description, lineup, venue capacity and coordinates; set to false for listing-only events |
| `dateFrom`, `dateTo` | String | next 30 days (events) / last 30 days (feeds) | `YYYY-MM-DD` or relative such as `7 days`; both ends inclusive |
| `getArticleDetails` | Boolean | false | Add blurb and full content to feed articles |
| `maxConcurrency` | Number | 2 | Parallel requests (1 to 4) |
| `maxRequests` | Number | 2000 | Hard request budget; the run stops cleanly when it is reached |

URLs are processed in order and share one `maxItems` cap, so put the pages you care about most first.

#### Example input

```json
{
  "startUrls": [{ "url": "https://ra.co/events/de/berlin" }],
  "maxItems": 200,
  "dateFrom": "2026-10-10",
  "dateTo": "2026-10-17",
  "getEventDetails": true
}
```

```json
{
  "startUrls": [{ "url": "https://ra.co/reviews" }, { "url": "https://ra.co/podcasts" }],
  "maxItems": 100,
  "dateFrom": "90 days",
  "dateTo": "0 days"
}
```

### Output

Each item is saved to the **Dataset** tab. Records of different kinds share one dataset; `recordType` tells them apart, and the dataset views show only the columns that suit each kind.

#### Sample output

```json
{
  "recordType": "event",
  "id": "2524382",
  "url": "https://ra.co/events/2524382",
  "market": "GB",
  "title": "Example Night",
  "startsAt": "2026-10-10T15:00:00+01:00",
  "startsAtUtc": "2026-10-10T14:00:00Z",
  "timezone": "Europe/London",
  "priceText": "12-20",
  "priceMin": 12,
  "priceMax": 20,
  "priceCurrency": "GBP",
  "priceConfidence": "high",
  "venue": { "id": "267817", "name": "Example Club", "capacity": 170 },
  "artists": [{ "id": "98659", "name": "Example DJ" }],
  "isDetailed": true,
  "scrapedAt": "2026-10-03T12:00:00.000Z"
}
```

### Tips

- RA's price field is free text. `priceText` is always the source of truth; `priceMin` and `priceMax` are filled only when the text is unambiguous, and an empty price is never reported as free.
- Event records can appear under several listing days (festivals). You get one record per event, with every day it was listed in `listingDates`.
- Set `maxItems` before a large run. Full event details cost one extra request per event.
- Every run writes a `RUN_SUMMARY` record to the key-value store with counts, skipped URLs and any coverage warnings.

### FAQ

#### Is scraping Resident Advisor legal?

Resident Advisor Scraper only extracts publicly available data. Always check the site's Terms of Service and make sure you have a legitimate purpose for the data.

#### Why did a city page get skipped?

City pages are supported for seven countries (listed above). Other countries are skipped with a warning rather than guessed.

#### Does it return ticket prices per tier?

No. RA publishes a single free-text price line per event, which is returned as `priceText` with a parsed range where possible.

#### Does it return private or ticketing data?

No. Only public pages' information is returned; there is no ticket-sales, guest-list or account data.

### Support

- Bugs and feature requests: **Issues** tab
- Programmatic access: **API** tab

> **Disclaimer**: Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

# Actor input Schema

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

RA URLs: a city events page (https://ra.co/events/uk/london), an event (/events/{id}), venue (/clubs/{id}), promoter (/promoters/{id}), artist (/dj/{slug}), label (/labels/{id}), an article (/news/{id}, /reviews/{id}, /features/{id}, /podcast/{id}) or a feed (/news, /reviews, /features, /podcasts). City pages work for the UK, US, Germany, Netherlands, Spain, Australia and Japan. URLs are processed in order and share one result cap.

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

Global maximum number of unique records returned across all start URLs.

## `getEventDetails` (type: `boolean`):

Fetch each listed event individually to add the description, raw lineup, venue capacity and coordinates, status and update timestamps. Direct event URLs always return full detail.

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

First day, inclusive. Use YYYY-MM-DD, or a relative value such as "7 days" meaning that long BEFORE today. Applies to city event pages and feeds. Default: today for events (in the city's time zone), 30 days ago for feeds.

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

Last day, inclusive. Use YYYY-MM-DD, or a relative value such as "30 days" meaning that long AFTER today. Events: at most 366 days after the From date. Default: 30 days from the From date for events, today for feeds.

## `getArticleDetails` (type: `boolean`):

For news, review, feature and podcast feeds, fetch each article by ID to add the blurb and full content. Direct article URLs always return full content.

## `maxConcurrency` (type: `integer`):

Maximum simultaneous requests. Keep it low; RA's sustained-rate tolerance is unproven.

## `maxRequests` (type: `integer`):

Hard budget on HTTP attempts, retries included. A detailed event costs about one request, so raise this above 2,000 for detailed runs of more than about 1,500 events. The run stops gracefully and reports the cut-off.

## `debugMode` (type: `boolean`):

Verbose routing and window logs, plus up to 10 failed-response artifacts (64 KB each) in the key-value store.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://ra.co/events/uk/london"
    }
  ],
  "maxItems": 500,
  "getEventDetails": true,
  "getArticleDetails": false,
  "maxConcurrency": 2,
  "maxRequests": 2000,
  "debugMode": false
}
```

# Actor output Schema

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

Dataset containing every scraped Resident Advisor record

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

Counts, skipped URLs, coverage warnings and any cut-off reason for this run

# 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://ra.co/events/uk/london"
        }
    ],
    "maxItems": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("hypebridge/resident-advisor-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://ra.co/events/uk/london" }],
    "maxItems": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("hypebridge/resident-advisor-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 '{
  "startUrls": [
    {
      "url": "https://ra.co/events/uk/london"
    }
  ],
  "maxItems": 500
}' |
apify call hypebridge/resident-advisor-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hypebridge/resident-advisor-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/eRjCxXUYtt92qu2N8/builds/3k02nDCBE0R29oAGd/openapi.json