# Best Linkedin Email Scraper (`scraperoka/best-linkedin-email-scraper`) Actor

🚀 Best LinkedIn Email Scraper extracts verified emails from LinkedIn profiles and company pages fast. Perfect for B2B lead gen, sales, recruiting & outreach—saving time while boosting targeting accuracy. 📈 Get more prospects, fewer manual searches!

- **URL**: https://apify.com/scraperoka/best-linkedin-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Best Linkedin Email Scraper 🎯

Manually visiting hundreds of profiles to collect emails wastes hours you don’t have. **Best Linkedin Email Scraper** pulls business and consumer email contacts in bulk from public web data using your keywords and filters—ideal for marketers, recruiters, and growth teams. This Best Linkedin Email Scraper (and its LinkedIn email scraper tool alternatives) helps you build outreach-ready lists with thousands of records in minutes.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "keyword": "fitness",
  "title": "Fitness & Wellness Founder",
  "url": "https://www.linkedin.com/in/jane-doe/",
  "description": "Contact details and email references found on the public profile page.",
  "email": "jane.doe@fitnessexample.com",
  "email_domain": "fitnessexample.com",
  "email_type": "B2C",
  "scrape_from": "Profile",
  "country": "United States",
  "error_message": null
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | Which keyword drove the contact discovery for easier reporting (and to refine the next run). |
| `title` | string | The title/name context linked to the record so you know who you’re targeting. |
| `url` | string | The source URL for the record (useful for verification and auditing). |
| `description` | string | The scraped description text that provides context behind the email finding. |
| `email` | string | The actual extracted email address you can use for outreach. |
| `email_domain` | string | The email domain so you can segment leads by company/brand. |
| `email_type` | string | Whether the email is categorized as B2B or B2C for better targeting and messaging. |
| `scrape_from` | string | What source type the actor used (for example: Profile, Company, Posts, or Pulse). |
| `country` | string | The country filter applied to focus your results in a specific geography. |
| `error_message` | string (nullable) | Includes an error message when something goes wrong so you can troubleshoot or retry intelligently. |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Best Linkedin Email Scraper?

There are a lot of ways to pull data from LinkedIn email scraping workflows—here’s what sets Best Linkedin Email Scraper apart.

#### Keyword-first lead discovery

You provide `keywords`, a `country`, and an `emailType` (B2B or B2C). That means this LinkedIn outreach email scraper is designed to return results aligned to your prospecting intent, not generic noise.

#### Flexible “scrape from” coverage

Use `scrapeFrom` to choose what to scan: All, Profile, Company, Posts, or Pulse. This makes it suitable for LinkedIn prospecting email scraper use cases—from basic profile lead sourcing to broader content-based discovery.

#### Email typing for better outreach fit

With `email_type` available in the output, you can quickly build the right segments for campaigns (for example, separating B2B and B2C in your LinkedIn email list building tool workflow).

#### Resilient runs with engine choice

You can pick an `engine` mode to balance speed and cost. This is helpful when you’re using LinkedIn email extraction software for repeated lead-building cycles and want more consistent run behavior.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["fitness", "marketing"],
  "country": "United States",
  "scrapeFrom": "All",
  "emailType": "B2B",
  "engine": "legacy",
  "maxEmails": 100
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | One or more keywords to search for on LinkedIn. |
| `country` | ✅ | Targets a specific country to focus the results. |
| `scrapeFrom` | ✅ | Chooses where to scrape from: All, Profile, Company, Posts, or Pulse. |
| `emailType` | ✅ | Choose the email category: B2C or B2B. |
| `engine` | ⬜ | Select the scraping engine (Cost Effective or Legacy) to balance speed, reliability, and cost. |
| `maxEmails` | ✅ | The maximum number of emails to collect (limits run size, helping manage time and cost). |

***

### Core Capabilities

#### Bulk LinkedIn email extraction (B2B and B2C)

Best Linkedin Email Scraper extracts both business and consumer email contacts based on your `emailType`. That makes it a practical LinkedIn leads email scraper when you need outreach lists that match your audience.

