# Eventbrite Dating Scraper (`payai/eventbrite-dating-scraper`)

Scrape real dating & singles events from EventBrite's official API. Get 400+ dating events across 10 major US cities (user customizable) with age group targeting!

- **URL**: https://beta-securitybyobscurity.apify.com/payai/eventbrite-dating-scraper.md
- **Developed by:** [PayAI](https://beta-securitybyobscurity.apify.com/payai) (community)
- **Categories:** Automation, Lead generation, Agents
- **Stats:** 4 total users, 4 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## 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 after the free trial period.
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

# README

## 💝 EventBrite Dating Events Scraper v1.3

A powerful Apify actor that scrapes real dating and singles events from EventBrite using advanced web scraping techniques. Perfect for dating apps, singles platforms, and event aggregators looking for comprehensive dating event data.

### 🌟 Features

- 💕 **Real EventBrite Data**: Direct scraping from EventBrite's dating category pages
- 🏙️ **10 Major US Cities**: New York, Los Angeles, Chicago, San Francisco, Miami, Austin, Seattle, Boston, Denver, Atlanta
- 📊 **40 Events Per City**: Default 40 (user customizable 1-100)
- 📄 **Pagination Support**: Scrapes multiple pages (1-3) for comprehensive coverage
- 🔄 **30+ URL Patterns**: Checks dating, singles, speed-dating, matchmaking categories
- 🖼️ **Event Thumbnails**: Properly extracts EventBrite event images
- 💰 **Price Detection**: Identifies free vs paid events
- 🌐 **Online & In-Person**: Detects virtual and physical events
- 🔁 **Retry Logic**: Up to 3 retries with intelligent fallbacks
- 🎯 **Duplicate Detection**: Uses event IDs to avoid duplicates

### 📋 Output Format

Each event includes:

- `id`: Unique event identifier
- `title`: Event name (up to 200 chars)
- `description`: Event description (up to 500 chars)
- `date`: Formatted event date
- `city`: City location
- `venue`: Venue name or "Venue TBD"
- `address`: Full address when available
- `price`: Ticket price or "Free"
- `eventUrl`: Direct EventBrite event link
- `imageUrl`: Event thumbnail from EventBrite
- `category`: "Dating & Singles"
- `isOnline`: Boolean for virtual events
- `source`: "EventBrite"
- `extractedAt`: Timestamp of extraction

### 🎯 Event Categories Scraped

For each city, the scraper checks:

- `/home-and-lifestyle/dating/`
- `/dating/`
- `/singles/`
- `/speed-dating/`
- `/dating-and-relationships/`
- `/singles-mixer/`
- `/singles-party/`
- `/matchmaking/`

Each category is paginated (pages 1-3) for maximum coverage.

### 🔧 Configuration

#### Default Settings

- **Cities**: 10 major US cities (user customizable)
- **Events per city**: 40 (user adjustable 1-100)
- **Include online**: Yes (configurable)
- **Max retries**: 3 per city
- **Pagination**: 3 pages per category

#### Input Parameters

```json
{
  "cities": [
    "New York",
    "Los Angeles",
    "Miami"
  ],
  "eventsPerCity": 40,
  "includeOnlineEvents": true,
  "maxRetries": 3
}
```

### 💻 Usage

#### Running on Apify

1. Go to the actor page: https://console.apify.com/organization/vK6fmobLbdfZEkiC4/actors/Sgb4KPT4gmTfh8569
2. Customize input parameters (optional)
3. Click "Run"
4. Export results as JSON, CSV, or Excel

#### API Integration

```javascript
// Run the actor
const response = await fetch('https://api.apify.com/v2/acts/payai~eventbrite-dating-scraper/runs', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer YOUR_APIFY_TOKEN'
    },
    body: JSON.stringify({
        cities: ["New York", "Miami"],
        eventsPerCity: 40
    })
});
```

#### Command Line

```bash
## Run with default settings
apify call eventbrite-dating-scraper

## Run with custom cities
apify call eventbrite-dating-scraper --input '{
  "cities": ["New York", "Miami", "Los Angeles"],
  "eventsPerCity": 30
}'
```

### 📊 Sample Output

```json
{
  "id": "7890123456",
  "title": "Speed Dating NYC - Ages 30-40",
  "description": "Meet 10-15 singles in one fun evening at our popular speed dating event...",
  "date": "Sat, Dec 14, 2024",
  "city": "New York",
  "venue": "The Manhattan Lounge",
  "price": "$45",
  "eventUrl": "https://www.eventbrite.com/e/speed-dating-nyc-tickets-7890123456",
  "imageUrl": "https://img.evbuc.com/https%3A%2F%2Fcdn.evbuc.com%2Fimages%2F...",
  "category": "Dating & Singles",
  "isOnline": false,
  "source": "EventBrite",
  "extractedAt": "2025-08-21T00:00:00.000Z"
}
```

### 🚀 Performance

- **Speed**: ~3-5 minutes per city
- **Coverage**: 30+ pages checked per city
- **Success Rate**: 70-90% depending on available events
- **Deduplication**: Automatic duplicate removal
- **Rate Limiting**: 5-second delay between cities
- **Scrolling**: 5 scroll iterations for lazy-loaded content

### 📈 Statistics & Reporting

The scraper provides comprehensive statistics:

- Total events found per city
- Success percentage
- Online vs in-person events
- Free vs paid events
- Events by month distribution
- Sample events preview

### 🛠️ Advanced Features

#### Enhanced Selectors

Uses 10+ different CSS selectors to find events:

- `article[data-testid="event-card-link"]`
- `div.discover-search-desktop-card`
- `div.eds-event-card`
- And 7+ more fallback selectors

#### Retry Logic

- Automatic retry up to 3 times if no events found
- 5-second delay between retries
- Different URL patterns on each retry

#### Anti-Detection

- User-agent rotation
- Cookie acceptance
- Proper scrolling behavior
- Request delays

### 💰 Cost Efficiency

- Optimized crawling with pagination
- Caches processed event IDs
- Batch processing for efficiency
- Minimal compute unit usage

### 📝 Version History

#### v1.3 (Current)

- Added pagination support (pages 1-3)
- Enhanced selectors for better detection
- Retry logic with fallbacks
- Proper thumbnail extraction
- Duplicate detection via event IDs
- Comprehensive statistics

#### v1.2

- Direct category page scraping
- Multiple URL patterns per city
- Basic thumbnail support

#### v1.1

- Web scraping implementation
- Replaced API approach

#### v1.0

- Initial release with API (deprecated)

### 🆘 Troubleshooting

#### No Events Found

- EventBrite may have no dating events in that city
- Try different cities or run later
- Check if EventBrite is blocking (rare with v1.3)

#### Partial Results

- Normal - not all cities have 40 dating events
- The scraper gets all available events up to the limit

#### Rate Limiting

- Built-in 5-second delays between cities
- Automatic retry with longer delays

### 📞 Support

For issues or feature requests:

- Apify Console: https://console.apify.com/organization/vK6fmobLbdfZEkiC4/actors/Sgb4KPT4gmTfh8569
- GitHub Issues: Create issue in repository
- Email: support@apify.com

***

**Built for Dating Platforms** 💝 - Your comprehensive source for EventBrite dating event data

**Version**: 1.3\
**Last Updated**: August 21, 2025\
**Actor ID**: Sgb4KPT4gmTfh8569

# Actor input Schema

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

List of cities to search for dating events. Defaults to 10 major US cities.

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

Number of dating events to fetch per city

## `ageGroups` (type: `array`):

Age groups to target for dating events

## `includeOnlineEvents` (type: `boolean`):

Whether to include virtual/online dating events

## `customKeywords` (type: `array`):

Additional keywords to search for (e.g., 'wine tasting singles', 'christian singles')

## `priceFilter` (type: `string`):

Filter events by price

## `dateRange` (type: `string`):

How far ahead to search for events

## Actor input object example

```json
{
  "cities": [
    "New York",
    "Los Angeles",
    "Chicago",
    "San Francisco",
    "Miami",
    "Austin",
    "Seattle",
    "Boston",
    "Denver",
    "Atlanta"
  ],
  "eventsPerCity": 40,
  "ageGroups": [
    "20s",
    "30s",
    "40s",
    "50+",
    "all ages"
  ],
  "includeOnlineEvents": true,
  "customKeywords": [],
  "priceFilter": "all",
  "dateRange": "next_6_months"
}
```

# 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("payai/eventbrite-dating-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("payai/eventbrite-dating-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 '{}' |
apify call payai/eventbrite-dating-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventbrite Dating Scraper",
        "description": "Scrape real dating & singles events from EventBrite's official API. Get 400+ dating events across 10 major US cities (user customizable) with age group targeting!",
        "version": "1.0",
        "x-build-id": "1c0GuzP6WhCpInbdm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/payai~eventbrite-dating-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-payai-eventbrite-dating-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~eventbrite-dating-scraper/runs": {
            "post": {
                "operationId": "runs-sync-payai-eventbrite-dating-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~eventbrite-dating-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-payai-eventbrite-dating-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": {
                    "cities": {
                        "title": "Cities to Search",
                        "type": "array",
                        "description": "List of cities to search for dating events. Defaults to 10 major US cities.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "New York",
                            "Los Angeles",
                            "Chicago",
                            "San Francisco",
                            "Miami",
                            "Austin",
                            "Seattle",
                            "Boston",
                            "Denver",
                            "Atlanta"
                        ]
                    },
                    "eventsPerCity": {
                        "title": "Events Per City",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Number of dating events to fetch per city",
                        "default": 40
                    },
                    "ageGroups": {
                        "title": "Age Groups",
                        "type": "array",
                        "description": "Age groups to target for dating events",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "20s",
                            "30s",
                            "40s",
                            "50+",
                            "all ages"
                        ]
                    },
                    "includeOnlineEvents": {
                        "title": "Include Online Events",
                        "type": "boolean",
                        "description": "Whether to include virtual/online dating events",
                        "default": true
                    },
                    "customKeywords": {
                        "title": "Custom Keywords",
                        "type": "array",
                        "description": "Additional keywords to search for (e.g., 'wine tasting singles', 'christian singles')",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "priceFilter": {
                        "title": "Price Filter",
                        "enum": [
                            "all",
                            "free",
                            "paid"
                        ],
                        "type": "string",
                        "description": "Filter events by price",
                        "default": "all"
                    },
                    "dateRange": {
                        "title": "Date Range",
                        "enum": [
                            "this_week",
                            "this_month",
                            "next_3_months",
                            "next_6_months"
                        ],
                        "type": "string",
                        "description": "How far ahead to search for events",
                        "default": "next_6_months"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
