# Event Presence Index Conference Booth Sponsor Signals Clay (`mambalabs/event-presence-index`) Actor

Company domain in, the third party conferences and trade shows that company publicly says it attends out. Searches the company's own domain, tells its own conference apart from the ones it attends, and returns event names with years plus an honest account of what the search could see.

- **URL**: https://apify.com/mambalabs/event-presence-index.md
- **Developed by:** [Mamba Labs](https://apify.com/mambalabs) (community)
- **Categories:** Lead generation, Automation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.25 / 1,000 company analyzeds

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

### 🎪 What can Event Presence Index do?

Give it a **company domain**. It returns the **third party conferences and trade shows that company publicly says it attends**, with a year for each where one can be resolved, as one flat Clay ready row per company.

| 📦 What you get | ⚙️ Features and integrations |
|---|---|
| 🎟️ **Events the company attends**, with a year and an evidence URL for each<br>🏛️ **Its own conference, told apart**, reported separately and never mixed in<br>📅 **A resolved year**, or an explicit null when the year cannot be trusted<br>🔎 **An honest coverage account**, so you can see what the search actually saw | 🌐 **Searches the company's own domain**, which is what kills brand collisions<br>🔁 **Two search sources**, with automatic failover per query<br>🧊 **21 day cache**, so a repeat run costs nothing new<br>⬇️ **Export** to JSON, CSV, Excel, HTML or XML |

Built for GTM teams who already have an account list and want to know where those accounts will physically be: to book meetings around a show, time a campaign to a conference week, or open with "see you at Forrester B2B Summit". Field and event marketing teams use it to build a competitive presence map.

> 🚫 **This is not an events database.** It is not a ticketing feed, not a directory of conferences, and not a list of everyone exhibiting at a show. Every other supplier in this category runs the inverse: event in, exhibitor list out. This one takes a company and reports what that company publishes about the events it attends. If the company publishes nothing, you get an honest empty row, not a guess.

### 🎯 Why use Event Presence Index?

| You want to | Read this field |
|---|---|
| Know which shows an account will be at | `event_1_name`, `event_2_name`, `event_3_name` |
| Time outreach to a conference week | `event_1_year`, `most_recent_event_year` |
| Prove the claim before you send it | `event_1_url`, `events_json` |
| Tell a sponsor from an attendee | `runs_own_event`, `own_events_json` |
| Know whether an empty row means anything | `coverage`, `fetch_status`, `queries_failed` |
| Filter to only dated, domain verified events | `confidence` inside `events_json` |

#### 🏛️ It tells a company's own conference apart from the ones it attends

This is the part that is hard, and it is where most of the build went.

Most companies use their events page for their own annual conference. A naive reading puts Dreamforce in Salesforce's attendance list, INBOUND in HubSpot's, and Data + AI Summit in Databricks'. None of those companies attends those events; they run them, and telling a buyer otherwise is a visible mistake.

Event Presence Index resolves ownership from evidence rather than from the name. A company that **runs** a conference hosts its registration, agenda, sessions and sponsors pages. A company that **attends** one hosts a landing page and links out to the organizer. Own conferences go in `own_events_json` with the signal that identified them, and never into the attendance list.

Measured across 24 companies on the build set: **100 percent of returned events were real third party events**, with zero own conferences misfiled and zero listing pages counted as events. Across a wider 49 company set, 94 percent, with the one exception a co-hosted event where ownership is genuinely shared.

### 📊 What data can Event Presence Index extract?

**33 fields per company.** The ones you will actually use:

| Field | What it holds |
|---|---|
| `event_count` | Distinct third party events found. `0` means the search ran and nothing matched. `null` means the search itself did not work. |
| `events_json` | Every event as `{name, year, evidence_url, source_host, confidence}` |
| `event_1_name` … `event_3_url` | The first three events flattened, so Clay does not have to parse JSON |
| `most_recent_event_name` / `_year` | The dated event with the highest year |
| `dated_event_count` / `undated_event_count` | How many events carry a resolvable year, and how many do not |
| `runs_own_event` / `own_event_name` | Whether the company runs its own conference |
| `own_events_json` | Every own conference found, with the signal that identified it |
| `excluded_own_event_count` | How many candidates were filtered out as the company's own event |
| `coverage` | `good`, `partial` or `none` |
| `fetch_status` | `ok`, `partial` or `search_failed` |
| `queries_run` / `queries_failed` / `queries_fallback` | What the look actually did |

> ⚠️ **`0` and `null` mean different things and are never collapsed.** `event_count: 0` means every search ran, the results were read, and nothing matched. `event_count: null` with `fetch_status: "search_failed"` means the search engine refused and **nothing was looked at**. A zero is an answer. A null is an admission. Read `coverage` and `queries_failed` alongside the count and you can always tell which one you are holding.

### 🔍 How to find the conferences a company attends

1. Open the **Input** tab and put a company domain in `domain`, for example `6sense.com`.
2. Add `company_name` when the brand differs from the domain stem, for example `Gong` for `gong.io`. It improves matching.
3. Set `years` to the years you care about. The default is `2025,2026`.
4. Run it. A cold run takes about 6 seconds.
5. Read `event_1_name` for the headline answer, and `event_1_url` for the page that proves it.

#### 🧬 Using it in Clay

Add it as an enrichment on a company table and map `domain` to your domain column. Every run returns exactly one row per company, including companies with no events found, so your table never loses rows. Map `event_1_name` and `event_1_year` into columns and filter on `coverage = good` to work only with complete looks.

#### 🎚️ Filtering for outreach quality

Filter `events_json` on `confidence: "high"` when you only want dated events found on the company's own domain. `medium` is domain verified but undated. Use `high` for anything you are going to put in an email.

### 💵 How much does it cost to check a company's event presence?

**$0.005 per company** on the free tier, less at every paid Apify tier.

| Tier | Price per company |
|---|---|
| FREE | $0.005 |
| BRONZE | $0.00475 |
| SILVER | $0.0045 |
| GOLD | $0.00425 |

> 💳 **Every company that gets looked at is billed, including the ones that come back empty.** The actor issues the same searches and reads the same results either way, so an honest empty row costs the same as a full one. **You are not billed when the look does not happen.** If every search is refused, the row comes back `event_count: null` with `fetch_status: "search_failed"` and no charge is made for it.

### ⌨️ Input

Set everything on the **Input** tab. Only `domain` is required.

| Field | Default | What it does |
|---|---|---|
| `domain` | none | Company domain, for example `6sense.com`. Protocol and path are stripped. |
| `company_name` | derived | Helps when the brand differs from the domain stem. |
| `years` | `2025,2026` | Comma separated. Events dated outside the set are still returned and flagged. |
| `max_queries` | `2` | 1 to 5. Two is the measured sweet spot. |
| `include_own_events` | `true` | Report the company's own conference in its own field. |
| `skipCache` | `false` | `true` forces a fresh look instead of the 21 day cache. |

### 📤 Output

One row per company. Export as **JSON, CSV, Excel, HTML or XML**, or pull it straight from the API.

```json
{
  "domain": "6sense.com",
  "company_name": "6sense",
  "event_count": 2,
  "event_1_name": "Adobe Summit 2026",
  "event_1_year": 2026,
  "event_1_url": "https://abx.6sense.com/adobe2026",
  "event_2_name": "Forrester B2B Summit 2026",
  "event_2_year": 2026,
  "most_recent_event_name": "Adobe Summit 2026",
  "most_recent_event_year": 2026,
  "dated_event_count": 2,
  "undated_event_count": 0,
  "runs_own_event": false,
  "own_events_json": null,
  "excluded_own_event_count": 0,
  "queries_run": 2,
  "queries_failed": 0,
  "results_examined": 24,
  "coverage": "good",
  "fetch_status": "ok",
  "run_date": "2026-08-10T06:30:00.000Z"
}
```

### 💡 Tips

- Run it on a shortlist rather than a whole database. It bills per company looked at, and the answer is most valuable on accounts you already care about.
- Pass `company_name` whenever the brand is a common word. `Gong`, `Clari` and `Segment` all collide with unrelated results, and the name helps.
- Treat `runs_own_event: true` as its own signal. A company that runs a conference is a different kind of account from one that only attends.
- Re-run with `skipCache: "true"` in the weeks before a big show, when attendance pages go up.

### ⚠️ Known limits

- **Roughly three companies in ten come back with a search that could not complete.** Measured at 30 percent of queries refused across a 49 company production set. Those rows return `event_count: null` and `fetch_status: "search_failed"`, never a false zero, and they are not billed. Re-running later usually clears it.
- **Most companies genuinely publish nothing.** An empty row means the company does not publish an event attendance page that a search engine has indexed. It does not mean the company attends no events. Read `event_count: 0` as "we could not see any".
- **Co-hosted events are genuinely ambiguous.** Where a company co-hosts an event with the wider community, ownership is a judgment call and the actor may classify it either way. Starburst and Presto Summit is the live example from the build set.
- **A year in an event name can be stale.** The actor reports the year the company's own page carries. A page that still names last year's edition will return last year's year, correctly quoted and out of date.
- **About one event in five comes back without a year.** Those are returned with a null year, counted in `undated_event_count`, and excluded from `most_recent_event_year`. They are never treated as current.
- **Attendance phrases are matched case sensitively.** A heading written in full caps is missed. The measured precision and recall numbers were taken with this exact rule.
- **No proxy.** The actor runs proxyless by design, so rate limiting surfaces in `fetch_status` rather than being hidden.

### ❓ FAQ

**Does it read the company's event pages?**
No. It reads search result titles and URLs from the company's own domain. It does not fetch the target pages, so no site's `robots.txt` is engaged and no page content is copied. Event names are short factual strings.

**Why did my account come back empty?**
Check `coverage` and `queries_failed` first. `coverage: good` with `queries_failed: 0` means a full healthy look found nothing published. Anything else means the look was incomplete, and `fetch_status` says so.

**Why is my account's flagship conference missing?**
Look at `own_events_json`. If the conference is theirs, it is reported there deliberately and kept out of the attendance list.

**Can I get more than three events?**
Yes. `event_1` through `event_3` are a convenience for Clay. `events_json` carries every event found.

**Does it work outside the US?**
Yes. Nothing in it is region specific, and the build set returned events in London, Mumbai and Sydney.

### 🧩 Want other GTM data?

Mamba Labs builds custom actors for B2B go-to-market teams. The public versions
of that work live here on the Store, so our users get the same tooling we build
under contract.

| | |
|---|---|
| 🧑‍💼 [GTM Hiring Signal Scraper](https://apify.com/mambalabs/gtm-hiring-signal-scraper) | 🧱 [Tech Stack Detector](https://apify.com/mambalabs/gtm-tech-stack-signal-scraper) |
| 📡 [B2B Buying Signals Aggregator](https://apify.com/mambalabs/b2b-buying-signals-hiring-tech-stack-intent-for-clay) | 🔑 [Job Board Keyword Scanner](https://apify.com/mambalabs/job-board-keyword-signal-scanner) |
| 🔗 [Domain to LinkedIn URL Resolver](https://apify.com/mambalabs/domain-to-linkedin-url-resolver) | 🎯 [ICP Fit Scorer](https://apify.com/mambalabs/icp-account-lead-scoring-fit-scorer-0-100-for-clay) |
| 📋 [Job Posting Monitor](https://apify.com/mambalabs/gtm-job-discovery) | 📬 [Domain Deliverability Checker](https://apify.com/mambalabs/domain-deliverability-checker) |
| 🏢 [Company Firmographic Enricher](https://apify.com/mambalabs/company-firmographic-enricher) | 🌐 [Company Social Presence Mapper](https://apify.com/mambalabs/company-social-presence-mapper) |
| 🪪 [Company Identity Resolver](https://apify.com/mambalabs/company-identity-resolver) | 💰 [Funding and Press Signal Scanner](https://apify.com/mambalabs/funding-press-signal-scanner) |
| 🔄 [Company Change-Event Feed](https://apify.com/mambalabs/company-change-event-feed) | 👤 [People Finder and Email Verifier](https://apify.com/mambalabs/people-finder) |
| 🚀 [Prospect Engine](https://apify.com/mambalabs/b2b-prospect-engine) | 🤖 [AI Tooling Detector](https://apify.com/mambalabs/ai-tooling-detector) |
| 📮 [Outbound Stack Detector](https://apify.com/mambalabs/outbound-infrastructure-fingerprint) | 📝 [Publishing Frequency Tracker](https://apify.com/mambalabs/blog-publishing-frequency) |
| ✉️ [Work Email Waterfall Finder](https://apify.com/mambalabs/email-waterfall-orchestrator) | ⏩ [Sequencer Lead Push](https://apify.com/mambalabs/clay-to-instantly-smartlead-push) |
| 🏅 [Workplace Program Detector](https://apify.com/mambalabs/workplace-program-detector) | 👥 [Team Page People Extractor](https://apify.com/mambalabs/team-page-people-extractor) |
| 🧭 [Company Discovery List Builder](https://apify.com/mambalabs/company-discovery-list-builder) |  |

> Every actor in the suite takes a domain or a company and returns one flat row,
> so they stack in the same Clay table without reshaping anything.

> 🛠️ **Need something custom built for you or your team?** Tell us what you are
> trying to find and we will build it. [Talk to Mamba Labs](https://mambabuilt.com/contact).

### 🛟 Support

Issues, feature requests and data questions go through the **Issues** tab on this actor. Include the domain and the run ID and it can be traced.

> **Sourcing and legal.** This actor reads publicly available search results only. It does not fetch target pages, does not process personal data, and returns short factual strings: event names, years and the public URL of the page each came from. It runs proxyless, and rate limiting is reported in the output rather than hidden.

Built by [Mamba Labs](https://apify.com/mambalabs).

# Actor input Schema

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

A single company domain, for example 6sense.com. Protocol and path are stripped.

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

Improves matching when the brand differs from the domain stem, for example Gong for gong.io. Derived from the domain when left empty.

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

Comma separated, for example 2025,2026. Events dated outside this set are still returned and flagged. Sent as a string so it works from Clay.

## `include_own_events` (type: `boolean`):

Reports whether the company runs its own conference as a separate field. It is never mixed into the attendance list.

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

Between 1 and 5. Each query costs roughly 0.8 seconds plus a 1.3 second pause. 2 is the measured sweet spot: search engines refuse a third query from the same container almost every time, and the third query added no events the first two did not already find. Sent as a string so it works from Clay.

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

false uses the 21 day result cache. true forces a fresh look.

## Actor input object example

```json
{
  "domain": "6sense.com",
  "company_name": "6sense",
  "years": "2026",
  "include_own_events": true,
  "max_queries": "2",
  "skipCache": "false"
}
```

# Actor output Schema

## `results` (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 = {
    "domain": "6sense.com",
    "company_name": "6sense",
    "years": "2026",
    "include_own_events": true,
    "max_queries": "2",
    "skipCache": "false"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mambalabs/event-presence-index").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 = {
    "domain": "6sense.com",
    "company_name": "6sense",
    "years": "2026",
    "include_own_events": True,
    "max_queries": "2",
    "skipCache": "false",
}

# Run the Actor and wait for it to finish
run = client.actor("mambalabs/event-presence-index").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 '{
  "domain": "6sense.com",
  "company_name": "6sense",
  "years": "2026",
  "include_own_events": true,
  "max_queries": "2",
  "skipCache": "false"
}' |
apify call mambalabs/event-presence-index --silent --output-dataset

```

## MCP server setup

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

```

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/WLhMy8fMDgsxdYxv5/builds/UiTeor3YBQjfw9RGH/openapi.json