# City Events Organizer Leads: Official Open Data (`transparent_meteorite/city-events-organizer-leads`) Actor

Event organizer and venue leads with emails, phones and websites from official open city event feeds (Paris, Nantes, Helsinki, New York). Filter by date, keyword, category and contact. Beta.

- **URL**: https://apify.com/transparent_meteorite/city-events-organizer-leads.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.59 / 1,000 event or organizer lead returneds

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

## City Events Organizer Leads: Official Open Data, Emails + Phones

Use this to find event organizers and venues with published email, phone and website, straight from official open city event feeds (Paris, Nantes, Helsinki and New York), with no login, no proxy and no ticket-site scraping.

**Beta.** Every row comes from a government or city open data feed, with the licence and dataset link on the row. Contact fields are only filled when the publisher released them, never guessed. Open an issue on the Issues tab if a field looks wrong and we fix it fast.

### Run in 30 seconds

1. Click **Try for free** and leave the prefilled input as it is (Paris, Nantes and Helsinki, next 30 days, only rows with a contact, 60 results).
2. Press **Start**. A typical run finishes in under a minute.
3. Open the **Leads** table: organizer, email, phone, website, event, date, city, category.
4. Download as CSV, Excel or JSON, or call the API. Switch **Output mode** to *One row per unique organizer* to get a clean prospect list with event counts.

### What it does

It reads the official open event agendas that cities publish for their citizens and turns them into outreach-ready lead rows.

- **Four official feeds in one schema:** the City of Paris "Que faire a Paris" agenda, the Nantes Metropole agenda, the City of Helsinki LinkedEvents API, and the New York City permitted events register.
- **Organizer, venue and contact in each row:** organizer name, organizer email, phone and website where the publisher released them, plus venue name, street address, postal code, city and coordinates.
- **Two output modes:** one row per event, or one row per unique organizer with the number of upcoming events, next and last event date, the categories they run and three sample events.
- **Filters that matter for outreach:** date window, keywords, categories, city or district text, "only rows with a contact" and "only rows with an email".
- **Clean, typed output:** every field is nullable and consistently named across all four cities, so one spreadsheet or CRM import works for all of them.
- **Always free of login and proxies:** official open data endpoints, polite request pacing, retries with backoff, and an exit code of 0 even when one source is down (you keep the rows from the others).

### Why it is better than the alternatives

We checked the public Apify Store listings of event scrapers on 2026-10-29 and compared them with a live run of this actor.

| Measure | Typical Store event scrapers | This actor |
|---|---|---|
| Price per event row on the free plan | $0.00349 to $0.02 | $0.00325 |
| Start fee | $0.00005 to $0.05 per run | $0.00005 per run |
| Needs a residential proxy or anti-bot handling | yes, for ticket sites | no, official open APIs |
| Terms-of-service risk for you | scraping of platforms whose terms forbid it | none, open licences with attribution on every row |
| Rows with a usable contact (email, phone or website) | not published | 90% Paris, 92% Nantes, 99% Helsinki (measured on 500+ rows each, 2026-10-29) |
| Rows with an organizer email | not published | 53% Paris, 37% Nantes, 95% Helsinki |
| Unique organizer lead mode | usually extra paid enrichment | included, same price per lead |
| Speed | minutes with browser rendering | Paris and Nantes about 3 seconds per 500 rows, Helsinki about 30 seconds per 600 rows |
| Dataset schema | many untyped or null-breaking fields | fully typed, nullable, same fields for every city |

The honest limit: this is not a worldwide ticket-site crawler. It covers cities that publish good open event data, and we add more feeds over time. If you need every event on one commercial ticket platform, this is the wrong tool. If you need organizer and venue leads in the covered cities with real contact data and zero terms-of-service risk, it is the cheapest and cleanest option we know of.

### Things to know

