# Email Account Finder | Email OSINT Lookup (`arjun_code/email-account-presence`) Actor

Find account-registration signals for an email address across 78 default websites. Export positive matches and available public details to JSON or CSV, with separate diagnostics for unresolved checks.

- **URL**: https://apify.com/arjun\_code/email-account-presence.md
- **Developed by:** [Arjun AI](https://apify.com/arjun_code) (community)
- **Categories:** Social media
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 email checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### Find accounts linked to an email address

Email Account Finder checks an email address for account-registration signals across **78 default websites**. It returns positive matches as structured Dataset rows and keeps non-matches, blocked requests, and skipped checks in a separate run summary.

Use it to review your own digital footprint, support an authorized investigation, or add email-account checks to an Apify workflow. No mailbox password or login is required. A positive signal is a lead to review; it is not proof of account ownership or identity.

### What can Email Account Finder do?

- Check one email or a batch of addresses, with duplicate removal.
- Scan all 78 default websites or choose a focused website list.
- Return only positive registration signals in the main Dataset.
- Preserve available public details and media when a website provides them.
- Separate `Registered`, `Not Registered`, `Error`, and `Skipped` outcomes.
- Export results as JSON, CSV, or Excel.
- Run through the Apify Console, API, schedules, integrations, or webhooks.

This Actor checks a complete email address that you provide. It does not discover an email from a person's name, verify mailbox deliverability, or search breach and password databases.

### How to check an email address

1. Enter one or more complete email addresses you own or are authorized to check.
2. Leave **Websites to check** empty for the default 78-site scan, or select specific websites for a faster, focused lookup.
3. Run the Actor.
4. Open **Registration signals** for positive matches.
5. Open **Search summary** when you need non-matches, errors, skipped checks, and billing details.

#### Quick-check input

Replace the placeholder before running:

```json
{
  "emails": ["your-email@example.com"],
  "sites": ["Spotify", "Duolingo", "Quizlet", "Adobe"],
  "timeoutSeconds": 30,
  "maxConcurrency": 5
}
```

For the full default scan, omit `sites` or set it to an empty array:

```json
{
  "emails": ["your-email@example.com"],
  "sites": []
}
```

### Input parameters

| Parameter | Default | Description |
| --- | --- | --- |
| `emails` | Required | Complete email addresses. Surrounding spaces are removed and normalized duplicates are checked once. |
| `sites` | `[]` | Empty uses the 78-site default set. Add website names for a focused scan; names are case-insensitive. |
| `timeoutSeconds` | `30` | Maximum time for one website check, including automatic retries. |
| `maxConcurrency` | `5` | Number of websites checked concurrently for each email. Emails are processed in input order. |

### Website coverage

The default scan covers 78 account services across social media, publishing, developer tools, education, entertainment, shopping, travel, productivity, and online communities.

Examples include Spotify, Pinterest, Gravatar, Canva, Dropbox, Duolingo, Etsy, Figma, HackerRank, Hugging Face, Patreon, Freelancer, Deezer, Coursera, Chess.com, Vimeo, Quizlet, Last.fm, CodePen, Internet Archive, Adobe, Tumblr, and Wattpad.

Leave `sites` empty to use the maintained default set. The input selector can also show paused or experimental integrations that are not part of the 78-site default scan. When explicitly selected, a paused integration returns `Skipped` instead of being presented as a negative account result.

Websites can change their login flows, impose rate limits, or require a CAPTCHA. Individual checks can therefore be unresolved even when the overall run succeeds.

### Results

#### Registration signals

The main Dataset contains only `Registered` results. Each row represents one positive email-and-website signal.

```json
{
  "email": "[REDACTED]",
  "site_name": "Spotify",
  "status": "Registered",
  "category": "Music",
  "url": "https://spotify.com",
  "extra": {},
  "media": {},
  "reason": "",
  "checkedAt": "2026-09-08T08:37:30.816061+00:00"
}
```

`[REDACTED]` is used only in this documentation sample. Your private run contains the normalized input email.

| Field | Description |
| --- | --- |
| `email` | Normalized input email. |
| `site_name` | Website or account-service name. |
| `status` | `Registered` for rows in the main Dataset. |
| `category` | Website category supplied by the integration. |
| `url` | Source URL, which can be a service homepage rather than a personal profile. |
| `extra` | Available public details; structure varies by website and can be empty. |
| `media` | Available media links; can be empty. |
| `reason` | Additional explanation when available. |
| `checkedAt` | ISO 8601 check timestamp. |

Many services reveal an account signal without exposing a public profile. Empty `extra` or `media` fields are therefore valid and do not cancel the registration signal.

#### Search summary

The **Search summary** output contains selected websites, per-email counts, exclusions, billing information, and every outcome not placed in the positive-results Dataset.

| Outcome | Meaning |
| --- | --- |
| `Registered` | A positive signal was detected. Review the matching Dataset row. |
| `Not Registered` | The selected lookup returned a negative signal. It is not proof that no account exists elsewhere. |
| `Error` | The check could not complete reliably because of blocking, a timeout, or an unexpected response. |
| `Skipped` | No account conclusion was made for this integration. |

An empty Dataset does not prove that the email has no accounts. Always review **Search summary** to distinguish negative results from unresolved checks.

### Pricing

| Usage | Email-check charge |
| --- | ---: |
| 1 unique email | $0.02 |
| 10 unique emails | $0.20 |
| 100 unique emails | $2.00 |

The email-check event is charged once per unique email after its scan report is saved and at least one selected website returns `Registered` or `Not Registered`. There is no additional charge per website or match found. Invalid inputs and checks containing only `Error` or `Skipped` outcomes do not create an email-check event.

Apify also applies its standard Actor Start charge. At 1 GB of memory or less, one email check plus startup is currently $0.02005, so a one-email run needs a charge limit of at least $0.03. Review the active prices in Apify Console before running.

### Use the API

The same input works with the Apify API and clients:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_API_TOKEN"])
run = client.actor("arjun_code/email-account-presence").call(
    run_input={
        "emails": ["your-email@example.com"],
        "sites": ["Spotify", "Duolingo", "Quizlet", "Adobe"],
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

Use the run's `defaultKeyValueStoreId` to retrieve the `OUTPUT` summary. Saved Tasks can preserve common website selections, while schedules, integrations, and webhooks can connect authorized checks to an existing workflow.

### Frequently asked questions

#### Does a match prove who owns the account?

No. It reports an account-registration signal for the supplied email. It does not verify ownership, control, or identity.

#### Why can a positive result have no profile fields?

Many websites expose a registration signal without returning a public profile. Available details vary by service.

#### Does the Actor solve CAPTCHAs?

No. Eligible requests use automatic proxy retries, but retries cannot guarantee access. Blocked or unresolved checks remain visible in **Search summary**.

#### Does it create accounts or send password-reset emails?

The maintained lookup paths do not invoke account creation, password resets, or email-notification workflows.

### Responsible use and support

Check only addresses you own or have permission to investigate. Results can contain personal data, so limit access and sharing to the authorized purpose.

When reporting a problem, include the affected website and Apify run ID, but do not post email addresses, API tokens, private inputs, or complete result records publicly.

The Actor incorporates established open-source account-discovery components. Their attribution and license notices are retained in the Actor package.

# Actor input Schema

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

One or more complete email addresses you own or are authorized to check. Replace the example.com placeholder in the JSON example before running. Surrounding whitespace is removed and normalized duplicates are checked once. No mailbox login is required.

## `sites` (type: `array`):

Leave empty to check the 78 default websites, or select specific websites for a smaller scan. Paused entries return Skipped with an explanation. Hack The Box, Flickr and Moz are experimental, explicit-only options and are not part of default coverage. See Search summary for unresolved checks and exclusions.

## `timeoutSeconds` (type: `integer`):

Maximum time to wait for a website check, including automatic retries. Individual requests may time out sooner. Start with 30 seconds.

## `maxConcurrency` (type: `integer`):

How many selected websites to check concurrently for one email address. Email addresses are processed in input order.

## Actor input object example

```json
{
  "emails": [
    "your-email@example.com"
  ],
  "sites": [],
  "timeoutSeconds": 30,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `accounts` (type: `string`):

Positive registration signals with native available details. A source URL may be the website homepage rather than an account profile.

## `summary` (type: `string`):

Selected websites, per-email counts, non-matches, errors and skipped checks.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("arjun_code/email-account-presence").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("arjun_code/email-account-presence").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 '{}' |
apify call arjun_code/email-account-presence --silent --output-dataset

```

## MCP server setup

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

```

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/O4thC8QTvzSQFuLdn/builds/mR4x9ghEmbHu47gS8/openapi.json