# Event Finder - AI-powered tech conference discovery (`phazonoverload/event-finder`) Actor

Fetch tech conferences and open CFPs from developers.events, filter them using a plain-English query via AI, and get a clean ranked list. No scraping needed.

- **URL**: https://apify.com/phazonoverload/event-finder.md
- **Developed by:** [Kevin Lewis](https://apify.com/phazonoverload) (community)
- **Categories:** AI
- **Stats:** 7 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Event Finder — AI-powered tech conference discovery

Find tech conferences and open Calls for Proposals using plain English. Describe what you're looking for, and an AI model (via OpenRouter) filters and ranks the results from the community-maintained [developers.events](https://developers.events) dataset.

No web scraping required. The data source is a free public JSON API.

### Why use Event Finder?

- **Save time searching** — Describe what you want in natural language instead of filtering through spreadsheets
- **Discover CFPs** — Find open calls for proposals matching your talk topics
- **AI-ranked results** — AI scores each event's relevance so you see the best matches first
- **Pre-filter by date/country** — Reduce AI token usage and cost by narrowing the dataset before AI processes it

### How inputs work together

The Actor processes inputs in two stages:

#### Stage 1: Hard pre-filters (always runs, no AI needed)

These reduce the dataset before any AI call. They are exact, cheap, and happen first.

| Field | What it does |
|---|---|
| `type` | Picks which dataset to fetch: `events` or `cfps`. Events are conferences; CFPs are conferences actively seeking speaker submissions with a deadline |
| `dateFrom` / `dateTo` | Events: filters by event start date. CFPs: filters by submission deadline. Both dates inclusive. Default `dateFrom` is today so past items are excluded |
| `location` | A country name or a region. See below for how each is handled |

#### Stage 2: AI filter (only if `query` is provided)

The `query` field is a plain English description of what you want. The pre-filtered list plus your query are sent to OpenRouter, which scores every event 1-10 on relevance, keeps items scoring 5+, and ranks the rest.

`maxResults` caps the final output (top N by score). Defaults to 10.

```
Dataset ──> Stage 1: hard pre-filters ──> Stage 2: AI scores ──> Top N results
(events or CFPs)   (type, date, location)      (query + maxResults)
```

If `query` is empty, Stage 2 is skipped entirely. You get all matching events sorted by date up to `maxResults`.

#### Location

The `location` field handles three types of values:

**1. Specific country** — Does an exact country match in the pre-filter. Common aliases are resolved automatically:

| You type | Matches events in |
|---|---|
| `Germany` | Germany |
| `USA`, `US`, `United States`, `America` | USA |
| `UK`, `United Kingdom`, `GB`, `England` | UK |
| `UAE` | United Arab Emirates |
| `Czech Republic` | Czechia |
| `Korea`, `South Korea` | South Korea |
| `Holland` | Netherlands |

**2. Region** — Expands to a list of countries in the pre-filter. All matching countries are included before AI sees anything:

| Region | Countries included |
|---|---|
| `Europe` | Albania through UK + Wales (~40 countries) |
| `DACH` | Germany, Austria, Switzerland |
| `EMEA` | Europe + Middle East + Africa |
| `APAC` | East Asia + South Asia + Southeast Asia + Oceania |
| `Asia` | All Asian countries |
| `North America` | Canada, Mexico, USA |
| `South America` | All South American countries |
| `Middle East` | Bahrain through Yemen |
| `Africa` | All African countries |
| `Oceania` | Australia through Vanuatu |
| `Scandinavia` / `Nordics` | Denmark, Finland, Iceland, Norway, Sweden |

For the full list of supported regions and their country mappings, see `src/location.ts`.

**3. Blank** — No location filter. Events from all countries are included.

#### Combinations

| Scenario | What happens |
|---|---|
| `type: events` + `query: "AI conferences"` | AI sees all events regardless of date/location and picks relevant ones |
| `type: events` + `query: "AI conferences"` + `location: Germany` + `dateFrom: 2026-06-01` | Pre-filter: only German events starting June 2026. AI scores those. |
| `type: events` + `query: "AI conferences"` + `location: Europe` | Pre-filter: all European countries. AI scores against your query. |
| `type: events` + `query: ""` + `location: Japan` | Dump mode: all events in Japan sorted by start date (no AI cost) |
| `type: cfps` + `query: "Rust or Go topics"` + `location: DACH` | CFPs from Germany, Austria, Switzerland with Rust/Go relevance |
| `type: cfps` + `query: "cloud"` + `location: EMEA` | CFPs from Europe, Middle East, Africa |
| `type: cfps` + `dateFrom: 2026-06-01` + `dateTo: 2026-07-01` | CFPs with submission deadlines in June 2026 |
| `dateFrom: none` (blank) | Defaults to today. Past events/expired deadlines excluded automatically |

#### Input fields

| Field | Type | Required | Description |
|---|---|---|---|
| `query` | string | optional | Plain English description. Leave empty for dump mode (sorted by date, no AI cost) |
| `type` | select | optional | `events` or `cfps` (default: `events`) |
| `dateFrom` | date | optional | Events: earliest start date. CFPs: earliest submission deadline. Blank defaults to today |
| `dateTo` | date | optional | Events: latest start date. CFPs: latest submission deadline. Blank = no upper bound |
| `location` | string | optional | Country name (with alias resolution) or region (expanded to country list). Blank = all countries |
| `maxResults` | number | optional | Max results to return (default: 10, max: 100) |
| `openrouterApiKey` | secret | optional | Your OpenRouter API key (or set `OPENROUTER_API_KEY` env var) |

### How to use Event Finder

1. Open the Actor's **Input** tab in the Apify Console
2. Enter a plain English query or leave blank for dump mode
3. Optionally set date range, location, and type
4. Click **Run** and wait for results
5. Download the dataset as JSON, CSV, HTML, or Excel

### Output

Each result is a JSON record in the dataset:

```json
{
  "name": "React Summit",
  "type": "event",
  "date": { "start": "2026-06-12", "end": "2026-06-14" },
  "location": { "city": "Amsterdam", "country": "Netherlands" },
  "tags": ["react", "frontend", "javascript"],
  "url": "https://reactsummit.com/",
  "cfpDeadline": "2026-03-01",
  "cfpUrl": "https://sessionize.com/react-summit-2026",
  "relevanceScore": 8,
  "reason": "Frontend conference with React focus matches the query for JavaScript/React events."
}
```

You can download the dataset in JSON, HTML, CSV, or Excel format.

### Data fields

| Field | Description |
|---|---|
| `name` | Event name |
| `type` | `event` or `cfp` |
| `date` | Object with `start` and `end` ISO dates |
| `location` | Object with `city` and `country` |
| `tags` | Array of topic tags |
| `url` | Event website |
| `cfpDeadline` | CFP submission deadline (ISO date or null) |
| `cfpUrl` | CFP submission link (or null) |
| `relevanceScore` | AI relevance score (1-10) |
| `reason` | One-sentence explanation of why this matched |

### Cost estimation

Each run costs approximately $0.002–0.01 using a cheap model like `deepseek/deepseek-v4-flash` on OpenRouter. Model choice is the main cost driver — cheaper models (DeepSeek, Llama via OpenRouter) keep costs near zero. Hard pre-filters (date, country) reduce the AI payload so you pay for fewer tokens.

### Tips

- **Use pre-filters to cut cost** — `dateFrom`/`dateTo` and `location` run before AI and are the cheapest way to narrow results. A tight pre-filter means fewer items sent to OpenRouter.
- **Regions are pre-filtered too** — `Europe`, `DACH`, `EMEA`, etc. expand to country lists and filter before AI, so they reduce cost the same way a single country does.
- **No-query mode is free** — Leave `query` blank for dump mode. No AI call means zero API cost.
- **Set OPENROUTER\_API\_KEY as environment variable** — Store your API key in the Actor's environment variables instead of passing it with every run.
- **Cheap model by default** — Uses `deepseek/deepseek-v4-flash` on OpenRouter. Override with `OPENROUTER_MODEL` env var for a different model.
- **CFP hunting** — Set `type` to `cfps` and use `dateFrom`/`dateTo` to narrow by submission deadline. A tight window like the next 30 days shows what you should apply to now.
- **Date means different things** — For events, `dateFrom`/`dateTo` filters by event start date. For CFPs, it filters by submission deadline. The output `date` field always shows the event date; `cfpDeadline` shows when submissions close.

### FAQ, disclaimers, and support

**Q: Do I need an OpenRouter API key?** Yes, for AI filtering. Get one at [openrouter.ai/keys](https://openrouter.ai/keys). Without it, you can still use the no-query dump mode.

**Q: Is web scraping involved?** No. All data comes from the public JSON API at developers.events. No proxy or browser automation needed.

**Q: Where does the data come from?** The [developers.events](https://developers.events) community-maintained dataset. Events are added and updated by the community.

**Q: How accurate is the AI filtering?** The AI model evaluates each event against your query contextually. It handles misspellings, related terms, and implicit preferences well, but always verify results before making decisions.

For issues or feature requests, use the [Issues tab](https://github.com/kevinlewis/event-finder/issues). Need custom event sourcing or scheduled digests? Contact the author.

# Actor input Schema

## `query` (type: `string`):

Plain English description of what you're looking for. E.g. "AI/ML conferences in Europe in the next 3 months"

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

Whether to search events or open CFPs. Events filter by event start date. CFPs filter by submission deadline

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

Events: earliest event start date. CFPs: earliest CFP deadline. Defaults to today

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

Events: latest event start date. CFPs: latest CFP deadline

## `location` (type: `string`):

Country name (e.g. Germany, USA) for exact filtering, or a region (e.g. Europe, Asia, DACH, EMEA, Online) for AI-based filtering. Reduces token usage for large datasets

## `maxResults` (type: `integer`):

Maximum number of results to return. AI picks the most relevant ones up to this limit

## Actor input object example

```json
{
  "type": "events",
  "maxResults": 10
}
```

# 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("phazonoverload/event-finder").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("phazonoverload/event-finder").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 '{}' |
apify call phazonoverload/event-finder --silent --output-dataset

```

## MCP server setup

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

```

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/fLf4OGQfbgK6QP52z/builds/G3CChGUUlonDfyI8h/openapi.json