# Event Sponsorship Opportunity Finder (`trovevault/event-sponsorship-finder`) Actor

Find local tech and startup events and rank sponsorship opportunities by audience fit, sponsorability, timing, evidence, and recommended next action.

- **URL**: https://apify.com/trovevault/event-sponsorship-finder.md
- **Developed by:** [Trove Vault](https://apify.com/trovevault) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.55 / 1,000 events

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/platform/actors/running/actors-in-store#pay-per-event

## 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 Sponsorship Opportunity Finder

Find local tech and startup events, then rank them as sponsorship opportunities with component scores, evidence gaps, and a recommended next action.

The Actor is designed for B2B field marketing, partnerships, developer relations, recruiting, and community teams. It answers: **which local events deserve outreach?**

This is an opportunity finder, not a generic scraper. It scans public event listings itself, normalizes and deduplicates the events, then applies transparent sponsorship scoring inside the same Actor. Missing information becomes an evidence gap instead of a guess.

### Why use this Actor?

- Search one or more cities without maintaining several event-source integrations.
- Rank local events against your company, audience, and preferred themes.
- Separate audience fit, sponsorability, and outreach timing.
- See why an event scored well and what still needs confirmation.
- Open the canonical event page to validate details and contact the organizer.
- Append results to an existing Apify dataset and schedule weekly searches.

The Actor may return a public listing image URL for review, but it does not download or republish image files, attendee profiles, or private contact data.

### Use cases

- **Field marketing:** shortlist meetups and community events where buyers may gather.
- **Partnerships:** find communities for co-marketing, demos, or ecosystem relationships.
- **Developer relations:** identify events suited to talks, workshops, or technical sponsorships.
- **Recruiting and agencies:** choose relevant communities or run client-specific searches without collecting attendee identities.

### How scoring works

| Score | What it measures |
|---|---|
| `audienceFitScore` | Match between the expected event audience, sponsor profile, and themes. |
| `sponsorshipPotentialScore` | Public signals such as organizer, venue, format, audience-size signal, and event type. |
| `timingScore` | Whether enough lead time remains for outreach and activation planning. |
| `opportunityScore` | Weighted total: 50% audience fit, 35% sponsorability, and 15% timing. |

The deterministic scoring model prioritizes research; it does not call an external AI model and does not predict sponsorship ROI. Audience size is returned only when a public listing contains a usable signal and is labeled `heuristic_estimate`, because public RSVPs are not verified attendance.

`recommendedAction` is one of `contact_organizer`, `fast_track_outreach`, `research_sponsorship`, `attend_or_validate`, or `skip_for_now`.

### How do I run it?

1. Enter one to three cities where your team can act.
2. Describe the company, product, ideal audience, and sponsorship goal.
3. Add themes such as `AI agents`, `developer tools`, or `B2B SaaS`.
4. Choose a date range, or leave it blank for the next 60 days.
5. Start with five results, review the scoring, then increase the limit.
6. Open each event page and confirm sponsorship availability before committing budget.

```json
{
  "cities": ["Lisbon"],
  "dateFrom": "2026-08-14",
  "dateTo": "2026-10-13",
  "sponsorProfile": "A B2B developer-tools company seeking AI founders, technical leaders, and senior engineers for product demos and partnerships.",
  "themes": ["AI", "startup founders", "developer tools"],
  "maxResults": 10,
  "runId": "lisbon-weekly-2026-08-14"
}
```

### What input is accepted?

| Field | Required | Description |
|---|---:|---|
| `cities` | Yes | City names to search. One to three is recommended; up to ten are accepted. |
| `sponsorProfile` | Yes | Company, offer, audience, and sponsorship objective used for fit scoring. |
| `themes` | Yes | Topics that should appear in the event or expected audience. |
| `dateFrom` | No | Earliest event date in `YYYY-MM-DD`; defaults to today. |
| `dateTo` | No | Latest event date; defaults to 60 days after the start. |
| `maxResults` | No | Maximum ranked rows to save, from 1 to 100. |
| `datasetId` | No | Existing Apify dataset that should also receive every result. |
| `runId` | No | Workflow identifier copied to every output row. |

Source selection, request limits, retries, and temporary state remain internal.

### What data is returned?

Each row is one opportunity. Unavailable optional facts are omitted rather than returned as `null`; `evidenceGaps` explains what remains unknown.

```json
{
  "eventName": "Startup Summit Lisbon 2026 | Founder, Startup & Investor Event",
  "startsAt": "2026-09-17T08:30:00.000Z",
  "endsAt": "2026-09-17T23:00:00.000Z",
  "city": "Lisbon",
  "venue": "Unicorn Factory Lisboa - Beato Innovation District",
  "attendanceMode": "in-person",
  "organizer": "Startup Summit",
  "eventSummary": "2,000+ founders, investors & innovators. Lisbon, Sept 17–18. 150+ speakers, 200+ booths, 40+ countries.",
  "imageUrl": "https://img.evbuc.com/event-image.jpg",
  "isFree": false,
  "priceFrom": 24.5,
  "currency": "EUR",
  "eventUrl": "https://www.eventbrite.co.uk/e/startup-summit-lisbon-2026-founder-startup-investor-event-tickets-1987781295364",
  "audienceSizeTier": "unknown",
  "audienceFitScore": 56,
  "sponsorshipPotentialScore": 76,
  "timingScore": 100,
  "opportunityScore": 70,
  "opportunityStatus": "promising",
  "recommendedAction": "research_sponsorship",
  "fitReasons": [
    "Theme match: startup founders",
    "Matches sponsor audience terms: startup, founders"
  ],
  "sponsorshipSignals": [
    "In-person event supports physical brand activation",
    "Named organizer provides a practical outreach path",
    "Named venue indicates concrete event planning",
    "Commercially useful event format: summit, founder, startup"
  ],
  "evidenceGaps": [
    "Audience size is not publicly evidenced",
    "Sponsorship availability and package pricing require organizer confirmation"
  ],
  "runId": "lisbon-weekly-2026-08-14"
}
```

`RUN_SUMMARY` and `OUTPUT` hold run-level diagnostics instead of adding error rows to the opportunity table:

```json
{
  "status": "succeeded",
  "opportunitiesSaved": 10,
  "eventsEvaluated": 34,
  "cities": ["Lisbon"],
  "dateRange": { "from": "2026-08-14", "to": "2026-10-13" },
  "highPriorityCount": 2,
  "promisingCount": 5
}
```

A search with no matching events succeeds with `succeeded_no_results`.

### API usage

```bash
curl -X POST "https://api.apify.com/v2/acts/trovevault~event-sponsorship-finder/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "cities": ["Berlin"],
    "sponsorProfile": "A B2B observability platform seeking platform engineers, developer-tool founders, and cloud infrastructure teams.",
    "themes": ["platform engineering", "developer tools", "cloud infrastructure"],
    "maxResults": 10
  }'
```

Poll the returned run ID, then download the default dataset. The Actor also works with Apify clients and the Apify MCP server. Use webhooks or a downstream integration for delivery.

### Scheduling

Use an Apify Schedule for weekly searches. Every run returns the current shortlist so score changes remain visible. For new-only alerts, deduplicate by `eventUrl` downstream; `datasetId` and `runId` support that pattern.

### Runtime and cost

The Actor is self-contained: it does not call another Actor or an external scoring service. It uses HTTP extraction where possible and browser rendering for dynamic public listings, so run time and compute usage increase with the number of cities and themes. Start with one city and five results.

### Limitations

- Initial discovery focuses on local technology, AI, startup, founder, and developer events.
- Coverage varies by city, date, and the availability of public event listings.
- Listings may be changed, canceled, incomplete, promotional, or duplicated.
- Audience estimates are heuristic and are not verified attendance.
- A named organizer does not guarantee sponsorship inventory.
- The Actor does not retrieve sponsorship decks, package prices, private emails, attendee lists, or private communities.
- It does not contact organizers, purchase packages, register attendees, or publish event content.
- Verify dates, venue, audience, rights, and commercial terms on the event page.
- Do not use output for unsolicited bulk messaging or personal-data collection.

### Troubleshooting

**No results:** broaden the window, simplify themes, or test a larger technology hub.

**Relevant but not sponsorable:** add audience roles and activation goals to `sponsorProfile`.

**Scores are broad:** replace generic themes such as `technology` with concrete topics, roles, or communities.

**Scheduled runs repeat events:** the Finder intentionally returns a current shortlist. Deduplicate by `eventUrl` downstream for new-only alerts.

**One source returns fewer events:** retry once, then open an issue with a redacted run ID. Other sources continue independently.

### Responsible use

Respect copyright, contracts, privacy, local law, and publisher terms. Verify important claims and do not republish full descriptions or standalone images without permission.

### FAQ

**Finder or monitor?**\
Finder describes the product result. Apify Schedules provide recurring monitoring.

**Does it guarantee sponsorship ROI?**\
No. Scores prioritize research. Confirm audience, packages, exclusivity, price, and deliverables with the organizer.

**Why keep `eventUrl`?**\
Buyers need the canonical page to validate the opportunity and find the correct organizer route.

**Where can I get help?**\
Open an issue with the run ID, city, date range, and expected result. Do not include API tokens or private information.

### Changelog

#### 0.1

- Initial city-level sponsorship opportunity finder.
- Added self-contained public event crawling, audience-fit, sponsorability, timing, weighted scores, evidence gaps, images, price signals, recommended actions, destination dataset support, and run summaries.

# Actor input Schema

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

Cities to search for local events. Use common English city names such as Lisbon, Berlin, London, New York, or San Francisco. One to three cities keeps runs focused and economical.

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

Earliest event date to include. Leave blank to start today. Use a future date when planning a specific trip or campaign.

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

Latest event date to include. Leave blank for a 60-day window. Two to eight weeks usually provides enough time for sponsorship outreach.

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

Describe your company, offer, ideal audience, and sponsorship goal. This context determines audience-fit scoring. Example: A B2B developer-tools company seeking founders and senior engineers for product demos and partnerships.

## `themes` (type: `array`):

Topics that should be present in the event or its expected audience. These themes sharpen discovery and fit scoring. Examples: AI agents, developer tools, startup founders, B2B SaaS.

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

Maximum number of ranked opportunities to save. Use 5 to 20 for a weekly review, or a larger value when creating a broader event pipeline.

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

Optional existing Apify dataset ID. When supplied, the Actor writes each opportunity to both the default dataset and this destination dataset.

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

Optional identifier from your workflow. It is copied to every result so downstream systems can group rows from the same search.

## Actor input object example

```json
{
  "cities": [
    "Lisbon"
  ],
  "sponsorProfile": "A B2B developer-tools company seeking AI founders, technical leaders, and senior engineers for product demos and partnerships.",
  "themes": [
    "AI",
    "startup founders",
    "developer tools"
  ],
  "maxResults": 5
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "cities": [
        "Lisbon"
    ],
    "sponsorProfile": "A B2B developer-tools company seeking AI founders, technical leaders, and senior engineers for product demos and partnerships.",
    "themes": [
        "AI",
        "startup founders",
        "developer tools"
    ],
    "maxResults": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/event-sponsorship-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 = {
    "cities": ["Lisbon"],
    "sponsorProfile": "A B2B developer-tools company seeking AI founders, technical leaders, and senior engineers for product demos and partnerships.",
    "themes": [
        "AI",
        "startup founders",
        "developer tools",
    ],
    "maxResults": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/event-sponsorship-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 '{
  "cities": [
    "Lisbon"
  ],
  "sponsorProfile": "A B2B developer-tools company seeking AI founders, technical leaders, and senior engineers for product demos and partnerships.",
  "themes": [
    "AI",
    "startup founders",
    "developer tools"
  ],
  "maxResults": 5
}' |
apify call trovevault/event-sponsorship-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,trovevault/event-sponsorship-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/rqQLoucBGLZgHISXP/builds/dphTEe8TrU9wmbuhl/openapi.json