# Email Account Footprint Scanner – Authorized OSINT (`automation-lab/email-account-footprint-scanner`) Actor

Map authorized email addresses across public account-registration signals from over 100 services. Export deterministic service matches, statuses, methods, rate limits, and available masked recovery hints.

- **URL**: https://apify.com/automation-lab/email-account-footprint-scanner.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.56 / 1,000 email scanneds

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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Email Account Footprint Scanner

Map the public account footprint of email addresses you own or are explicitly authorized to investigate.

This Actor checks anonymous registration, sign-in, and recovery signals across more than 100 online services. It returns structured evidence for security reviews, fraud investigations, trust-and-safety operations, and authorized OSINT workflows.

> **Authorized use only:** account-existence signals are personal data. Do not use this Actor for stalking, harassment, credential attacks, unsolicited profiling, or decisions that require verified identity evidence.

### What does Email Account Footprint Scanner do?

The Actor sends an email address to selected public account-state checks from the maintained Holehe module library.

For each service, it can report:

- ✅ whether the public response indicates an account;
- 🌐 the service and domain checked;
- 🔍 the registration, login, or recovery method used;
- 🚦 rate-limit and adapter status;
- 🕒 a consistent scan timestamp;
- 🔒 masked recovery email or phone hints when the public response includes them;
- ⚠️ isolated error records when a service changes or times out.

One changed website does not fail the rest of the scan.

### Who is it for?

#### Security teams

Audit company-controlled addresses for unexpected account exposure during attack-surface reviews.

#### Fraud and trust-and-safety analysts

Compare public account-footprint signals during an authorized case review. Treat each match as a lead, not proof of identity.

#### Incident responders

Map services associated with an affected organizational address and prioritize manual follow-up.

#### Authorized OSINT practitioners

Run repeatable, exportable checks instead of manually visiting registration forms.

#### Privacy teams and individuals

Review the public footprint of addresses they control as part of a digital exposure audit.

### Why use this Actor?

- **Batch input:** scan up to 20 unique addresses in one run.
- **Broad coverage:** discover over 100 maintained Holehe service adapters.
- **Stable records:** keep not-found, rate-limited, and error evidence when `onlyFound` is disabled.
- **Focused scans:** allow-list, deny-list, or filter by service category.
- **Safer defaults:** password-recovery-based adapters are disabled unless explicitly enabled.
- **Predictable billing:** pay once per email scan, not once per output row.
- **Export-ready:** download JSON, CSV, Excel, XML, or connect the dataset through the Apify API.
- **Private logs:** email local parts are redacted in run logs.

### Quick start

1. Open the Actor input page.
2. Enter one or more addresses you are authorized to assess.
3. Keep the small prefilled service list for a fast first run, or clear it to scan all available services.
4. Leave **Confirmed accounts only** disabled when you need complete audit evidence.
5. Start the run.
6. Review the **Email footprint evidence** dataset view.
7. Export or integrate the result.

### Input

| Field | Type | Default | Purpose |
|---|---|---:|---|
| `emails` | string[] | required | One to 20 authorized email addresses |
| `onlyFound` | boolean | `false` | Save only confirmed account signals when enabled |
| `includeServices` | string[] | small prefill | Run only named service IDs; empty means all |
| `excludeServices` | string[] | `[]` | Skip named service IDs |
| `includeCategories` | string[] | `[]` | Run only selected Holehe categories |
| `includePasswordRecovery` | boolean | `false` | Opt in to recovery-form adapters |
| `serviceTimeoutSecs` | integer | `10` | Timeout for one service adapter, from 2 to 30 seconds |
| `maxConcurrency` | integer | `20` | Concurrent checks per email, from 1 to 40 |

Service IDs are lowercase module names such as `amazon`, `github`, `spotify`, `twitter`, and `firefox`.

Example categories include `social_media`, `shopping`, `software`, `programing`, `music`, `productivity`, and `crm`.

### Example input: focused audit

