# Conference Events Scout (`trovevault/conference-events-scout`) Actor

Discovers conferences and returns opportunityScore, icpMatch, recommendedEngagement, audienceFit, dates, locations, and websites. Export data, run via API, schedule runs, or integrate with tools.

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

## Pricing

from $1.70 / 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 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

## Conference Events Scout

Find upcoming conferences and rank them as business opportunities for speaking, sponsorship, booth, partnership, attendance, or skip decisions.

Conference Events Scout discovers public conference listings across business, marketing, technology, AI, ecommerce, cybersecurity, product, startup, fintech, health tech, and education technology markets. It deduplicates events, filters them by region and date range, then uses AI to score each event against your company or product description.

The actor is built for recurring event pipeline research. Use it to decide which conferences deserve sales, marketing, partnerships, or thought-leadership attention before your team spends time reviewing every listing manually.

### Why Use This Actor

- Discover relevant conferences from maintained public directories instead of pasting event URLs one by one.
- Rank conferences by commercial fit, not only by date or category.
- Get practical recommendations such as speak, sponsor, booth, attend, partnership, or skip.
- Generate talk-topic ideas and use-case angles for stronger event planning.
- Run the same search every month or quarter and append results to an existing dataset.

### Sources

The actor resolves sources internally. Users choose categories, region, dates, and company context; they do not need to manage source bundles or fallback settings.

Current discovery sources include:

- `online.marketing` for ecommerce, digital marketing, advertising, MarTech, SEO, content, analytics, growth, and AI-related marketing events.
- `conventions.io` for technology conferences such as AI, DevOps, cloud, cybersecurity, JavaScript, Python, data engineering, Kubernetes, and open source.
- `techconf.directory` for developer, cloud, AI, security, data, and software engineering conferences.
- `eventea.eu` for European business, technology, marketing, product, SaaS, startup, sales, and leadership events.
- `eventbrowse.com` for business and technology conferences across AI, fintech, health tech, cybersecurity, operations, and innovation.
- `martech.zone/conferences` for marketing technology, sales, cloud, data, and AI events.
- `10times.com` for broad business, technology, marketing, security, finance, startup, and sector-specific coverage.
- `clocate.com` for global conference directory expansion when category coverage needs more breadth.
- `usconf.com`, `legaltechevents.com`, and category-specific curated event lists for additional business and technology coverage.
- `apify/google-search-scraper` as an internal fallback when primary sources return too few results and Apify credentials are available.

Broad directories can include trade shows, expos, summits, forums, and business events. The actor filters and scores them, but users should review official websites before committing budget.

### AI Analysis

By default, AI scoring is routed through Apify's OpenRouter integration. On Apify Cloud this uses the run's `APIFY_TOKEN` to call OpenRouter through Apify, so users do not need to provide their own OpenRouter token for the default path.

If you provide your own LLM credentials, the actor uses your selected provider instead of the default OpenRouter via Apify route. Supported options are:

- OpenRouter with your own key
- OpenAI
- Anthropic
- Google Gemini
- OpenAI-compatible endpoints
- No AI scoring

Conference names, descriptions, dates, locations, categories, and your company description are sent to the selected AI provider for scoring. API keys are secret inputs, used only for provider requests, and never written to the dataset or logs.

When AI is unavailable or disabled, the actor still returns deterministic scores based on category and text relevance. AI scoring produces better recommendations.

### Input

| Input | Type | Description |
|---|---|---|
| `categories` | array | Conference markets to search, such as AI & Machine Learning, E-commerce & Retail, SaaS & Developer Tools, Cybersecurity, Cloud & DevOps, or Fintech. |
| `region` | string | Geographic filter: Worldwide, Europe, North America, Asia Pacific, Middle East & Africa, or Latin America. |
| `dateFrom` | string | Earliest event start date. Leave blank to use today. |
| `dateTo` | string | Latest event start date. Leave blank to use one year from today. |
| `maxResults` | integer | Maximum ranked conference opportunities to save. |
| `companyDescription` | string | Company, product, audience, and business goal used for AI scoring. |
| `aiProvider` | string | AI provider for scoring. Default is OpenRouter via Apify. |
| `aiApiKey` | string | Secret API key for your own provider. Leave blank for OpenRouter via Apify or No AI scoring. |
| `aiModel` | string | Optional model override. |
| `aiBaseUrl` | string | Base URL for OpenAI-compatible providers only. |
| `datasetId` | string | Optional Apify dataset ID to append results to. |
| `runId` | string | Optional pipeline identifier copied to output rows. |

Example input:

