# Event Organizer Contacts: Luma & Eventbrite Host Emails (`datagleaner/event-organizer-contacts`) Actor

Event organizer and host contact finder for Luma and Eventbrite. Give events, organizer pages or a city; get one row per organizer with website, X, Instagram, LinkedIn and the public email on their own site. $0.01 per organizer with an email, $0.002 socials only, nothing found free.

- **URL**: https://apify.com/datagleaner/event-organizer-contacts.md
- **Developed by:** [Data Gleaner](https://apify.com/datagleaner) (community)
- **Categories:** Lead generation, Integrations, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Event Organizer Contacts: Luma & Eventbrite Host Emails

Find **event organizer emails and contacts** from Luma and Eventbrite. It answers "event organizer email", "event organizer contacts", "Luma event hosts" and "conference organizer contacts": give it events, organizer pages or a city, and get **one row per organizer or host** with their website, X, Instagram, LinkedIn, TikTok, YouTube and Facebook, the **public email on their own website**, and the events they run. **$0.01 per organizer with an email, $0.002 per organizer with socials only, and nothing found is free.** No login, no API key, no browser.

Built for people and AI agents alike: one row per organizer, deduplicated across all its events, the same fields every time, and the price tied to what was found.

### What it does

- **Luma city pages** (`sf`, `nyc`, `london`, `berlin`, `tokyo` and so on): every upcoming event in that city, and every organizer behind it: the community or company calendar (for example "Betaworks" or "Build with AI Club") and each individual host.
- **Luma calendars** (luma.com/your-community): the calendar and every host of its upcoming events.
- **Eventbrite cities**, optionally narrowed by a keyword (`tech`, `startup`, `wine tasting`): the organizers of the events found there, with their Eventbrite follower and event counts.
- **Event links** from either platform: that event's organizers and hosts.
- **Organizer links** (Eventbrite `/o/` profiles, Luma calendars, Luma user profiles): just those organizers.

For each organizer it reads the profile's own social handles, website and bio, then (by default) visits **up to 2 pages of the organizer's own website**, the home page and its contact page if needed, to find the public email and phone. Emails are kept only when they belong to that site (its own domain, a brand-named domain, or the organizer's webmail); platform, payment and builder addresses are dropped.

### Use cases

- **Sponsorship and partnership sales**: venues, sponsors, caterers, SaaS and event tech selling to the people who run events in a city.
- **Speaker and community outreach**: reach the organizers of AI, startup or developer meetups in your city.
- **Lead lists by city and topic**: "tech event organizers in New York with an email", in one run.
- **Enrichment for AI agents**: turn a list of Luma or Eventbrite links into contact rows, paying only for organizers where something was found.

### Input

| Field | Meaning |
|---|---|
| `lumaPlaces` | Luma city slugs (`sf`, `nyc`, `london`) or links, and Luma calendar links. |
| `eventbriteCities` | Eventbrite locations: `ny--new-york`, `Austin, TX`, `london`, `online`, or a full `/d/` search link. |
| `eventbriteKeyword` | Optional topic for the Eventbrite search, e.g. `tech`. Alone, it searches online events. |
| `eventUrls` | Luma (`luma.com/abc123`, `lu.ma/abc123`) or Eventbrite (`/e/...`) event links. |
| `organizerUrls` | Eventbrite organizer profiles (`/o/name-123456`), Luma calendars, Luma user profiles (`luma.com/user/name`). |
| `maxOrganizers` | Unique organizers to look up across all inputs (default 100). Cities share it evenly. |
| `followWebsites` | Visit up to 2 pages of each organizer's website for an email and phone (default true). |
| `onlyWithEmail` | Output only organizers with a public email (default false). |
| `maxConcurrency`, `delaySecs`, `proxyConfiguration` | Pacing and network. No proxy by default. |

Leave everything empty to run a small example: 5 organizers from Luma San Francisco, in about 10 seconds.

```json
{
  "lumaPlaces": ["nyc"],
  "eventbriteCities": ["ny--new-york"],
  "eventbriteKeyword": "tech",
  "maxOrganizers": 100,
  "onlyWithEmail": false
}
```

### Output

One row per organizer. A field that was not found is empty, never guessed.

```json
{
  "platform": "eventbrite",
  "organizerType": "organizer",
  "organizerId": "76632044443",
  "organizerName": "AI Founders Connect",
  "organizerUrl": "https://www.eventbrite.com/o/ai-founders-connect-76632044443",
  "website": "https://aifoundersconnect.org/",
  "email": "stacy@aifoundersconnect.org",
  "emails": [{"email": "stacy@aifoundersconnect.org", "source": "website", "foundOn": "https://aifoundersconnect.org/"}],
  "phones": ["+16469177791"],
  "socials": {"x": null, "instagram": null, "linkedin": "https://www.linkedin.com/in/ai-lawyer", "tiktok": null, "youtube": null, "facebook": null},
  "linkedinUrl": "https://www.linkedin.com/in/ai-lawyer",
  "bio": "AI Founders Connect is a NYC non-profit running small AI investor events. ...",
  "followerCount": 437,
  "eventCount": 20,
  "eventsSeenCount": 1,
  "eventsSeen": [{"title": "AI Founders Connect Hosted by Cornell Tech - Round 21", "url": "https://www.eventbrite.com/e/...-2002710412756", "startAt": "2026-10-29T17:00:00-04:00"}],
  "city": "New York",
  "hasEmail": true,
  "hasSocials": true,
  "pagesFollowed": 1,
  "input": "ny--new-york / tech",
  "scrapedAt": "2026-10-09T14:41:17+00:00"
}
```

- `organizerType` is `host` (a Luma person), `calendar` (a Luma community or company page) or `organizer` (an Eventbrite organizer).
- `emails[].source` is `profile` (written in the organizer's bio), `website`, `contact-page` or `link-in-bio`, and `foundOn` is the exact page.
- `xUrl`, `instagramUrl`, `linkedinUrl`, `tiktokUrl`, `youtubeUrl` and `facebookUrl` repeat `socials` as flat columns for CSV and Excel.
- `eventsSeen` lists up to 20 of the organizer's events from this run, with start times in the event's local time zone.
- `followerCount` and `eventCount` come from Eventbrite's organizer page. On Luma, `eventCount` is filled for user profiles and calendars given as organizer links.

The dataset has three views: organizer contacts, all emails (one row per email), and events seen (one row per event).

### Pricing

Pay per organizer, by what was found:

- **`organizer-with-email`: $0.01** for one organizer with a public email, plus its socials.
- **`organizer-with-socials`: $0.002** for one organizer with social profiles or a website but no email.
- An organizer with **nothing found is free**, and so is any row left out by `onlyWithEmail`.

**Worked example.** A run returns 300 organizers: 120 with an email, 150 with socials only, 30 with nothing. You pay 120 x $0.01 + 150 x $0.002 = **$1.50**. The 30 empty rows cost nothing.

For comparison, the best-known Eventbrite scraper charges $0.015 per organizer enrichment on top of its per-event price. Here an organizer with an email costs $0.01, with no per-event charge.

Set a maximum total charge on the run and the Actor stops cleanly when it is reached.

### What to expect

On a test run of 70 New York organizers (Luma `nyc` plus Eventbrite `tech`), 19% had a public email, 51% had socials or a website only, and 30% had nothing public. Luma hosts very often list X, Instagram and LinkedIn but rarely a website; Eventbrite organizers more often have a website, and so an email. Luma calendars (communities and companies) are the most likely Luma rows to have an email.

### Limits

- Only public data: what the organizer put on their Luma or Eventbrite profile and their own website. Luma and Eventbrite never show an organizer's account email, and this Actor does not try to get it.
- At most 2 website pages per organizer. Sites that render entirely with JavaScript, or block bots in robots.txt, may show no email.
- Luma city pages list upcoming events only; a city's page holds a few hundred at most. Eventbrite searches read up to 15 result pages per city.
- A Luma host's socials come from their own profile. Socials on a host's website (often their employer's) are not mixed in; for calendars and Eventbrite organizers, website socials fill gaps.
- The same person can appear twice when they run a Luma calendar and also host as themselves: these are different accounts with different IDs.

### Run it after an Eventbrite scraper

Open the source Actor's **Integrations** tab, add this Actor (`datagleaner/event-organizer-contacts`) and set its input to:

```json
{"datasetId": "{{resource.defaultDatasetId}}"}
```

Every time the source run succeeds, this Actor reads the organizers from its results. Per item it takes the organizer link (`primary_organizer.url`, `organizerUrl`, `organizer.url`) or the organizer id (`primary_organizer_id`, `organizer_id`, `organizerId`), and when there is neither, the Eventbrite event link (`url`, `eventUrl`); `datasetField` names another field and is tried first. Organizers are deduped by id, items without an Eventbrite organizer or event link are skipped, and at most `maxDatasetItems` (default 1000) are read. The run log and status line say how many items were read and how many were skipped. Dataset organizers combine with every other input, and `maxOrganizers` still caps the output. Billing is the same: $0.01 per organizer with an email, $0.002 socials only, nothing found free. Compatible with the output of the Eventbrite scrapers on the Store that return an organizer or event link per row (for example `aitorsm/eventbrite`, `shahidirfan/Eventbrite-Scraper`) and with the `datagleaner/eventbrite` Actor.

The same works from code, for one finished run:

````python
run = client.actor("datagleaner/event-organizer-contacts").call(run_input={"datasetId": "SOURCE_DATASET_ID"})
``` It also works as an integration: open the source Actor's Integrations tab, choose Add integration and pick this Actor, and the dataset is passed automatically.

### Use it from n8n, Make, Zapier or an AI agent

Actor ID: `datagleaner/event-organizer-contacts`

Minimal input:

    {"lumaPlaces": ["sf"], "maxOrganizers": 20, "onlyWithEmail": true}

Each tool below runs this Actor with your own Apify API token.

- **n8n:** add the **Apify** node (`@apify/n8n-nodes-apify`). On n8n Cloud you install it from the community node registry. Choose **Run an Actor and get dataset**, set Actor to `datagleaner/event-organizer-contacts` and paste the input above.
- **Make:** use the Apify app's **Run an Actor** module, then **Get Dataset Items** to read the results. **Watch Actor Runs** can trigger a scenario when a run finishes.
- **Zapier:** use the Apify action **Run Actor**, then the search **Fetch dataset items**. The trigger **Finished Actor run** starts a Zap when a run ends.
- **AI agents (MCP):** connect to `https://mcp.apify.com/?tools=datagleaner/event-organizer-contacts`. Without a token, an agent can still find Actors with the `search-actors` tool, but running this one needs your Apify account. In Claude Code:

        claude mcp add --transport http apify "https://mcp.apify.com/?tools=datagleaner/event-organizer-contacts"

    Then run `/mcp` to sign in to Apify in your browser. Then ask in plain language, for example: "Find 50 tech event organizers in New York with a public email, and tell me who hosts these Luma events and how to contact them."
- **LangChain (Python):**

```python
## pip install langchain-apify, then set APIFY_TOKEN in your environment
import json
from langchain_apify import ApifyActorsTool
tool = ApifyActorsTool("datagleaner/event-organizer-contacts")
result = tool.invoke({"run_input": json.loads('{"lumaPlaces": ["sf"], "maxOrganizers": 20, "onlyWithEmail": true}')})
````

### FAQ

**Do I need a Luma or Eventbrite account or API key?** No.

**Which emails are kept?** Addresses on the organizer's own domain, on a domain named after the organizer, or a webmail address on their site. A page listing many webmail addresses (speakers, members) is ignored. Support and no-reply mailboxes are listed last.

**How are duplicates handled?** One row per organizer ID (Luma `usr-`/`cal-` IDs, Eventbrite organizer numbers), with all its events in `eventsSeen`.

**Can I run just one platform?** Yes. Fill only the Luma fields or only the Eventbrite fields.

**Does it get attendees or guest lists?** No. Only organizers and hosts.

### Related Actors

- [Website Contact Details Scraper](https://apify.com/datagleaner/website-contact-details-scraper): emails, phones and social profiles from organizer websites that had no email in your results.
- [Team Page Contacts](https://apify.com/datagleaner/team-page-contacts): named people, titles and LinkedIn profiles from the team page of a company that runs events.
- [Link in Bio Email Finder](https://apify.com/datagleaner/bio-link-email-finder): emails and links from Linktree, Taplink and AllMyLinks pages, for hosts who list one instead of a website.
- [YouTube Channel Email & Influencer Contacts Finder](https://apify.com/datagleaner/youtube-channel-contacts): public emails and social profiles of YouTube channels, for organizers who also run a channel.

### Responsible use

This Actor reads public pages only. Names, emails, phone numbers and social profiles can be personal data. You are responsible for using them lawfully, including consent and opt-out rules for outreach (GDPR, CAN-SPAM and local law), and for respecting the terms of the platforms you use the data on. Luma users who asked Luma to hide their profile from search are skipped when given as a profile link.

# Actor input Schema

## `lumaPlaces` (type: `array`):

Luma city pages such as `sf`, `nyc`, `london`, `berlin` or `tokyo` (or full links like https://luma.com/sf), and Luma calendar pages (community pages such as https://luma.com/oss4ai). Every organizer of the upcoming events listed there is returned: the calendar itself and each host.

## `eventbriteCities` (type: `array`):

Eventbrite locations: a slug such as `ny--new-york` or `united-kingdom--london`, a name such as `Austin, TX` or `london`, `online`, or a full Eventbrite search link (https://www.eventbrite.com/d/...). The organizers of the events found there are returned.

## `eventbriteKeyword` (type: `string`):

Optional. Narrows the Eventbrite city search to a topic, for example `tech`, `startup` or `wine tasting`. Given without a city, it searches online events.

## `eventUrls` (type: `array`):

Luma event links (https://luma.com/abc123 or lu.ma/abc123) or Eventbrite event links (https://www.eventbrite.com/e/...). Returns each event's organizers and hosts.

## `organizerUrls` (type: `array`):

Organizer pages to look up directly: Eventbrite organizer profiles (https://www.eventbrite.com/o/name-123456), Luma calendars (https://luma.com/oss4ai) or Luma user profiles (https://luma.com/user/name).

## `datasetId` (type: `string`):

Optional. Read Eventbrite organizers from this dataset, for example the results of an Eventbrite scraper, and add them to the inputs above. Each item's organizer link or id (`primary_organizer.url`, `organizerUrl`, `organizer_id`, `primary_organizer_id`) is used, else its event link (`url`, `eventUrl`); items with neither are skipped. In an integration use `{{resource.defaultDatasetId}}`.

## `datasetField` (type: `string`):

Optional. Name of the field that holds the Eventbrite organizer or event link when it is not one of the usual ones. Tried first.

## `maxDatasetItems` (type: `integer`):

Stop reading the dataset after this many unique organizers and events. The Max organizers limit below still applies to the output.

## `maxOrganizers` (type: `integer`):

Stop collecting after this many unique organizers across all inputs. Each organizer is one row, however many of its events were seen.

## `followWebsites` (type: `boolean`):

Visit up to 2 pages of each organizer's own website (the home page, then its contact page if needed) and collect the public email, phone and missing socials. Off: only the platform profile is used, which is faster but rarely has an email.

## `onlyWithEmail` (type: `boolean`):

Output only organizers where a public email was found. Organizers left out are not charged.

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

How many organizers are looked up at the same time.

## `delaySecs` (type: `integer`):

A random pause of up to this many seconds before each Luma or Eventbrite request and each website visit. Raise it on very large runs.

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

Optional. Defaults to no proxy. Use one only if Luma or Eventbrite start answering with errors on large runs.

## Actor input object example

```json
{
  "lumaPlaces": [
    "sf"
  ],
  "maxDatasetItems": 1000,
  "maxOrganizers": 20,
  "followWebsites": true,
  "onlyWithEmail": false,
  "maxConcurrency": 5,
  "delaySecs": 1
}
```

# 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 = {
    "lumaPlaces": [
        "sf"
    ],
    "maxOrganizers": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("datagleaner/event-organizer-contacts").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 = {
    "lumaPlaces": ["sf"],
    "maxOrganizers": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("datagleaner/event-organizer-contacts").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 '{
  "lumaPlaces": [
    "sf"
  ],
  "maxOrganizers": 20
}' |
apify call datagleaner/event-organizer-contacts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datagleaner/event-organizer-contacts"
        }
    }
}
```

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/B6t67bOBiJcOKg8P1/builds/o1wSfC2GY0YVSfNGA/openapi.json