- **New York rows name the permitting city agency** (for example Parks Department) as organizer, because the register does not publish private organizer or contact data. Use New York for venue, borough and event-type signals, not for outreach emails.
- **Dates:** Paris and Nantes agendas list occurrences. Nantes is de-duplicated to the first occurrence in your window per event.
- **Languages:** names and categories come in the publisher's language (French, Finnish with English where the publisher provides it). Use local-language keywords, for example concert, exposition, spectacle, tapahtuma.
- **Contact data is as published.** Some publishers leave fields blank. A blank is returned as null, never invented.
- **Private persons:** the feeds are organisation-level. If a field happens to contain an individual's details, treat it under your local data protection rules, for example GDPR legitimate-interest B2B outreach with an opt-out.

### Use cases

- **Event suppliers:** sound, lighting, staging, catering, security, merchandise and ticketing companies building a prospect list of organizers with upcoming events and a direct contact.
- **Sponsorship and brand teams:** find festivals, concerts and community events by category and city before the season is booked.
- **Agencies and promoters:** list venues and organizers in a new city with event frequency (event count) as a size signal.
- **Marketplaces and apps:** seed a local events or venue directory with licensed, attributable data.
- **Researchers and journalists:** compare cultural programming across cities with one schema.
- **Sales ops:** schedule a weekly run, then send only new organizers to your CRM.

### Example input

```json
{
  "sources": ["paris", "nantes", "helsinki"],
  "mode": "organizers",
  "keywords": ["concert", "festival", "exposition"],
  "dateFrom": "2026-11-01",
  "daysAhead": 60,
  "mustHaveContact": true,
  "maxItems": 200
}
```

Leave **City feeds** empty to read all four. Use **City or area contains** to narrow to a district, for example Brooklyn or Espoo. Use **Categories** to keep only matching types, for example Theatre or Sport.

### Output fields

| Field | Meaning |
|---|---|
| recordType | event or organizer |
| organizerName, organizerType | name and role (organiser, venue, publisher or permitting city agency) |
| organizerEmail, organizerPhone, organizerUrl | published contact details, null when absent |
| eventName, startDate, endDate, eventUrl | the event (event mode) |
| venueName, address, postalCode, city, region, country | where it happens |
| category, tags, categories | event type labels from the feed |
| isFree, latitude, longitude | free-entry flag and coordinates when published |
| eventCount, nextEventDate, lastEventDate, sampleEvents | organizer mode: size and activity of the organizer |
| source, sourceDataset, sourceLicense, sourceId | provenance, licence text and the official dataset link |
| scrapedAt | UTC timestamp of the run |

### Pricing

Pay per result: **$0.00325 per lead row on the free plan, falling to $0.00259 on the Gold plan** (Bronze $0.00306, Silver $0.00278), plus a $0.00005 start fee per run. A lead row is an event row or a unique organizer row, depending on the mode; organizer leads cost the same as event rows, with no separate enrichment charge. Rows removed by your filters and duplicates are never charged. Set **Maximum cost per run** in the run options to cap spend; the actor stops cleanly at the limit and keeps everything delivered.

**How this beats the other event scrapers (live Store prices read through the Apify API, 2026-10-29, free-plan rate):** aitorsm/eventbrite $0.02 per event plus $0.015 for organizer enrichment, newpo/eventbrite-scraper $0.015, parseforge/eventbrite-scraper $0.0045 (plus $0.003 for organizer data), zen-studio/10times-events-scraper $0.00349. We are cheaper than all of them at every plan level, and unlike them we publish the measured share of rows with a usable contact.

### Licence and privacy

All data comes from official open data portals and is reused under each portal's licence: ODbL for the Paris dataset, Licence Ouverte (Etalab) for Nantes Metropole, CC BY 4.0 for the City of Helsinki LinkedEvents API, and the NYC Open Data terms of use. The licence text and dataset URL are on every row so attribution is one column away. The actor reads only public endpoints, needs no account and stores nothing between runs.

### Output sample

