# Email OSINT & Account Finder (`lance_api/email-osint-account-finder`) Actor

Find public accounts linked to an email across supported websites. Check account-existence signals, identify found accounts, separate not-found from uncertain results, and get clean structured data for OSINT, investigations, enrichment, and API workflows.

- **URL**: https://apify.com/lance\_api/email-osint-account-finder.md
- **Developed by:** [LanceAPI](https://apify.com/lance_api) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.50 / 1,000 results

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/actors/running/actors-in-store.md#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

## 📧 Email OSINT Account Finder

**Find public account-existence signals linked to an email address across supported websites, with one clean result per email.**

Enter one or more email addresses and check them across all currently supported platforms, or target only the websites you care about. The Actor returns which platforms found account signals and clearly separates **found**, **not found**, and **uncertain** checks, so blocked or rate-limited platforms are not incorrectly treated as confirmed negatives.

Each valid email produces **one dataset result item**. Multiple found accounts for the same email are grouped inside `accounts`, and the email is still billed as **one result**.

Why users choose this Actor:

- **One email → one clean result:** easy to scan, export, and send to another system.
- **Found is not confused with uncertain:** blocked, timed-out, errored, and inconclusive checks are counted separately.
- **Broad scan or targeted lookup:** check all supported platforms or only selected sites such as GitHub, Instagram, Office365, or Spotify.
- **Simple result-based pricing:** one valid email result creates one `result` charge, even if several account signals are found.

Important: a found account is an **account-existence signal**, not legal proof, identity verification, or email deliverability verification. Public websites can change their flows, block requests, or return inconclusive responses.

### ✨ Key Features

#### One email, one result

Each input email produces exactly **one dataset item**. Found platforms are nested under `accounts`, so your dataset does not turn into a long list of platform rows.

#### Found, not found, and uncertain are separated

The Actor reports `foundCount`, `notFoundCount`, and `uncertainCount` up front. Rate limits, timeouts, errors, and inconclusive checks stay separate instead of being counted as confirmed not found.

#### Broad scan or targeted account lookup

Leave `selectedPlatforms` empty to check all currently supported platforms, or select specific platforms for a focused email account lookup.

#### Structured JSON for workflows

Results are normalized for Apify datasets and APIs, making them easier to use in spreadsheets, CRMs, fraud review tools, internal dashboards, and AI workflows.

#### Batch-friendly email OSINT

Run one email or a larger list in the same input. Emails are normalized, deduplicated, and processed into clean per-email result items.

### ⚡ Quick Start

1. Add one or more email addresses.
2. Leave **Platforms to check** empty to check all supported platforms, or select only the sites you need.
3. Click **Start** and open the Dataset to review the results.

Minimal input:

```json
{
  "emails": ["test@example.com"]
}
```

`test@example.com` is a reserved example email address. For real runs, use only email addresses you own, have permission to investigate, or are otherwise allowed to process.

### Short Output Example

This is an example structure showing the shape of a successful result:

```json
{
  "email": "person@example.com",
  "platformsChecked": 121,
  "foundCount": 1,
  "notFoundCount": 42,
  "uncertainCount": 78,
  "rateLimitedCount": 68,
  "errorCount": 9,
  "timeoutCount": 0,
  "accounts": [
    {
      "platform": "office365",
      "domain": "office365.com",
      "emailRecovery": null,
      "phoneNumber": null,
      "others": null
    }
  ],
  "elapsedMs": 8271,
  "checkedAt": "2026-08-28T11:56:29.916997+00:00"
}
```

### Input

The public input is intentionally small. Runtime decisions such as timeout, concurrency, retry behavior, and proxy strategy are handled by the Actor.

| Field | Type | Required | Default | Description |
|---|---|---:|---|---|
| `emails` | array of strings | Yes | `["test@example.com"]` | One or more email addresses to check. Inputs are trimmed, lowercased, deduplicated, and validated. Maximum valid emails per run: `500`. |
| `selectedPlatforms` | array of strings | No | `[]` | Optional platform filter. Leave empty to check all currently supported platforms. Use values such as `github`, `instagram`, `office365`, or `spotify` for a targeted search. |
| `noPasswordRecovery` | boolean | No | `false` | Advanced option. Set to `true` to skip platforms that rely on password-recovery flows for account detection. Turning it on may reduce coverage. |

#### Platform selection logic

- If `selectedPlatforms` is empty or missing, the Actor checks **all currently supported platforms**.
- If `selectedPlatforms` contains platform names, the Actor checks **only those platforms**.
- If `noPasswordRecovery` is `true`, password-recovery-style checks are removed from the selected platform set.

### Input Examples

#### Check one email across all supported platforms

```json
{
  "emails": ["test@example.com"]
}
```

#### Check multiple emails

```json
{
  "emails": [
    "first@example.com",
    "second@example.com"
  ]
}
```

#### Check only selected platforms

```json
{
  "emails": ["test@example.com"],
  "selectedPlatforms": ["github", "instagram", "spotify"]
}
```

#### Skip password-recovery checks

```json
{
  "emails": ["test@example.com"],
  "noPasswordRecovery": true
}
```

### API Usage

Actor ID:

```text
lance_api/email-osint-account-finder
```

Use your own Apify token through the `APIFY_TOKEN` environment variable. Do not put tokens directly into source code.

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const input = {
  emails: ['test@example.com'],
  selectedPlatforms: ['github', 'office365'],
};

const run = await client.actor('lance_api/email-osint-account-finder').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("lance_api/email-osint-account-finder").call(
    run_input={
        "emails": ["test@example.com"],
        "selectedPlatforms": ["github", "office365"],
    }
)

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Output

Each valid input email produces exactly **one dataset item**.

Found accounts are returned inside `accounts`. The Actor does not create separate dataset rows for each found platform.

The default dataset views are:

- **Overview:** the main result view with the most useful fields first
- **All fields:** the complete dataset item

### Complete Output Field Reference

#### Core result fields

| Field | Type | Nullable | Description |
|---|---|---:|---|
| `email` | string | No | The normalized email address that was checked. |
| `platformsChecked` | integer | No | Number of platforms checked for this email. |
| `foundCount` | integer | No | Number of platforms that returned an account-existence signal. This equals `accounts.length`. |
| `notFoundCount` | integer | No | Number of platforms that clearly returned no account signal. |
| `uncertainCount` | integer | No | Number of checks that were not confirmed found or confirmed not found. |
| `rateLimitedCount` | integer | No | Number of platforms that reported a blocked or rate-limited response. |
| `errorCount` | integer | No | Number of platform checks that raised or returned an error. |
| `timeoutCount` | integer | No | Number of platform checks that exceeded the internal timeout. |
| `inconclusiveCount` | integer | No | Number of platform results that did not match a known result shape. |
| `accounts` | array | No | Found account signals for this email. Empty when no account signals were found. |
| `elapsedMs` | integer | No | Scan duration for this email, in milliseconds. |
| `checkedAt` | string | No | ISO 8601 timestamp when the email result was created. |

#### `accounts` array fields

| Field | Type | Nullable | Description |
|---|---|---:|---|
| `platform` | string | No | Platform name, such as `github`, `office365`, or `spotify`. |
| `domain` | string | Yes | Platform domain when available from the underlying module. |
| `emailRecovery` | string or null | Yes | Masked recovery email hint when returned by the platform. |
| `phoneNumber` | string or null | Yes | Masked phone recovery hint when returned by the platform. |
| `others` | object, array, string, or null | Yes | Additional non-standard information returned by a platform module, if any. |

### Status Values

The final dataset item does not include separate platform rows, but the Actor internally classifies every platform check into one of these statuses and rolls them into the count fields.

| Status | Meaning | Reflected in output | Per-result billing |
|---|---|---|---:|
| `FOUND` | A platform returned an account-existence signal. | Added to `accounts`; counted in `foundCount`. | No separate extra charge. |
| `NOT_FOUND` | A platform clearly did not return an account signal. | Counted in `notFoundCount`. | No separate extra charge. |
| `RATE_LIMITED` | The platform blocked or rate-limited the check. | Counted in `rateLimitedCount` and `uncertainCount`. | No separate extra charge. |
| `TIMEOUT` | The platform check exceeded the internal timeout. | Counted in `timeoutCount` and `uncertainCount`. | No separate extra charge. |
| `ERROR` | A platform module or request failed. | Counted in `errorCount` and `uncertainCount`. | No separate extra charge. |
| `INCONCLUSIVE` | The response did not match a known result shape. | Counted in `inconclusiveCount` and `uncertainCount`. | No separate extra charge. |

A single platform error does **not** stop the whole batch. Other platforms and other emails continue to run.

### Complete Output Example

This is an example structure. It uses reserved example data and should not be read as a claim that the example email owns these accounts.

```json
{
  "email": "person@example.com",
  "platformsChecked": 121,
  "foundCount": 2,
  "notFoundCount": 43,
  "uncertainCount": 76,
  "rateLimitedCount": 66,
  "errorCount": 9,
  "timeoutCount": 0,
  "inconclusiveCount": 1,
  "accounts": [
    {
      "platform": "office365",
      "domain": "office365.com",
      "emailRecovery": null,
      "phoneNumber": null,
      "others": null
    },
    {
      "platform": "twitter",
      "domain": "twitter.com",
      "emailRecovery": null,
      "phoneNumber": null,
      "others": null
    }
  ],
  "elapsedMs": 12661,
  "checkedAt": "2026-08-28T12:34:46.403634+00:00"
}
```

#### No accounts found example

```json
{
  "email": "person@example.com",
  "platformsChecked": 121,
  "foundCount": 0,
  "notFoundCount": 45,
  "uncertainCount": 76,
  "rateLimitedCount": 67,
  "errorCount": 9,
  "timeoutCount": 0,
  "inconclusiveCount": 0,
  "accounts": [],
  "elapsedMs": 8123,
  "checkedAt": "2026-08-28T12:35:10.100000+00:00"
}
```

### 💳 Pricing

This Actor uses **pay-per-result pricing**.

The configured billing event is `result`, charged once for each valid email address that produces one dataset result item.

**Base price:** `$0.006` per email result, or **$6.00 per 1,000 email results**.

Simple billing examples:

- **1 email checked → 1 `result` charge**
- **1 email checked with 5 found accounts → still 1 `result` charge**
- **100 valid emails checked → up to 100 `result` charges**
- Platform-level rate limits, timeouts, errors, and multiple found accounts do **not** create extra result charges.

Eligible Apify plan pricing may reduce the effective per-result price shown in the Actor's Pricing tab. Check the Pricing tab before running for the exact price available to your account.

To control cost, run a smaller list of emails first or use `selectedPlatforms` for targeted checks.

### 🎯 Use Cases

#### Email OSINT research

Run repeatable email OSINT checks from the Apify Console or API and export one clean result item per email for analysis.

#### Account discovery

Find public account-existence signals linked to an email address across supported platforms, then review the results as leads rather than identity proof.

#### Fraud & risk review

Add email account signals to manual risk reviews, onboarding checks, abuse investigations, or fraud triage workflows.

#### Trust & safety investigations

Separate found, not found, and uncertain checks so blocked or inconclusive platforms do not get treated as confirmed negatives.

#### CRM & data enrichment

Add lightweight public account context to permitted CRM records and enrichment pipelines using structured JSON.

#### API & AI workflows

Call the Actor from scripts, internal tools, dashboards, or AI agents that need an email account finder API.

### How It Works

1. The Actor validates, normalizes, and deduplicates the input emails.
2. It builds the current supported platform list from the underlying account-check modules.
3. It checks either all supported platforms or only the platforms selected in `selectedPlatforms`.
4. Each platform result is classified as found, not found, rate-limited, timed out, error, or inconclusive.
5. The Actor returns one final dataset item per email, with found accounts nested under `accounts`.

The Actor uses the open-source [Holehe](https://github.com/megadose/holehe) engine under the hood and normalizes the results for Apify datasets and APIs.

### Public Data and Responsible Use

Use this Actor only for email addresses you own, have permission to investigate, or are otherwise allowed to process.

This Actor is designed for public account-existence signals. It does not access private accounts, bypass authentication, retrieve passwords, read inboxes, or verify that an email address is deliverable.

You are responsible for complying with website terms, Apify terms, privacy laws, anti-spam rules, and any rules that apply to your use case. Do not use this Actor for harassment, spam, illegal profiling, or attempts to obtain non-public information.

### FAQ

#### Can I find accounts linked to an email address?

The Actor can check supported platforms and return public account-existence signals linked to an email address. Results do not prove account ownership, identity, or control of the email.

#### Can I find social media accounts by email?

The Actor can check currently supported platforms that return account-existence signals. Not every social platform supports email-based detection, and some checks may be rate-limited, blocked, or inconclusive.

#### What does a found account mean?

`FOUND` means a supported platform returned an account-existence signal for the email address. It does not prove identity, ownership, intent, or deliverability.

#### Does one email produce multiple dataset rows?

No. Each valid email produces exactly **one dataset item**. Multiple found platforms are listed inside the `accounts` array.

#### What happens when no accounts are found?

The Actor still returns one dataset item for that email with `foundCount` set to `0` and `accounts` set to an empty array.

#### Why is `uncertainCount` sometimes high?

Some websites block checks, rate-limit traffic, change their pages, time out, or return responses that cannot be interpreted reliably. Those checks are counted as uncertain instead of being treated as confirmed not-found results.

#### Can I check only a few platforms?

Yes. Use `selectedPlatforms` and provide platform values such as `github`, `instagram`, `office365`, or `spotify`. Leave it empty to check all currently supported platforms.

#### Does this verify whether an email address can receive mail?

No. This Actor does not perform email deliverability verification, SMTP checks, inbox checks, or email validation beyond input format validation.

#### How are results billed?

The `result` event is charged once per valid email result item. Multiple found accounts for the same email do not create extra result charges.

#### Does one failed platform stop the whole run?

No. A platform-level error is counted in the result summary, and the Actor continues checking other platforms and other emails.

### Limitations

- Public websites can change their flows at any time.
- Some platforms may block, rate-limit, time out, error, or return inconclusive responses.
- Recovery hints such as `emailRecovery` and `phoneNumber` are only returned when a platform provides masked values.
- `domain` and `others` may be `null` depending on the platform result.
- The Actor does not verify email deliverability.
- The Actor does not search breach databases.
- The Actor does not retrieve private profile data, passwords, inbox content, tokens, cookies, or session data.
- Results should be treated as leads or signals that may require human review.

### Support

For support, contact **lanceapi2026@hotmail.com** or open an issue on the Actor's Issues page.

When reporting a problem, include the Run ID, non-sensitive example input, relevant status counts, and any error message shown in the run log. Do not send Apify tokens, cookies, passwords, private keys, or other secrets.

# Actor input Schema

## `emails` (type: `array`):

Enter one or more email addresses to check for registered accounts across supported platforms.

## `selectedPlatforms` (type: `array`):

Optional. Leave empty to check all available platforms, or select specific platforms to run a targeted search.

## `noPasswordRecovery` (type: `boolean`):

Optional advanced setting. Enable this to skip platforms that rely on password-recovery flows to check whether an account exists. This may reduce account coverage.

## Actor input object example

```json
{
  "emails": [
    "test@example.com"
  ],
  "selectedPlatforms": [],
  "noPasswordRecovery": false
}
```

# Actor output Schema

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

Open the default dataset to review normalized email account lookup results.

# 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 = {
    "emails": [
        "test@example.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lance_api/email-osint-account-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 = { "emails": ["test@example.com"] }

# Run the Actor and wait for it to finish
run = client.actor("lance_api/email-osint-account-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 '{
  "emails": [
    "test@example.com"
  ]
}' |
apify call lance_api/email-osint-account-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lance_api/email-osint-account-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/FWruW6aCbncKkXmdb/builds/Xv0vVll4tBHTHOJCZ/openapi.json