```json
{
  "categories": ["AI & Machine Learning", "SaaS & Developer Tools"],
  "region": "Europe",
  "dateFrom": "2026-05-01",
  "dateTo": "2026-12-31",
  "maxResults": 20,
  "companyDescription": "A B2B SaaS company selling web data, scraping automation, and AI data workflows to developers, agencies, and e-commerce teams.",
  "aiProvider": "openrouter-apify"
}
````

### Output

Each dataset row is one conference opportunity.

| Field | Description |
|---|---|
| `name` | Conference or event name. |
| `startDate`, `endDate` | Event dates when detected. |
| `city`, `country`, `region` | Normalized location fields. |
| `attendanceMode` | Detected format such as in-person, online, or hybrid. |
| `category` | Category searched when the conference was found. |
| `description` | Short public listing description when available. |
| `websiteUrl` | Official or best available conference website. |
| `opportunityScore` | Overall opportunity score from 1 to 100. |
| `icpMatch` | Ideal customer profile fit from 1 to 10. |
| `recommendedEngagement` | Recommended action: booth, speak, sponsor, attend, partnership, or skip. |
| `audienceFit` | Concise audience-fit explanation. |
| `engagementRationale` | Why the actor recommends that engagement path. |
| `suggestedTalkTopics` | Talk ideas when speaking appears relevant. |
| `relevantUseCases` | Product, sales, or marketing use cases for the event audience. |
| `runId` | Optional pipeline identifier when supplied. |

Example output:

```json
{
  "name": "AI World Congress 2026",
  "startDate": "2026-06-23",
  "endDate": "2026-06-24",
  "city": "London",
  "country": "United Kingdom",
  "region": "Europe",
  "attendanceMode": "in-person",
  "category": "AI & Machine Learning",
  "description": "Conference for AI leaders, technology teams, and business decision makers.",
  "websiteUrl": "https://www.aiworldcongress.com/",
  "opportunityScore": 86,
  "icpMatch": 9,
  "recommendedEngagement": "speak",
  "audienceFit": "Strong fit for teams evaluating AI data workflows and automation.",
  "engagementRationale": "The audience likely includes technical and commercial buyers for web data products.",
  "suggestedTalkTopics": [
    "Building reliable AI data pipelines from public web data",
    "Operational lessons from large-scale web automation"
  ],
  "relevantUseCases": [
    "AI training data collection",
    "Market intelligence automation"
  ]
}
```

### API Usage

```bash
curl -X POST "https://api.apify.com/v2/acts/trovevault~conference-events-scout/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "categories": ["AI & Machine Learning"],
    "region": "Europe",
    "dateFrom": "2026-05-01",
    "dateTo": "2026-12-31",
    "maxResults": 10,
    "companyDescription": "A B2B SaaS company selling web data and AI automation workflows."
  }'