```json
{
  "emails": ["analyst-owned@example.com"],
  "includeServices": ["amazon", "github", "spotify"],
  "onlyFound": false,
  "serviceTimeoutSecs": 10,
  "maxConcurrency": 10
}
````

Clear `includeServices` to use every available adapter.

### Example input: batch positives only

```json
{
  "emails": [
    "first-authorized@example.com",
    "second-authorized@example.org"
  ],
  "onlyFound": true,
  "excludeServices": ["pornhub", "redtube", "xvideos", "xnxx"],
  "includePasswordRecovery": false
}
```

Use full-output mode when audit reproducibility matters more than a compact result.

### Output data

Each dataset item represents one service check for one input email.

| Field | Type | Description |
|---|---|---|
| `email` | string | Normalized input email |
| `service` | string | Holehe service ID |
| `domain` | string | Public domain checked |
| `category` | string | Holehe module category |
| `method` | string | `register`, `login`, `password`, or adapter-specific method |
| `exists` | boolean | Whether the response indicated an account |
| `rateLimit` | boolean | Whether the adapter reported rate limiting |
| `status` | string | `found`, `not_found`, `rate_limited`, or `error` |
| `emailRecovery` | string | Optional masked recovery email |
| `phoneNumber` | string | Optional masked phone number |
| `otherHints` | any | Optional public service-specific hints |
| `errorMessage` | string | Optional bounded adapter error |
| `checkedAt` | string | UTC ISO timestamp for the email scan |

### Example output

```json
{
  "email": "analyst-owned@example.com",
  "service": "amazon",
  "domain": "amazon.com",
  "category": "shopping",
  "method": "login",
  "exists": true,
  "rateLimit": false,
  "status": "found",
  "checkedAt": "2026-07-15T03:40:39.345891Z"
}
```

A `found` row is a public signal, not independently verified ownership or identity evidence.

### How much does it cost to scan an email footprint?

The Actor uses pay-per-event pricing:

- **Start:** $0.005 once per run.
- **Email scanned:** tiered by your Apify plan; the current BRONZE rate is $0.0042702 per completed email scan.

A one-email run at the BRONZE rate is approximately $0.00927 before any platform-specific credits. Output mode and the number of dataset rows do not change the per-email event count.

The live pricing table in Apify Console is authoritative and may include lower rates on higher plans.

### Understanding statuses

#### `found`

The service response matched the adapter's account-existence condition.

#### `not_found`

The adapter completed and did not observe its account-existence condition.

#### `rate_limited`

The service refused, throttled, or changed the expected response. Retry later or interpret the record as inconclusive.

#### `error`

The adapter timed out, returned no result, or no longer matched its expected form. Other services still complete.

Do not convert `rate_limited` or `error` into `not_found` in downstream decisions.

### Service filters and categories

`includeServices` is an allow list. When it is non-empty, only those service IDs are eligible.

`excludeServices` is then applied to the eligible set.

`includeCategories` can narrow that set further.

If all filters together select zero services, the Actor fails early with a clear input error instead of charging for an empty scan.

### Password-recovery safety

Most adapters use registration or sign-in responses.

A small set of Holehe modules uses public password-recovery forms. They are excluded by default through `includePasswordRecovery: false`.

Enabling the option does not intentionally request that reset messages be sent, but third-party behavior can change. Use it only when your authorization and operating procedure permit recovery-form checks.

### Reliability and rate limits

Public forms change without notice.

The Actor therefore:

- pins the Holehe release used by the build;
- limits concurrent requests;
- enforces a timeout for every service;
- reuses HTTP connections within one email scan;
- isolates each adapter failure;
- sorts rows deterministically by service;
- returns explicit status metadata.

For a recurring audit, compare statuses over time and retry only inconclusive services rather than assuming completeness.

### Tips for accurate investigations

- Start with a focused service allow list while designing your workflow.
- Disable `onlyFound` when evidence of attempted coverage matters.
- Keep password-recovery checks disabled unless they are explicitly in scope.
- Treat account matches as leads that require corroboration.
- Record authorization and case purpose outside the dataset.
- Avoid scanning large batches against the same services repeatedly.
- Preserve `checkedAt`, `status`, and `method` in downstream systems.

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~email-account-footprint-scanner/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "emails": ["authorized@example.com"],
    "includeServices": ["amazon", "github", "spotify"],
    "onlyFound": false
  }'
```

Poll the returned run ID, then fetch items from its default dataset.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/email-account-footprint-scanner').call({
  emails: ['authorized@example.com'],
  includeServices: ['amazon', 'github', 'spotify'],
  onlyFound: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/email-account-footprint-scanner').call(run_input={
    'emails': ['authorized@example.com'],
    'onlyFound': True,
    'includePasswordRecovery': False,
})

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

### MCP integration

Use the Actor as a tool from MCP-compatible clients through Apify's MCP server:

```text
https://mcp.apify.com/?tools=automation-lab/email-account-footprint-scanner
```

