# Holehe Email OSINT — Email Finder & Digital Footprint Mapper (`datacach/holehe-email-osint-scraper`) Actor
50% Cheaper Silent email OSINT: instantly check 120+ platforms (Instagram, GitHub, Twitter, Discord, Spotify, Amazon…) for registered accounts without notifying the target. Results include category breakdown, masked recovery emails, and partial phone numbers.
- **URL**: https://apify.com/datacach/holehe-email-osint-scraper.md
- **Developed by:** [DataCach](https://apify.com/datacach) (community)
- **Categories:** Developer tools, Other, Social media
- **Stats:** 8 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet
## Pricing
from $5.00 / 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/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
## Holehe Email OSINT — Find Accounts Registered to Any Email Address
**Instantly discover which of 120+ platforms an email address has a registered account on** — without sending any alert, notification, or password-reset email to the target inbox. Built on the battle-tested open-source [Holehe](https://github.com/megadose/holehe) engine, this Actor delivers structured, categorized OSINT results in seconds via the Apify platform.
Whether you're running a security assessment, verifying a lead's digital footprint, or conducting an authorized OSINT investigation, this tool gives you precise, actionable intelligence across social networks, developer tools, e-commerce platforms, and more — all in one API call.
---
### What Data Does This Actor Extract?
Each email check returns a fully structured JSON record with per-platform results **grouped by category**, masked recovery data, and a clean summary array:
| Field | Description |
|---|---|
| `email` | The email address that was checked |
| `checkedAt` | ISO 8601 UTC timestamp of the scan |
| `totalChecked` | Total platforms scanned (120+) |
| `accountsFound` | Number of confirmed registered accounts |
| `rateLimited` | Platforms that throttled the request |
| `errors` | Platforms that returned unexpected errors |
| `accountsFoundByCategory` | Account count broken down by category (social, developer, ecommerce…) |
| `results[].name` | Platform name (e.g., `github`, `spotify`) |
| `results[].domain` | Platform domain |
| `results[].category` | Category: `social`, `developer`, `ecommerce`, `entertainment`, etc. |
| `results[].method` | Detection method used (`password_recovery` or other) |
| `results[].exists` | `true` if an account was found |
| `results[].emailrecovery` | Masked recovery email (if exposed by platform) |
| `results[].phoneNumber` | Partial phone number (if exposed by platform) |
| `results[].rateLimit` | `true` if this platform rate-limited the check |
| `results[].others` | Any additional data the platform returned |
| `summary.found` | Array of platform names where account was confirmed |
| `summary.notFound` | Array of platform names with no account |
| `summary.rateLimited` | Array of rate-limited platform names |
| `summary.errors` | Array of platform names that errored |
---
### Which Platforms Does This Actor Check?
The Actor checks **120+ platforms** in parallel using async HTTP requests, organized into categories:
**Social Networks** — Instagram, Twitter/X, Facebook, TikTok, Snapchat, Pinterest, Reddit, Tumblr, Flickr, VK, and more
**Developer & Tech** — GitHub, GitLab, Stack Overflow, Docker Hub, npm, Bitbucket, Gravatar, Keybase, and more
**E-Commerce** — Amazon, eBay, Etsy, AliExpress, and more
**Entertainment & Gaming** — Spotify, Twitch, Steam, Discord, Deezer, and more
**Productivity & Other** — Slack, Notion, Codecademy, Duolingo, LastFM, and more
---
### How to Use This Actor
#### Step 1 — Open the Actor on Apify
Go to the Actor's page and click **Try for free**. You don't need to install anything — the Actor runs entirely in the cloud.
#### Step 2 — Enter the Target Email
In the **Input** tab, fill in the `email` field with the address you want to investigate. All other inputs are optional.
#### Step 3 — Configure Optional Settings
| Input Field | Type | Default | Description |
|---|---|---|---|
| `email` | String | — | **Required.** The email address to check |
| `onlyUsed` | Boolean | `true` | Return only platforms where an account was found (set to `false` for full results) |
| `noPasswordRecovery` | Boolean | `false` | Skip checks that rely on the password-recovery flow |
| `timeout` | Integer | `30` | Per-request timeout in seconds (10–120) |
| `modules` | Array of strings | — | Restrict the scan to specific platform names (e.g., `["github", "spotify"]`) |
#### Step 4 — Run and Download Results
Click **Start** and wait 2–5 minutes. Results appear in the **Dataset** tab and are downloadable as JSON, CSV, or Excel. You can also retrieve them via the [Apify API](https://docs.apify.com/api/v2).
---
### Example Output
Input:
```json
{
"email": "test@example.com",
"onlyUsed": true
}
````
Output (single dataset item):
```json
{
"email": "test@example.com",
"checkedAt": "2025-06-01T14:32:00.000Z",
"totalChecked": 123,
"accountsFound": 7,
"rateLimited": 2,
"errors": 1,
"accountsFoundByCategory": {
"social": 3,
"developer": 2,
"entertainment": 1,
"ecommerce": 1
},
"results": [
{
"name": "github",
"domain": "github.com",
"category": "developer",
"method": "register",
"exists": true,
"emailrecovery": null,
"phoneNumber": null,
"rateLimit": false,
"others": null
},
{
"name": "spotify",
"domain": "spotify.com",
"category": "entertainment",
"method": "register",
"exists": true,
"emailrecovery": "t***@g***.com",
"phoneNumber": null,
"rateLimit": false,
"others": null
}
],
"summary": {
"found": ["github", "spotify", "twitter", "instagram", "reddit", "amazon", "duolingo"],
"notFound": ["gitlab", "docker", "etsy"],
"rateLimited": ["facebook", "tiktok"],
"errors": ["npm"]
}
}
```
#### What Makes Our Output Better
Unlike tools that return only a flat list of platform names, this Actor also provides:
- **`accountsFoundByCategory`** — immediately see whether the target is primarily a developer, a social media user, or a gamer, without parsing individual results
- **`method` field** — understand *how* each account was detected, important for audit trails in authorized investigations
- **`checkedAt` timestamp** — every scan is time-stamped in ISO 8601 UTC, ready for logging or compliance records
- **Module filtering** — target only the platforms that matter for your investigation instead of scanning all 120+
***
### Use Cases
#### OSINT Investigations and Security Assessments
Map the complete digital footprint of an email address during a penetration test or threat-intelligence engagement. Identify exposed recovery emails and partial phone numbers that can inform further research.
#### Lead Enrichment and Sales Intelligence
Before a cold outreach, discover which professional platforms a prospect is active on. A lead with active GitHub and Stack Overflow accounts signals a developer persona; route them to the right sales sequence automatically.
#### Background Checks and Due Diligence
Verify the online presence of contractors, freelancers, or business partners as part of a due-diligence workflow. Connect this Actor to Zapier, Make, or n8n to automate the process at scale.
#### Account Recovery and Digital Forensics
Identify where an email address has been used as part of an account recovery workflow — for example, finding all accounts associated with a compromised email.
#### Fraud Detection and Identity Verification
Cross-reference suspicious email addresses against known platform patterns to identify newly created or throwaway accounts that lack a typical digital footprint.
***
### How Much Does It Cost to Run This Actor?
This Actor uses a simple **pay-per-result** model: **$5.00 per 1,000 email scans** — half the price of comparable tools.
| Volume | Cost |
|---|---|
| 100 emails | $0.50 |
| 1,000 emails | $5.00 |
| 10,000 emails | $50.00 |
| 100,000 emails | $500.00 |
**Platform usage (compute) is included** — you pay only the per-result fee above, nothing else. No compute unit charges, no hidden costs.
> **Tip:** Use the `modules` input to restrict the scan to only the platforms you care about — this reduces runtime and delivers results faster.
***
### Integrate With Your Stack
#### API Access
Every Apify Actor exposes a REST API. Trigger a scan programmatically:
```python
import requests
run = requests.post(
"https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs",
headers={"Authorization": "Bearer YOUR_API_TOKEN"},
json={"email": "target@example.com", "onlyUsed": True}
).json()
print(run["data"]["id"]) ## Run ID to poll for results
```
#### No-Code Automation
Connect this Actor to your existing workflows without writing code:
- **[Zapier](https://zapier.com/apps/apify/integrations)** — trigger on new CRM contacts, webhook events, or form submissions
- **[Make (Integromat)](https://www.make.com/en/integrations/apify)** — build multi-step automation with conditional branching on account count
- **[n8n](https://n8n.io/integrations/apify/)** — self-hosted workflow automation with full JSON output access
#### MCP / AI Agent Integration
This Actor is compatible with the **Apify MCP Server**, meaning you can invoke it directly from Claude, ChatGPT, Cursor, or any LLM agent that supports the Model Context Protocol — no separate API call needed.
***
### Frequently Asked Questions
#### Does this Actor send any email to the target?
No. The Holehe engine checks platform registration forms and password-recovery endpoints using techniques that **do not trigger any notification** to the target's inbox. The target has no way of knowing a check was performed.
#### Is it legal to use this tool?
The legality depends entirely on your jurisdiction and your authorization to investigate the target email. This tool is intended exclusively for:
- Authorized security assessments (penetration testing with written consent)
- OSINT research on your own accounts
- Law enforcement and legal investigations with proper authority
- Academic and educational research
You are responsible for complying with applicable laws including GDPR, CCPA, DPDP, and the Computer Fraud and Abuse Act (CFAA). **Do not use this tool to investigate email addresses you do not have authorization to investigate.**
#### How is this different from an email validator?
Email validators (syntax checks, MX record lookups, SMTP pings) tell you whether an email *address exists*. This Actor tells you *where that address has registered accounts* — a fundamentally different and more powerful capability for OSINT and digital footprint mapping.
#### Some platforms show as rate-limited. What does that mean?
When a platform throttles repeated requests, the Actor marks it as `rateLimit: true` in the results and includes it in `summary.rateLimited`. It does **not** count as a confirmed account. Re-run the Actor after a few minutes to get cleaner results for those platforms.
#### Can I scan multiple emails at once?
Currently each Actor run processes one email. To scan multiple emails in bulk, use the [Apify Scheduler](https://docs.apify.com/platform/schedules) or call the API in a loop from your own script. Batch support is on the roadmap.
#### Why are some platforms missing from my results?
If you used the `modules` input to filter specific platforms, only those will appear. If a platform is missing from a full scan, it may have been removed from the Holehe module list due to a breaking change on the platform's side. Open an issue if you notice a specific platform consistently missing.
***
### About the Holehe Engine
This Actor is built on [Holehe](https://github.com/megadose/holehe) by [@megadose](https://github.com/megadose), an open-source Python tool released under the MIT License. The Apify layer adds:
- Cloud execution with no local setup
- Structured, categorized JSON output (including `accountsFoundByCategory` and per-result `category` and `method` fields)
- REST API and webhook delivery
- No-code integrations (Zapier, Make, n8n)
- Scheduling, monitoring, and run history via the Apify console
***
### Support and Issues
- **Bug reports / feature requests**: Open an issue via the **Issues** tab on this Actor's page
- **Questions**: Use the **Community** tab or reach out through the Apify Discord
- **Email**: Contact the actor developer through your Apify account
If you find this Actor useful, please leave a **star and a review** — it helps other users discover it.
# Actor input Schema
## `email` (type: `string`):
Enter the email address you want to investigate. The Actor will check it across 120+ platforms and return a categorized report of where an account exists.
## `onlyUsed` (type: `boolean`):
When enabled, the results array contains only platforms where the email has a confirmed account. Disable to receive the full list of all 120+ platforms checked (useful for audits and logs).
## `noPasswordRecovery` (type: `boolean`):
Some platforms (Adobe, Mail.ru, Odnoklassniki, Samsung) are detected via the password-recovery flow. Enable this to exclude those platforms from the scan — for example, if your use case requires avoiding any password-reset traffic.
## `timeout` (type: `integer`):
Set the maximum wait time per HTTP request. Increase this if you see many errors on slow platforms; decrease it to speed up scans at the cost of more timeouts.
## `modules` (type: `array`):
Add specific platform names (e.g. github, spotify, twitter) to restrict the scan to only those platforms. Leave empty to scan all 120+ platforms. Platform names must match the internal Holehe module names (lowercase, no spaces).
## Actor input object example
```json
{
"email": "example@domain.com",
"onlyUsed": true,
"noPasswordRecovery": false,
"timeout": 30
}
```
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"email": "example@domain.com",
"timeout": 30
};
// Run the Actor and wait for it to finish
const run = await client.actor("datacach/holehe-email-osint-scraper").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"email": "example@domain.com",
"timeout": 30,
}
# Run the Actor and wait for it to finish
run = client.actor("datacach/holehe-email-osint-scraper").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 '{
"email": "example@domain.com",
"timeout": 30
}' |
apify call datacach/holehe-email-osint-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=datacach/holehe-email-osint-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Holehe Email OSINT — Email Finder & Digital Footprint Mapper",
"description": "50% Cheaper Silent email OSINT: instantly check 120+ platforms (Instagram, GitHub, Twitter, Discord, Spotify, Amazon…) for registered accounts without notifying the target. Results include category breakdown, masked recovery emails, and partial phone numbers.",
"version": "0.1",
"x-build-id": "fbMeJ8Ur3yLsOJXXz"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/datacach~holehe-email-osint-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-datacach-holehe-email-osint-scraper",
"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/datacach~holehe-email-osint-scraper/runs": {
"post": {
"operationId": "runs-sync-datacach-holehe-email-osint-scraper",
"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/datacach~holehe-email-osint-scraper/run-sync": {
"post": {
"operationId": "run-sync-datacach-holehe-email-osint-scraper",
"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": [
"email"
],
"properties": {
"email": {
"title": "📧 Target email address",
"type": "string",
"description": "Enter the email address you want to investigate. The Actor will check it across 120+ platforms and return a categorized report of where an account exists."
},
"onlyUsed": {
"title": "Show confirmed accounts only",
"type": "boolean",
"description": "When enabled, the results array contains only platforms where the email has a confirmed account. Disable to receive the full list of all 120+ platforms checked (useful for audits and logs).",
"default": true
},
"noPasswordRecovery": {
"title": "Skip password-recovery checks",
"type": "boolean",
"description": "Some platforms (Adobe, Mail.ru, Odnoklassniki, Samsung) are detected via the password-recovery flow. Enable this to exclude those platforms from the scan — for example, if your use case requires avoiding any password-reset traffic.",
"default": false
},
"timeout": {
"title": "⏱ Request timeout (seconds)",
"minimum": 10,
"maximum": 120,
"type": "integer",
"description": "Set the maximum wait time per HTTP request. Increase this if you see many errors on slow platforms; decrease it to speed up scans at the cost of more timeouts.",
"default": 30
},
"modules": {
"title": "🎯 Platforms to scan",
"type": "array",
"description": "Add specific platform names (e.g. github, spotify, twitter) to restrict the scan to only those platforms. Leave empty to scan all 120+ platforms. Platform names must match the internal Holehe module names (lowercase, no spaces).",
"items": {
"type": "string"
}
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```