```

### Limitations

- Conference directories can be incomplete, stale, or promotional.
- Broad sources such as 10times and Clocate may include trade shows, expos, and business events that need review.
- Dates, locations, and official URLs depend on what each source publishes.
- AI scoring is a recommendation layer, not a guarantee of ROI or audience quality.
- The actor does not register for events, verify sponsorship availability, or confirm speaker deadlines.
- Official event websites should be reviewed before buying booths, sponsorships, or travel.

### FAQ

**Do I need to provide source URLs?**\
No. Choose categories, dates, region, and company context. The actor resolves sources internally.

**Does it always use AI?**\
On Apify Cloud, the default route uses OpenRouter via Apify. You can also provide your own LLM key or disable AI scoring.

**What happens if I provide my own LLM token?**\
The actor uses your selected provider instead of the default OpenRouter via Apify route.

**Are conference details guaranteed?**\
No. The actor structures public listings and adds recommendations. Always verify important details on the official event website.

**Can I use it for monthly monitoring?**\
Yes. Schedule it with the same categories and date window, and optionally append to an existing dataset with `datasetId`.

### Troubleshooting

- If no results are returned, widen the date range, choose Worldwide, or add adjacent categories.
- If AI fields look generic, provide a more specific `companyDescription`.
- If using your own provider, confirm `aiApiKey`, `aiProvider`, and `aiModel` match that provider.
- If using an OpenAI-compatible endpoint, include `aiBaseUrl` without `/chat/completions`.

### Changelog

#### v0.1

- Initial TroveVault version based on the original Conference Scout workflow.
- Added broader conference categories, internal source resolution, detail-page enrichment, OpenRouter via Apify by default, optional user-supplied LLM providers, TroveVault schemas, and product-focused output.

# Actor input Schema

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

One or more conference markets to search. The actor uses maintained public directories for each category, deduplicates events, then ranks them against your company description. Choose focused categories for cleaner recommendations, or several categories when building a broader event pipeline.

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

Geographic region to keep in the final results. The actor filters by detected country, city, and directory region text. Use Worldwide for discovery, or choose Europe, North America, Asia Pacific, Middle East & Africa, or Latin America when your team can only act in specific markets.

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

Start of the event date range in YYYY-MM-DD format. Leave blank to use today's date. The actor keeps conferences that start on or after this date.

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

End of the event date range in YYYY-MM-DD format. Leave blank to use one year from today. A 6 to 12 month window usually gives enough lead time for speaking submissions, sponsorship planning, and travel decisions.

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

Maximum number of ranked conference opportunities to save. Lower values keep runs cheaper and focus on the strongest matches. Use 5 to 20 for review runs, or 50 to 100 when building a larger event database.

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

Short description of the company, product, audience, and commercial goal used for AI scoring. Example: A B2B SaaS company selling web data and automation workflows to developers, agencies, and e-commerce teams. Better context produces more useful ICP match scores, engagement recommendations, and talk ideas.

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

AI service used for opportunity scoring. The default uses Apify's OpenRouter integration and does not require your own LLM token on Apify Cloud. Choose another provider only when you want the actor to use your own API key instead.

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

API key for your selected AI provider. Leave blank when using OpenRouter via Apify or No AI scoring. The key is used only for the scoring request, is stored encrypted by Apify, and is never written to the dataset or logs.

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

Optional model name for AI scoring. Leave blank to use the actor default for the selected provider. Examples: openai/gpt-4o-mini for OpenRouter, gpt-4o-mini for OpenAI, claude-3-5-haiku-latest for Anthropic, or gemini-1.5-flash for Google.

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

Base URL for an OpenAI-compatible provider, such as https://api.your-provider.com/v1. Use this only when AI Provider is OpenAI-compatible endpoint. Leave blank for OpenRouter, OpenAI, Anthropic, Google, or No AI scoring.

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

ID of an existing Apify dataset to append the same conference opportunity rows to, in addition to the default run dataset. Use this for pipeline chaining or shared dashboards. Leave blank to use only the default run dataset.

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

Optional run identifier copied to output rows for downstream tracing. Use this when another actor, scheduler, or workflow needs to link these opportunities back to a larger campaign run. Leave blank for standalone runs.

## Actor input object example

```json
{
  "categories": [
    "AI & Machine Learning"
  ],
  "region": "Worldwide",
  "maxResults": 5,
  "companyDescription": "A B2B SaaS company selling web data, scraping automation, and AI data workflows to developers, agencies, and e-commerce teams.",
  "aiProvider": "none"
}
```

# Actor output Schema

## `dataset` (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 = {
    "categories": [
        "AI & Machine Learning"
    ],
    "maxResults": 5,
    "companyDescription": "A B2B SaaS company selling web data, scraping automation, and AI data workflows to developers, agencies, and e-commerce teams.",
    "aiProvider": "none"
};

// Run the Actor and wait for it to finish
const run = await client.actor("trovevault/conference-events-scout").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 = {
    "categories": ["AI & Machine Learning"],
    "maxResults": 5,
    "companyDescription": "A B2B SaaS company selling web data, scraping automation, and AI data workflows to developers, agencies, and e-commerce teams.",
    "aiProvider": "none",
}

# Run the Actor and wait for it to finish
run = client.actor("trovevault/conference-events-scout").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 '{
  "categories": [
    "AI & Machine Learning"
  ],
  "maxResults": 5,
  "companyDescription": "A B2B SaaS company selling web data, scraping automation, and AI data workflows to developers, agencies, and e-commerce teams.",
  "aiProvider": "none"
}' |
apify call trovevault/conference-events-scout --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Conference Events Scout",
        "description": "Discovers conferences and returns opportunityScore, icpMatch, recommendedEngagement, audienceFit, dates, locations, and websites. Export data, run via API, schedule runs, or integrate with tools.",
        "version": "0.1",
        "x-build-id": "Vu5uMJ7TjLAeLE0ch"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trovevault~conference-events-scout/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trovevault-conference-events-scout",
                "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/trovevault~conference-events-scout/runs": {
            "post": {
                "operationId": "runs-sync-trovevault-conference-events-scout",
                "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/trovevault~conference-events-scout/run-sync": {
            "post": {
                "operationId": "run-sync-trovevault-conference-events-scout",
                "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",
                "required": [
                    "categories",
                    "region"
                ],
                "properties": {
                    "categories": {
                        "title": "Conference Categories",
                        "minItems": 1,
                        "type": "array",
                        "description": "One or more conference markets to search. The actor uses maintained public directories for each category, deduplicates events, then ranks them against your company description. Choose focused categories for cleaner recommendations, or several categories when building a broader event pipeline.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "AI & Machine Learning",
                                "E-commerce & Retail",
                                "Digital Marketing",
                                "SEO & Content Marketing",
                                "SaaS & Developer Tools",
                                "Cybersecurity",
                                "Cloud & DevOps",
                                "Data & Analytics",
                                "Fintech",
                                "Product & Design",
                                "Sales & Growth",
                                "Startup & Venture",
                                "Healthcare Technology",
                                "Education Technology"
                            ],
                            "enumTitles": [
                                "AI & Machine Learning",
                                "E-commerce & Retail",
                                "Digital Marketing",
                                "SEO & Content Marketing",
                                "SaaS & Developer Tools",
                                "Cybersecurity",
                                "Cloud & DevOps",
                                "Data & Analytics",
                                "Fintech",
                                "Product & Design",
                                "Sales & Growth",
                                "Startup & Venture",
                                "Healthcare Technology",
                                "Education Technology"
                            ]
                        },
                        "default": [
                            "AI & Machine Learning"
                        ]
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "Worldwide",
                            "Europe",
                            "North America",
                            "Asia Pacific",
                            "Middle East & Africa",
                            "Latin America"
                        ],
                        "type": "string",
                        "description": "Geographic region to keep in the final results. The actor filters by detected country, city, and directory region text. Use Worldwide for discovery, or choose Europe, North America, Asia Pacific, Middle East & Africa, or Latin America when your team can only act in specific markets.",
                        "default": "Worldwide"
                    },
                    "dateFrom": {
                        "title": "Date From",
                        "type": "string",
                        "description": "Start of the event date range in YYYY-MM-DD format. Leave blank to use today's date. The actor keeps conferences that start on or after this date."
                    },
                    "dateTo": {
                        "title": "Date To",
                        "type": "string",
                        "description": "End of the event date range in YYYY-MM-DD format. Leave blank to use one year from today. A 6 to 12 month window usually gives enough lead time for speaking submissions, sponsorship planning, and travel decisions."
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of ranked conference opportunities to save. Lower values keep runs cheaper and focus on the strongest matches. Use 5 to 20 for review runs, or 50 to 100 when building a larger event database.",
                        "default": 5
                    },
                    "companyDescription": {
                        "title": "Company or Product Description",
                        "type": "string",
                        "description": "Short description of the company, product, audience, and commercial goal used for AI scoring. Example: A B2B SaaS company selling web data and automation workflows to developers, agencies, and e-commerce teams. Better context produces more useful ICP match scores, engagement recommendations, and talk ideas."
                    },
                    "aiProvider": {
                        "title": "AI Provider",
                        "enum": [
                            "openrouter-apify",
                            "openrouter",
                            "openai",
                            "anthropic",
                            "google",
                            "openai-compatible",
                            "none"
                        ],
                        "type": "string",
                        "description": "AI service used for opportunity scoring. The default uses Apify's OpenRouter integration and does not require your own LLM token on Apify Cloud. Choose another provider only when you want the actor to use your own API key instead.",
                        "default": "openrouter-apify"
                    },
                    "aiApiKey": {
                        "title": "AI API Key",
                        "type": "string",
                        "description": "API key for your selected AI provider. Leave blank when using OpenRouter via Apify or No AI scoring. The key is used only for the scoring request, is stored encrypted by Apify, and is never written to the dataset or logs."
                    },
                    "aiModel": {
                        "title": "AI Model",
                        "type": "string",
                        "description": "Optional model name for AI scoring. Leave blank to use the actor default for the selected provider. Examples: openai/gpt-4o-mini for OpenRouter, gpt-4o-mini for OpenAI, claude-3-5-haiku-latest for Anthropic, or gemini-1.5-flash for Google."
                    },
                    "aiBaseUrl": {
                        "title": "AI Base URL",
                        "type": "string",
                        "description": "Base URL for an OpenAI-compatible provider, such as https://api.your-provider.com/v1. Use this only when AI Provider is OpenAI-compatible endpoint. Leave blank for OpenRouter, OpenAI, Anthropic, Google, or No AI scoring."
                    },
                    "datasetId": {
                        "title": "Dataset ID (optional)",
                        "type": "string",
                        "description": "ID of an existing Apify dataset to append the same conference opportunity rows to, in addition to the default run dataset. Use this for pipeline chaining or shared dashboards. Leave blank to use only the default run dataset."
                    },
                    "runId": {
                        "title": "Run ID (optional)",
                        "type": "string",
                        "description": "Optional run identifier copied to output rows for downstream tracing. Use this when another actor, scheduler, or workflow needs to link these opportunities back to a larger campaign run. Leave blank for standalone runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