#### Claude Code

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com/?tools=automation-lab/email-account-footprint-scanner"
```

#### Claude Desktop and Cursor

Add this `mcpServers` JSON to Claude Desktop's configuration or Cursor's MCP settings:

```json
{
  "mcpServers": {
    "apify-email-footprint": {
      "url": "https://mcp.apify.com/?tools=automation-lab/email-account-footprint-scanner"
    }
  }
}
```

#### VS Code

Open **MCP: Add Server**, choose HTTP, and enter the same Apify MCP URL. Save it to your user or workspace configuration.

Example prompts:

- “Scan this company-controlled incident-response address against Amazon, GitHub, and Spotify and explain inconclusive statuses.”
- “Run a complete authorized email footprint audit and export the dataset as CSV.”
- “Compare found services for these two test identities without enabling password-recovery checks.”

### Integrations

#### Google Sheets

Export a complete evidence table for a case review, including inconclusive statuses.

#### Slack or email alerts

Trigger an alert only when a recurring scan produces a new `found` service compared with a prior authorized baseline.

#### Webhooks

Send finished-run events to a security automation pipeline, then retrieve the default dataset by ID.

#### Python or JavaScript enrichment

Join service signals with internal case data while preserving uncertainty and authorization controls.

#### Apify schedules

Run periodic exposure reviews for addresses controlled by your organization. Avoid unnecessary frequency because target services may rate-limit repeated checks.

### Legality, ethical use, and privacy

You are responsible for having a lawful basis and appropriate authorization.

Do not use results to harass people, guess passwords, take over accounts, bypass access controls, or create covert profiles.

Account-existence signals can be inaccurate, stale, shared, or affected by service defenses. They must not be treated as proof that a person owns an account.

Follow applicable privacy, employment, consumer-reporting, computer-misuse, and data-retention rules. Minimize collection, limit access, and delete results when the authorized purpose ends.

### Limitations

- Third-party services can change forms and response text at any time.
- Some services deliberately obscure account existence.
- Rate limits vary by network, geography, and request volume.
- A positive signal does not reveal an account profile or prove ownership.
- A negative signal is not proof that an account does not exist.
- Masked recovery hints appear only when a service publicly returns them.
- The service catalog follows the Holehe version pinned in the current build.
- The Actor does not log in, solve CAPTCHAs, access private profiles, or use paid enrichment APIs.

### Troubleshooting

#### Why are many rows `rate_limited`?

The service may be throttling anonymous checks or returning a changed response. Reduce concurrency, scan a smaller allow list, and retry later. Keep the row inconclusive.

#### Why did I receive no rows?

If `onlyFound` is enabled, no adapter may have produced a positive signal. Disable it to inspect complete coverage and errors.

#### Why did the run reject my filters?

Your allow list, deny list, and category list selected no known service. Check lowercase service IDs and remove conflicting filters.

#### Why is a known account marked `not_found`?

Public account-state checks are heuristic and can change. Inspect the method and status, rerun the single service, and corroborate through an authorized manual process.

### Related Automation Labs actors

- [Email Deliverability Checker](https://apify.com/automation-lab/email-deliverability-checker) — validate deliverability signals rather than account registrations.
- [Email Finder](https://apify.com/automation-lab/email-finder) — discover public business contact emails from web sources.
- [Email Pattern Finder](https://apify.com/automation-lab/email-pattern-finder) — infer organization address patterns.
- [Bulk Domain Email Security Checker](https://apify.com/automation-lab/bulk-domain-email-security-checker) — audit SPF, DKIM, DMARC, and mail-domain controls.
- [Website Emails Scraper](https://apify.com/automation-lab/website-emails-scraper) — extract publicly displayed contact addresses from websites.

### FAQ

#### Does the Actor send password-reset emails?

The underlying checks are designed to inspect public responses without intentionally sending reset messages. Recovery-based adapters are disabled by default because third-party behavior can change.

#### Does it reveal private account data?

No. It does not authenticate or access account contents. It returns public account-state signals and optional masked hints exposed by the service response.

#### How many services are checked?

The pinned Holehe release currently exposes more than 100 callable adapters. Filters and the password-recovery setting determine the exact count in a run.

#### Can I scan a list of customers?

Only when your organization has a documented lawful basis and authorization for that specific purpose. Do not treat a customer relationship alone as permission for unrelated profiling.

#### Is this an email verifier?

No. Use an email deliverability or SMTP verifier to assess whether a mailbox can receive mail. This Actor asks whether public service workflows indicate associated accounts.

#### Can I use the output as proof of identity?

No. Signals can be wrong or shared and must be corroborated.

#### Does the Actor need a proxy or login?

No login, cookie, private token, browser, or paid API is required for the core workflow.

#### How should I store results?

Restrict access, document purpose, retain only needed fields, and delete the data according to your privacy and case-retention policy.

# Actor input Schema

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

One to 20 email addresses that you own or are explicitly authorized to assess. Duplicates are removed.

## `onlyFound` (type: `boolean`):

When enabled, save only services reporting an account. Disable it to retain not-found, rate-limited, and error evidence.

## `includeServices` (type: `array`):

Optional Holehe service IDs such as amazon, github, spotify, or twitter. Leave empty to scan every available service.

## `excludeServices` (type: `array`):

Optional Holehe service IDs to skip.

## `includeCategories` (type: `array`):

Optional module categories such as social\_media, shopping, software, programing, music, or productivity.

## `includePasswordRecovery` (type: `boolean`):

Opt in to the small set of adapters that use public password-recovery forms. These checks do not intentionally submit reset emails, but may be more sensitive or rate-limited.

## `serviceTimeoutSecs` (type: `integer`):

Maximum seconds allowed for each individual service adapter.

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

Maximum adapters running at once for each email address.

## Actor input object example

```json
{
  "emails": [
    "security@automation-lab.ai"
  ],
  "onlyFound": false,
  "includeServices": [
    "amazon",
    "github",
    "spotify"
  ],
  "excludeServices": [],
  "includeCategories": [],
  "includePasswordRecovery": false,
  "serviceTimeoutSecs": 10,
  "maxConcurrency": 20
}
```

# Actor output Schema

## `overview` (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 = {
    "emails": [
        "security@automation-lab.ai"
    ],
    "onlyFound": false,
    "includeServices": [
        "amazon",
        "github",
        "spotify"
    ],
    "includePasswordRecovery": false,
    "serviceTimeoutSecs": 10,
    "maxConcurrency": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/email-account-footprint-scanner").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": ["security@automation-lab.ai"],
    "onlyFound": False,
    "includeServices": [
        "amazon",
        "github",
        "spotify",
    ],
    "includePasswordRecovery": False,
    "serviceTimeoutSecs": 10,
    "maxConcurrency": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/email-account-footprint-scanner").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 '{
  "emails": [
    "security@automation-lab.ai"
  ],
  "onlyFound": false,
  "includeServices": [
    "amazon",
    "github",
    "spotify"
  ],
  "includePasswordRecovery": false,
  "serviceTimeoutSecs": 10,
  "maxConcurrency": 20
}' |
apify call automation-lab/email-account-footprint-scanner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/email-account-footprint-scanner",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email Account Footprint Scanner – Authorized OSINT",
        "description": "Map authorized email addresses across public account-registration signals from over 100 services. Export deterministic service matches, statuses, methods, rate limits, and available masked recovery hints.",
        "version": "0.1",
        "x-build-id": "VlKdBC0DS5ZAQdPqK"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~email-account-footprint-scanner/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-email-account-footprint-scanner",
                "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/automation-lab~email-account-footprint-scanner/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-email-account-footprint-scanner",
                "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/automation-lab~email-account-footprint-scanner/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-email-account-footprint-scanner",
                "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": [
                    "emails"
                ],
                "properties": {
                    "emails": {
                        "title": "📧 Authorized email addresses",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "One to 20 email addresses that you own or are explicitly authorized to assess. Duplicates are removed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "onlyFound": {
                        "title": "Confirmed accounts only",
                        "type": "boolean",
                        "description": "When enabled, save only services reporting an account. Disable it to retain not-found, rate-limited, and error evidence.",
                        "default": false
                    },
                    "includeServices": {
                        "title": "✅ Only these services",
                        "type": "array",
                        "description": "Optional Holehe service IDs such as amazon, github, spotify, or twitter. Leave empty to scan every available service.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeServices": {
                        "title": "🚫 Exclude services",
                        "type": "array",
                        "description": "Optional Holehe service IDs to skip.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "includeCategories": {
                        "title": "🗂️ Only these categories",
                        "type": "array",
                        "description": "Optional module categories such as social_media, shopping, software, programing, music, or productivity.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "includePasswordRecovery": {
                        "title": "Include password-recovery checks",
                        "type": "boolean",
                        "description": "Opt in to the small set of adapters that use public password-recovery forms. These checks do not intentionally submit reset emails, but may be more sensitive or rate-limited.",
                        "default": false
                    },
                    "serviceTimeoutSecs": {
                        "title": "⏱️ Timeout per service",
                        "minimum": 2,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Maximum seconds allowed for each individual service adapter.",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Concurrent service checks",
                        "minimum": 1,
                        "maximum": 40,
                        "type": "integer",
                        "description": "Maximum adapters running at once for each email address.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```