#### Smart source targeting via `scrapeFrom`

You can broaden or narrow your results by selecting All, Profile, Company, Posts, or Pulse in `scrapeFrom`. This flexibility helps when you’re using LinkedIn email mining tool workflows for different lead-generation strategies.

#### Structured, dataset-ready output

Every run writes clean records into the dataset with consistent fields like `email`, `email_domain`, `email_type`, `scrape_from`, and `country`. This structure is exactly what you want for exporting emails from LinkedIn into downstream tools.

#### Engine selection for run balancing

The `engine` input lets you choose between cost-effective and legacy scraping behavior. If you’re building large lists with an automated LinkedIn email scraping workflow, this helps you adapt runs to your priorities.

#### Built-in safeguards for run sizing

Use `maxEmails` to control how many emails you collect in a single run. Large searches or high limits may take longer, so this cap is important when planning outreach cycles with LinkedIn email extraction software.

***

### Who Gets the Most Out of This

Here’s how different teams put Best Linkedin Email Scraper to work:

**Sales Development Reps** — Sales teams use it as a LinkedIn contact email finder to build segmented outreach lists by keyword and country, with email addresses ready for immediate personalization.

**Growth Teams & Marketers** — Growth teams use it as a LinkedIn email list building tool to generate leads for campaign testing, with B2B vs B2C separation to improve message-market fit.

**Recruiters & Talent Acquisition** — Recruiters use it to find contact emails tied to roles and public profiles, speeding up sourcing workflows when LinkedIn prospecting email scraper approaches are needed fast.

**Data Analysts & Researchers** — Analysts prefer the structured dataset output (keyword, domain, type, source, and country) to study lead distribution and refine targeting logic across runs.

**Automation Specialists (Developers / Ops)** — Engineers use the dataset results as a consistent input for pipelines, scheduling, and integration-based lead enrichment so the process becomes repeatable rather than manual.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Best Linkedin Email Scraper from start to finish:

1. **Open** the actor on Apify — go to the actor page on [console.apify.com](https://console.apify.com) and open Best Linkedin Email Scraper.
2. **Enter your inputs** — set `keywords`, `country`, `scrapeFrom`, `emailType`, and `maxEmails` in the input form (see Section 04).
3. **Choose engine settings** — optionally adjust `engine` based on whether you prioritize cost-effective runs or legacy behavior.
4. **Hit Run** — start the actor and monitor progress in the live log.
5. **View results** — open the dataset tab to inspect extracted fields like `email`, `email_domain`, and `email_type`.
6. **Export your data** — download as JSON, CSV, or Excel from the Apify dataset tab.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Best Linkedin Email Scraper plugs directly into your existing workflow.

You can export results from the Apify dataset tab in **JSON, CSV, or Excel**, which makes exporting emails from LinkedIn fast for CRMs, spreadsheets, and enrichment tools.

You can also connect the actor to your automation stack using Apify’s ecosystem features. Use **Zapier / Make**, **webhooks**, or **API access** to push results into downstream systems when a run completes. For depth on each option, see the Apify docs: https://apify.com/docs/api.

***

### Pricing & Free Trial

Best Linkedin Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

Apify usage is generally pay-as-you-go for actor runs (billed based on platform compute), and the free tier is designed to help you test workflows before scaling to larger LinkedIn email scraper tool batches. For exact plans and current pricing, check the Apify pricing page on apify.com.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limiting pressure | The actor is designed to keep runs moving by managing request behavior for more consistent extraction. |
| Large list jobs | You control throughput via `maxEmails`, so you can scale gradually. |
| Output consistency | Results are written with structured fields like `email`, `email_domain`, `email_type`, `scrape_from`, and `country`. |
| Engine flexibility | Choose `engine` to balance cost and reliability for your LinkedIn email list building tool workflow. |

Limitations: the actor is intended for collecting from **publicly available sources**. Results depend on whether email addresses are present in the public content it can access. For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify provides a free tier that you can use to run Best Linkedin Email Scraper for testing before scaling. Exact credit amounts and eligibility depend on the current Apify offering shown in your account.

#### Do I need to log in to LinkedIn to use this?

No login is required as part of the actor’s workflow because it targets publicly available web data and extracts emails where they are discoverable.

#### How accurate is the data?

Accuracy depends on what’s publicly available in the sources the actor processes. The output includes extracted `email`, `email_domain`, and context fields like `description`, so you can validate and filter as needed.

#### How many results can I get per run?

You control the maximum number of emails collected with `maxEmails`. Set it to a smaller number for quick tests, or increase it for larger runs—just note that larger limits can take longer.

#### How often is the data updated / how fresh is it?

Freshness depends on when the actor run is executed. Run it again when you need updated contacts for a new outreach cycle.

#### Is this legal? Does it comply with GDPR / CCPA?

You should review your use case and confirm compliance with applicable laws and platform policies. Best Linkedin Email Scraper works with **publicly available data**, but it’s still your responsibility to handle data ethically and lawfully.

#### Can I export results to Google Sheets or Excel?

Yes. You can export results from the Apify dashboard in JSON, CSV, or Excel format. You can also integrate into tools like Google Sheets using Apify automation and export workflows.

#### Can I run this on a schedule automatically?

Yes. You can schedule actor runs on Apify so Best Linkedin Email Scraper runs automatically on a recurring basis for ongoing LinkedIn email extraction.

#### Can I access this via API?

Yes. You can access actor run results programmatically via the Apify API. See https://apify.com/docs/api for details.

#### What happens if the actor hits an error?

If issues occur, the dataset records can include an `error_message` field to help you understand failures. You can then adjust inputs (like `maxEmails` or `engine`) and retry.

***

### Need Help or Have a Request?

Got a question about Best Linkedin Email Scraper or want a new feature added? Email us at <dataforleads@gmail.com>. We respond quickly and actively maintain this actor based on feedback, including ideas like webhook notifications on completion and improved bulk export workflows.

***

### Disclaimer & Responsible Use

*Best Linkedin Email Scraper is the fastest, most reliable way to build LinkedIn outreach email lists from public sources — start your free run today.*\
This actor collects **publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for ensuring your use complies with GDPR, CCPA, applicable laws, and platform Terms of Service. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `keywords` (type: `array`):

Enter one or more keywords to search for on Linkedin.

## `country` (type: `string`):

Specify the country to target for Google search results.

## `scrapeFrom` (type: `string`):

Choose one option — All, Profile, Company, Posts, or Pulse.

## `emailType` (type: `string`):

Choose one — B2C or B2B.

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

## `maxEmails` (type: `integer`):

Enter the maximum number of emails to collect.

## Actor input object example

```json
{
  "keywords": [
    "developer",
    "founder"
  ],
  "country": "United States",
  "scrapeFrom": "All",
  "emailType": "B2C",
  "engine": "legacy",
  "maxEmails": 20
}
```

# 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 = {
    "keywords": [
        "developer",
        "founder"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/best-linkedin-email-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "keywords": [
        "developer",
        "founder",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/best-linkedin-email-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 '{
  "keywords": [
    "developer",
    "founder"
  ]
}' |
apify call scraperoka/best-linkedin-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/best-linkedin-email-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Best Linkedin Email Scraper",
        "description": "🚀 Best LinkedIn Email Scraper extracts verified emails from LinkedIn profiles and company pages fast. Perfect for B2B lead gen, sales, recruiting & outreach—saving time while boosting targeting accuracy. 📈 Get more prospects, fewer manual searches!",
        "version": "1.0",
        "x-build-id": "rmAyWodxMsAR1XnBg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~best-linkedin-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-best-linkedin-email-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/scraperoka~best-linkedin-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-best-linkedin-email-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/scraperoka~best-linkedin-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-best-linkedin-email-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": [
                    "keywords",
                    "country",
                    "scrapeFrom",
                    "emailType",
                    "maxEmails"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Enter one or more keywords to search for on Linkedin.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "Germany",
                            "France",
                            "India",
                            "Japan",
                            "Brazil",
                            "Italy",
                            "Spain",
                            "Netherlands",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Finland",
                            "Poland",
                            "Czech Republic",
                            "Hungary",
                            "Romania",
                            "Bulgaria",
                            "Croatia",
                            "Slovenia",
                            "Slovakia",
                            "Estonia",
                            "Latvia",
                            "Lithuania",
                            "Portugal",
                            "Greece",
                            "Cyprus",
                            "Malta",
                            "Luxembourg",
                            "Ireland",
                            "Belgium",
                            "Austria",
                            "Switzerland",
                            "Liechtenstein",
                            "Iceland",
                            "South Korea",
                            "China",
                            "Mexico",
                            "Argentina",
                            "Chile",
                            "Colombia",
                            "Peru",
                            "Venezuela",
                            "Ecuador",
                            "Uruguay",
                            "Paraguay",
                            "Bolivia",
                            "Guyana",
                            "Suriname",
                            "French Guiana",
                            "Falkland Islands (Malvinas)",
                            "South Georgia and the South Sandwich Islands",
                            "Bonaire, Sint Eustatius and Saba",
                            "Curaçao",
                            "Aruba",
                            "Sint Maarten (Dutch part)",
                            "Turks and Caicos Islands",
                            "British Virgin Islands",
                            "Anguilla",
                            "Montserrat",
                            "Antigua and Barbuda",
                            "Barbados",
                            "Dominica",
                            "Grenada",
                            "Saint Kitts and Nevis",
                            "Saint Lucia",
                            "Saint Vincent and the Grenadines",
                            "Trinidad and Tobago",
                            "Jamaica",
                            "Bahamas",
                            "Belize",
                            "Costa Rica",
                            "Guatemala",
                            "Honduras",
                            "Nicaragua",
                            "Panama",
                            "El Salvador",
                            "Cuba",
                            "Dominican Republic",
                            "Haiti",
                            "Puerto Rico",
                            "U.S. Virgin Islands",
                            "American Samoa",
                            "Guam",
                            "Northern Mariana Islands",
                            "Saudi Arabia",
                            "United Arab Emirates",
                            "Bahrain",
                            "Iraq",
                            "Iran, Islamic Republic of",
                            "Israel",
                            "Jordan",
                            "Kuwait",
                            "Lebanon",
                            "Oman",
                            "Qatar",
                            "Syrian Arab Republic",
                            "Yemen",
                            "Afghanistan",
                            "Bangladesh",
                            "Bhutan",
                            "Maldives",
                            "Nepal",
                            "Pakistan",
                            "Sri Lanka",
                            "Myanmar",
                            "Cambodia",
                            "Lao People's Democratic Republic",
                            "Thailand",
                            "Viet Nam",
                            "Malaysia",
                            "Singapore",
                            "Brunei Darussalam",
                            "Philippines",
                            "Indonesia",
                            "Timor-Leste",
                            "Papua New Guinea",
                            "Fiji",
                            "New Zealand",
                            "Solomon Islands",
                            "Vanuatu",
                            "New Caledonia",
                            "French Polynesia",
                            "Wallis and Futuna",
                            "Samoa",
                            "Tonga",
                            "Tuvalu",
                            "Kiribati",
                            "Nauru",
                            "Federated States of Micronesia",
                            "Marshall Islands",
                            "Palau",
                            "Cook Islands",
                            "Niue",
                            "Tokelau"
                        ],
                        "type": "string",
                        "description": "Specify the country to target for Google search results.",
                        "default": "United States"
                    },
                    "scrapeFrom": {
                        "title": "Scrape From",
                        "enum": [
                            "All",
                            "Profile",
                            "Company",
                            "Posts",
                            "Pulse"
                        ],
                        "type": "string",
                        "description": "Choose one option — All, Profile, Company, Posts, or Pulse.",
                        "default": "All"
                    },
                    "emailType": {
                        "title": "Email Type",
                        "enum": [
                            "B2C",
                            "B2B"
                        ],
                        "type": "string",
                        "description": "Choose one — B2C or B2B.",
                        "default": "B2C"
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "maxEmails": {
                        "title": "Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Enter the maximum number of emails to collect.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