```json
{
  "recordType": "event",
  "source": "paris",
  "sourceLicense": "ODbL 1.0 (c) Ville de Paris",
  "sourceDataset": "https://opendata.paris.fr/explore/dataset/que-faire-a-paris-/",
  "country": "FR",
  "eventName": "Aja en concert",
  "organizerName": "Mediatheque Helene Berr",
  "organizerType": "organiser",
  "organizerEmail": null,
  "organizerPhone": null,
  "organizerUrl": "https://ajasphere.bandcamp.com/",
  "venueName": "Mediatheque Helene Berr",
  "address": "70 rue de Picpus",
  "postalCode": "75012",
  "city": "Paris",
  "category": "Concert",
  "startDate": "2026-11-27",
  "endDate": "2026-11-27",
  "isFree": true
}
```

### FAQ

**Is this legal?** Yes for the data source: these are official open datasets published for reuse, with licences recorded per row. Your outreach must still follow local rules (GDPR in the EU, CAN-SPAM in the US). Business organizers are normally fine for B2B contact with an opt-out.

**Why not a big ticketing platform?** Those sites forbid automated collection in their terms, need proxies and break often. This actor deliberately uses only official open data, so it keeps working and keeps you out of terms-of-service trouble.

**Why only these cities?** They are the ones whose open feeds we verified return real rows with organizer or venue names and an open licence. Each new feed is added only after the same test. Open an issue to request a city.

**How fresh is the data?** Paris, Nantes and Helsinki update daily or continuously. New York updates as permits are issued. Each run reads the live feeds.

**How many rows can I get?** Up to 20,000 per run. Paris exposes about 3,000 upcoming events, Nantes about 3,000 occurrences in 90 days, Helsinki more than 10,000 events, New York about 19,000 permits in 90 days.

**Can I monitor for new organizers?** Schedule the actor weekly in organizer mode and compare against your CRM, or use Apify's dataset deduplication. Each row has a stable sourceId.

**What if one source is down?** The run still ends with exit code 0 and a status message, keeps the rows from the other sources and charges only for rows delivered.

**What does a run cost?** The default prefill of 60 leads costs about $0.15 in event charges. A 1,000 lead organizer list costs about $2.50.

**Do you use AI or guess emails?** No. Every contact value is copied from the official record. Nothing is inferred or generated.

**Can I get the data as a spreadsheet, API or webhook?** Yes: CSV, Excel, JSON, the Apify API, webhooks, Zapier, Make and n8n all work with the dataset.

### How it works

1. **Read input.** The actor validates your dates, keywords and sources. Anything invalid ends the run with a clear message instead of a crash.
2. **Query each official feed with its own filters.** Date, keyword and city filters are pushed to the portal's own query language, so only matching records travel over the network. Paris and Nantes use the Opendatasoft Explore API, Helsinki uses the LinkedEvents REST API with the venue record expanded, and New York uses the Socrata SODA API.
3. **Normalise.** Names, addresses, categories and contact fields are mapped to one schema. HTML is stripped, emails are extracted and lower-cased, websites are made absolute and obviously empty values become null.
4. **Filter and de-duplicate.** Your contact and category filters apply after normalisation, and each source record is delivered once per run.
5. **Deliver and charge.** Each row is written to the dataset and charged one result event. If your maximum cost per run is reached, the actor stops cleanly and tells you in the run status.

### Tips for a better lead list

- Start with **organizer mode** and **Only leads with a contact** switched on. You get one line per organizer, sorted so the organizers with the most contact details and the most upcoming events come first.
- Use a longer window (Days ahead 120 to 365) in organizer mode. Organizers who run many events in a season are the best prospects, and the event count column shows who they are.
- Combine **Categories** with local words: Concert, Exposition, Theatre, Danse and Festival in France; Konsertti, Tapahtuma and Naytelma in Finland.
- Use **Only leads with an email** for cold email lists, and the phone and website columns for calling or LinkedIn research.
- Keep **sourceLicense** and **sourceDataset** when you republish data, so you meet the attribution terms of each licence.
- For a weekly new-organizer feed, schedule the actor and send the dataset to a spreadsheet, CRM or webhook with an Apify integration, then keep only organizers you have not contacted yet.

