# 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:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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/platform/actors/running/actors-in-store#pay-per-usage

## 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

## 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("💾 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 phazonoverload/event-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Event Finder - AI-powered tech conference discovery",
        "description": "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.",
        "version": "0.0",
        "x-build-id": "G3CChGUUlonDfyI8h"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/phazonoverload~event-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-phazonoverload-event-finder",
                "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/phazonoverload~event-finder/runs": {
            "post": {
                "operationId": "runs-sync-phazonoverload-event-finder",
                "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/phazonoverload~event-finder/run-sync": {
            "post": {
                "operationId": "run-sync-phazonoverload-event-finder",
                "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": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Plain English description of what you're looking for. E.g. \"AI/ML conferences in Europe in the next 3 months\""
                    },
                    "type": {
                        "title": "Search Type",
                        "enum": [
                            "events",
                            "cfps"
                        ],
                        "type": "string",
                        "description": "Whether to search events or open CFPs. Events filter by event start date. CFPs filter by submission deadline",
                        "default": "events"
                    },
                    "dateFrom": {
                        "title": "Date From",
                        "type": "string",
                        "description": "Events: earliest event start date. CFPs: earliest CFP deadline. Defaults to today"
                    },
                    "dateTo": {
                        "title": "Date To",
                        "type": "string",
                        "description": "Events: latest event start date. CFPs: latest CFP deadline"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "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": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of results to return. AI picks the most relevant ones up to this limit",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
