# Expose Search (`expose/expose-search`) Actor

Search people, companies, and schools on Expose. Each row uses one Expose credit and lands in the dataset as a report.

- **URL**: https://apify.com/expose/expose-search.md
- **Developed by:** [expose team](https://apify.com/expose) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Expose Search

Search people, companies, and schools on [Expose](https://expose.team) and save each report to the dataset.

One valid row uses one Expose credit. The credit is billed on your Expose account, through the API key you provide. Apify does not see that key in the dataset.

### What you need

- An Expose account with credits. Copy the API key from [Integrations](https://expose.team/platform/integrations).
- An identifier Expose can search:
  - Person: email, phone (with country code), or profile URL.
  - Company or school: domain or profile URL.

A name alone is not a search.

### Input

| Field | Required | Description |
| --- | --- | --- |
| Expose API key | Yes, unless `EXPOSE_API_KEY` is set | Your key. Apify stores this field encrypted. |
| Searches | Yes | One object per search. |

```json
{
  "exposeApiKey": "YOUR_API_KEY",
  "searches": [
    { "type": "person", "email": "jane@example.com" },
    { "type": "person", "phone": "+14155551234" },
    { "type": "company", "domain": "stripe.com" },
    { "type": "school", "domain": "mit.edu" }
  ]
}
```

When a row has more than one identifier, the Actor sends the first match in this order: email, phone, profile URL for a person; domain, then profile URL for a company or school. Use a second row to search another identifier. That second row spends another credit.

The Actor checks the credit balance first. If the account does not have a credit for every valid row, it stops and does not start the searches.

### Output

Each row becomes one dataset item:

| Field | Meaning |
| --- | --- |
| `type` | `person`, `company`, or `school` |
| `identifier` | The value that was searched |
| `identifierField` | `email`, `phone`, `profile_url`, or `domain` |
| `ok` | Expose accepted the search |
| `found` | The report object is not empty |
| `creditsCharged` | `1` when Expose charged this row |
| `error` | Why the row failed |
| `report` | The `data` object from `GET /api/search` |

Open an item to read the report. The run's key-value store also has a `SUMMARY` record with succeeded, failed, and skipped counts.

A row that fails validation is stored with `creditsCharged: 0` and the rest of the run continues. If Expose returns 401 or 402 during the run, the Actor stops so later rows are not sent.

### Call it from another Actor

```javascript
import { Actor } from 'apify';

const run = await Actor.call('YOUR_USERNAME/expose-search', {
  exposeApiKey: process.env.EXPOSE_API_KEY,
  searches: [{ type: 'person', email: 'jane@example.com' }],
});
const dataset = await Actor.apifyClient.dataset(run.defaultDatasetId).listItems();
```

Do not put a shared Expose API key in the environment of a public Actor. Each user should paste their own key. `EXPOSE_API_KEY` is for a private Actor that only your account runs.

### Data sent to Expose

The Actor sends the API key and the identifiers to `https://expose.team`. It does not browse the web and it does not use an Apify proxy. Reports contain publicly available information returned by Expose.

# Actor input Schema

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

From Expose, under Integrations. Stored encrypted. Leave this empty only when the Actor environment variable EXPOSE_API_KEY is set on a private Actor.

## `searches` (type: `array`):

One row is one search. A person needs an email, phone, or profile URL. A company or school needs a domain or a profile URL. When a row has more than one identifier, the Actor uses email, then phone, then profile URL for a person, and domain, then profile URL for a company or school.

## Actor input object example

```json
{
  "searches": [
    {
      "type": "person",
      "email": "jane@example.com"
    }
  ]
}
```

# Actor output Schema

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

Dataset of Expose reports, one item per search.

# 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 = {
    "searches": [
        {
            "type": "person",
            "email": "jane@example.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("expose/expose-search").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 = { "searches": [{
            "type": "person",
            "email": "jane@example.com",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("expose/expose-search").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 '{
  "searches": [
    {
      "type": "person",
      "email": "jane@example.com"
    }
  ]
}' |
apify call expose/expose-search --silent --output-dataset

```

## MCP server setup

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

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/jhyZoUPhA20iHMwT7/builds/55EgGZdg40SFaxaMz/openapi.json