### Integrations and API

Every run produces a standard Apify dataset. Pull it as JSON, CSV, Excel, XML or RSS, trigger the actor from the Apify API or client libraries for JavaScript and Python, and connect it to Zapier, Make, n8n, Google Sheets or any webhook. The same input fields are used everywhere, so a task you tune in the console runs unchanged from code or on a schedule.

### Alternatives to City Events Organizer Leads

Other ways to get similar data, so you can choose what fits:

- **Ticket-platform scrapers on the Apify Store:** broad coverage of commercial events, but they need proxies, carry terms-of-service risk and rarely return organizer emails.
- **Direct city open data portals:** free, but four different schemas, query languages and paging rules to learn and maintain.
- **Business directories and map scrapers:** good for venues, weak for event-specific organizers and dates.
- **Manual research:** accurate but slow, roughly minutes per lead instead of seconds for hundreds.

This actor's edge is one clean schema over official feeds, contact data measured in the dataset, pay-per-result pricing 7% under the cheapest listed rival and an organizer mode that turns events into a deduplicated prospect list. Compare on a small test run before you commit.

### Changelog

- **0.2** (2026-10-29): first release. Paris, Nantes, Helsinki and New York feeds, events and organizers modes, contact filters.

New to Apify? [Create a free account](https://console.apify.com/sign-up?fpr=rnmakg) and run this Actor in under a minute. Some links are affiliate links.

# Actor input Schema

## `sources` (type: `array`):

Which official open event feeds to read. Leave empty for all four. NYC rows name the permitting city agency, not a private organizer, and carry no contact details.

## `mode` (type: `string`):

Events returns every matching event. Organizers groups events into one lead per organizer, with event count, next date, categories and sample events.

## `keywords` (type: `array`):

Match event title, tags and venue, e.g. concert, festival, conference, exhibition. Any keyword matches. Use the local language for local feeds, e.g. concert, exposition, spectacle.

## `categories` (type: `array`):

Keep only events whose category or tags contain one of these words, e.g. Concert, Theatre, Sport. Case-insensitive.

## `city` (type: `string`):

Optional. Keep events whose city, borough or district contains this text, e.g. Espoo, Brooklyn, Nantes.

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

Earliest event date. Defaults to today.

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

Latest event date. Defaults to Days ahead from Date from.

## `daysAhead` (type: `integer`):

Window length when Date to is empty.

## `mustHaveContact` (type: `boolean`):

Keep only rows with at least one of email, phone or website.

## `mustHaveEmail` (type: `boolean`):

Keep only rows with a published organizer email.

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

Total rows to deliver, split evenly across the chosen feeds. You pay per row delivered.

## Actor input object example

```json
{
  "sources": [
    "paris",
    "nantes",
    "helsinki"
  ],
  "mode": "events",
  "daysAhead": 30,
  "mustHaveContact": true,
  "mustHaveEmail": false,
  "maxItems": 60
}
```

# Actor output Schema

## `overview` (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 = {
    "sources": [
        "paris",
        "nantes",
        "helsinki"
    ],
    "mode": "events",
    "daysAhead": 30,
    "mustHaveContact": true,
    "maxItems": 60
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/city-events-organizer-leads").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 = {
    "sources": [
        "paris",
        "nantes",
        "helsinki",
    ],
    "mode": "events",
    "daysAhead": 30,
    "mustHaveContact": True,
    "maxItems": 60,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/city-events-organizer-leads").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 '{
  "sources": [
    "paris",
    "nantes",
    "helsinki"
  ],
  "mode": "events",
  "daysAhead": 30,
  "mustHaveContact": true,
  "maxItems": 60
}' |
apify call transparent_meteorite/city-events-organizer-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/city-events-organizer-leads"
        }
    }
}
```

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/8t6iIkjX6Axy34UIW/builds/yC7xgPhba6BvnuSx4/openapi.json