# Electronic Music Events Scraper - EDM Concerts & Festivals (`payai/edmtrain-scraper`) Actor

🎵 Discover electronic music events, EDM concerts, raves, and festivals across 15 major US cities. Extract comprehensive event data including artist lineups, venues, dates, ticket prices, and more. Perfect for event discovery apps, market analysis, and tracking your favorite DJs.

- **URL**: https://apify.com/payai/edmtrain-scraper.md
- **Developed by:** [PayAI](https://apify.com/payai) (community)
- **Categories:** Travel
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 1.00 out of 5 stars

## Pricing

$10.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

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

## EDMTrain Electronic Events Scraper

🎵 A powerful Apify actor that scrapes electronic music events from EDMTrain.com across major US cities.

### Features

- 🏙️ **15 Major Cities**: New York, Los Angeles, Chicago, San Francisco, Miami, Las Vegas, Austin, Seattle, Denver, Atlanta, Boston, Detroit, Dallas, Philadelphia, Phoenix
- 🎧 **Comprehensive Event Data**: Event titles, dates, venues, artist lineups, prices, images
- 📊 **Customizable**: Choose cities and number of events per city
- 🔄 **Smart Pagination**: Automatically handles infinite scroll and pagination
- 💾 **Structured Output**: Clean JSON/CSV export ready for databases

### What Gets Scraped

- **Event Title**: Name of the electronic music event
- **Date & Time**: When the event is happening
- **Venue**: Location name and address
- **City & State**: Geographic location
- **Artists/Lineup**: DJs and performers
- **Ticket Price**: Cost information
- **Event URL**: Direct link to event details
- **Image**: Event poster/flyer
- **Genre**: Type of electronic music
- **Age Restriction**: 18+, 21+, All Ages
- **Source**: EDMTrain reference

### Input Configuration

```json
{
  "eventsPerCity": 50,
  "cities": ["Miami", "New York", "Los Angeles", "Las Vegas", "Chicago"],
  "includeLineups": true,
  "includePrices": true,
  "debug": false
}
````

#### Parameters

- **eventsPerCity** (number): Maximum events to scrape per city (1-200, default: 50)
- **cities** (array): List of cities to scrape (default: top 10 cities)
- **includeLineups** (boolean): Include detailed artist information (default: true)
- **includePrices** (boolean): Include ticket pricing (default: true)
- **debug** (boolean): Enable detailed logging (default: false)

### Output Example

```json
{
  "title": "Deadmau5 at LIV Nightclub",
  "date": "2025-08-30",
  "venue": "LIV Nightclub",
  "city": "Miami",
  "state": "FL",
  "artists": "Deadmau5",
  "lineup": "Deadmau5, Special Guests",
  "price": "$75-150",
  "eventUrl": "https://edmtrain.com/fl/miami/event-12345",
  "imageUrl": "https://edmtrain.com/images/event-12345.jpg",
  "genre": "Progressive House",
  "ageRestriction": "21+",
  "category": "Electronic Music",
  "source": "EDMTrain",
  "scrapedAt": "2025-08-20T21:00:00.000Z"
}
```

### Use Cases

- 📅 **Event Discovery Apps**: Build apps that help users find electronic music events
- 🎫 **Ticket Aggregators**: Compare prices across different events
- 📊 **Market Analysis**: Analyze electronic music trends by city
- 🎵 **Artist Tracking**: Follow specific DJs and their tour dates
- 🏢 **Venue Analytics**: Track which venues host the most events

### Deployment

#### Local Testing

```bash
npm install
npm start
```

#### Deploy to Apify

```bash
apify login
apify push
```

### Integration with Databases

The scraper outputs clean JSON that can be easily imported into:

- **Supabase**: Direct upsert with event URLs as unique keys
- **MongoDB**: Document-based storage for flexible queries
- **PostgreSQL**: Structured relational database
- **Elasticsearch**: Full-text search capabilities

### API Usage

```javascript
// Run via Apify API
const response = await fetch('https://api.apify.com/v2/acts/YOUR_USERNAME~edmtrain-scraper/runs', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': 'Bearer YOUR_API_TOKEN'
  },
  body: JSON.stringify({
    eventsPerCity: 50,
    cities: ["Miami", "New York", "Las Vegas"]
  })
});
```

### Rate Limits & Costs

- **Free Tier**: ~100-200 events per run
- **Paid Usage**: ~$0.10-0.20 per 500 events
- **Recommended**: Run daily for fresh event updates

### Error Handling

The scraper includes:

- Automatic retries on failed requests
- Fallback selectors for different page layouts
- Graceful handling of missing data
- Detailed error logging in debug mode

### Support

- **Issues**: Report bugs via GitHub issues
- **Updates**: Check for actor updates regularly
- **API Docs**: https://docs.apify.com

### License

MIT License - Free to use and modify

***

Built with ❤️ for the electronic music community

# Actor input Schema

## `eventsPerCity` (type: `integer`):

Maximum number of electronic events to scrape per city

## `includeLineups` (type: `boolean`):

Include detailed artist lineup information

## `includePrices` (type: `boolean`):

Include ticket pricing information

## `debug` (type: `boolean`):

Enable detailed logging for debugging

## Actor input object example

```json
{
  "eventsPerCity": 50,
  "includeLineups": true,
  "includePrices": true,
  "debug": false
}
```

# 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 = {
    "eventsPerCity": 50
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Electronic Music Events Scraper - EDM Concerts & Festivals",
        "description": "🎵 Discover electronic music events, EDM concerts, raves, and festivals across 15 major US cities. Extract comprehensive event data including artist lineups, venues, dates, ticket prices, and more. Perfect for event discovery apps, market analysis, and tracking your favorite DJs.",
        "version": "1.0",
        "x-build-id": "Tygcf6fqVWSe2W12l"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/payai~edmtrain-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-payai-edmtrain-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/payai~edmtrain-scraper/runs": {
            "post": {
                "operationId": "runs-sync-payai-edmtrain-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/payai~edmtrain-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-payai-edmtrain-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",
                "properties": {
                    "eventsPerCity": {
                        "title": "Events per city",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of electronic events to scrape per city",
                        "default": 50
                    },
                    "includeLineups": {
                        "title": "Include artist lineups",
                        "type": "boolean",
                        "description": "Include detailed artist lineup information",
                        "default": true
                    },
                    "includePrices": {
                        "title": "Include ticket prices",
                        "type": "boolean",
                        "description": "Include ticket pricing information",
                        "default": true
                    },
                    "debug": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Enable detailed logging for debugging",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```