# Linkedin Lead Scraper (`api-empire/linkedin-lead-scraper`) Actor

LinkedIn Lead Scraper extracts professional lead data from LinkedIn profiles and search results. Collect names, job titles, companies, locations, and profile URLs. Ideal for B2B lead generation, sales prospecting, recruitment research, and market outreach.

- **URL**: https://apify.com/api-empire/linkedin-lead-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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

### **LinkedIn** Lead Scraper 📱

Linkedin Lead Scraper allows you to **extract** a wide range of **data** from **LinkedIn** profiles with ease. This includes lead addresses, names, job titles, and company details, providing you with comprehensive information for lead generation.

The tool also captures profile URLs and locations, making it easier to organize and segment your **data**. By automating the **extract**ion process, you can collect large volumes of **data** in a fraction of the time.

This scraper is designed to ensure **data** accuracy, so you can rely on the information for your marketing and outreach campaigns. Whether you need basic **contact** details or in-depth profile insights, the scraper delivers reliable results.

Linkedin Lead Scraper is a powerful tool designed to extract lead addresses and other relevant contact information from LinkedIn profiles. It simplifies the process of gathering leads and building professional connections through automated lead extraction.

Extracting leads from LinkedIn can be a time-consuming task, but this scraper streamlines the process with precision and efficiency. It is ideal for professionals and businesses looking to enhance their LinkedIn lead generation efforts.

With Linkedin Lead Scraper, you can automate the tedious task of gathering contact information, saving you hours of manual work. The tool is designed to handle large-scale data extraction while maintaining accuracy and compliance.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead Address | Extract verified lead addresses from LinkedIn profiles for direct communication. |
| Full Name | Retrieve the full names of LinkedIn users for personalized outreach. |
| Job Title | Capture job titles to better understand the roles and responsibilities of your leads. |
| Company Name | Extract the names of companies associated with LinkedIn profiles for targeted marketing. |
| Profile URL | Get direct links to LinkedIn profiles for easy reference and follow-up. |
| Location | Gather location data to segment leads based on geographic regions. |
| Industry | Identify the industries of LinkedIn users to tailor your outreach strategy. |
| Connections Count | Extract the number of connections to gauge the network size of each profile. |

### Key Features of **LinkedIn** Lead Scraper

Here are the **standout features** that make the **LinkedIn** Lead Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** lead extraction from **LinkedIn** profiles for faster lead generation
- ⭐ **Accurate** and reliable data collection to ensure high-quality results
- ⭐ Ability to handle large-scale data scraping for enterprise-level needs
- ⭐ User-friendly interface that simplifies the scraping process for all users
- ⭐ **Customizable** filters to target specific industries job titles or locations
- ⭐ **Secure** and compliant scraping practices to protect user data and privacy
- ⭐ Export data in multiple formats such as CSV or Excel for easy integration
- ⭐ **Regular** updates to ensure compatibility with **LinkedIn**s platform changes
- ⭐ Detailed logs and reports for tracking scraping progress and results
- ⭐ 247 customer support to assist with any issues or questions

### How to use **LinkedIn** Lead Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **LinkedIn** leads today:

1. ✅ **Sign up** or **log in** to your account on the Linkedin Lead Scraper platform
2. ✅ Install the scraper tool or access it through the web interface
3. ✅ Enter the **LinkedIn** profile URLs or search criteria for the profiles you want to scrape
4. ✅ Set your desired filters such as job titles industries or locations
5. ✅ **Start** the scraping process and monitor the progress through the dashboard
6. ✅ Once the scraping is complete review the extracted data for accuracy
7. ✅ **Export** the data in your preferred format such as CSV or Excel
8. ✅ Use the extracted data for your lead generation marketing or recruitment campaigns

### Use Cases 🎯

Lead Generation
🎯 Extract leads from **LinkedIn** to build a targeted list of potential clients
🎯 **Identify** decision-makers in specific industries for personalized outreach

Recruitment
🎯 **Find** and contact qualified candidates for open positions
🎯 Gather detailed information about potential hires from **LinkedIn** profiles

Market Research
🎯 **Analyze** **LinkedIn** data to understand industry trends and demographics
🎯 **Collect** information on competitors and their employees

Networking
🎯 Expand your professional network by connecting with **LinkedIn** users
🎯 Reach out to industry leaders and influencers for collaborations

### Why choose us? 💎

Linkedin Lead Scraper is designed to meet the needs of professionals and businesses seeking efficient lead extraction from **LinkedIn**. Our tool combines speed, accuracy, and compliance to deliver **reliable** results for your lead generation efforts.

With customizable filters, you can target specific industries, job titles, or locations, ensuring that your outreach is relevant and effective. We prioritize user experience by offering a simple and intuitive interface that requires no technical expertise.

Our scraper is **regular**ly updated to adapt to **LinkedIn**’s platform changes, so you can rely on it for consistent performance. Whether you need to extract a few profiles or thousands, our tool is built to handle tasks of any scale.

With 24/7 customer support and detailed documentation, we are committed to helping you achieve your goals. Choose Linkedin Lead Scraper for a seamless and efficient lead extraction experience.

### **LinkedIn** Lead Scraper Scalability 📈

Linkedin Lead Scraper is built to handle data extraction tasks of any size, making it suitable for both small businesses and large enterprises. Our tool is optimized for high performance, allowing you to extract thousands of profiles without compromising on speed or accuracy.

Whether you need to scrape data for a single campaign or ongoing lead generation, our scraper can scale to meet your requirements. The tool supports batch processing, enabling you to extract data from multiple profiles simultaneously.

With robust infrastructure and regular updates, Linkedin Lead Scraper ensures reliable performance even during intensive scraping tasks. Our scalable solution is ideal for businesses looking to streamline their **LinkedIn** data collection processes.

### **LinkedIn** Lead Scraper Legal Guidelines ⚖️

**Yes**—scraping **LinkedIn** is **legal** as long as you follow **ethical** and **compliant** practices. The **LinkedIn** Lead Scraper extracts only **publicly available** information from **public** **LinkedIn** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **LinkedIn**s terms of service when using the scraper
⚖️ **Avoid** scraping data from profiles that are marked as private or restricted
⚖️ **Use** the extracted data solely for legitimate and ethical purposes
⚖️ **Do not** sell or distribute the scraped data without proper authorization
⚖️ Respect the privacy of **LinkedIn** users and avoid collecting sensitive information
⚖️ Follow all applicable data protection laws and regulations in your region
⚖️ **Obtain** consent from users before contacting them using the extracted data
⚖️ Regularly review **LinkedIn**s policies to ensure continued compliance

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Linkedin Lead Scraper"],
  "country": "Global",
  "maxLeadNumbers": 20,
  "platform": "LinkedIn",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxLeadNumbers | Maximum leads to collect (default 20) |
| platform | Platform to scrape (LinkedIn) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "LinkedIn",
    "keyword": "Linkedin Lead Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "lead": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies LinkedIn as the source |
| keyword | Keyword that triggered the result (Linkedin Lead Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct LinkedIn profile link |
| lead | Extracted lead address |

### FAQ ❓

#### What is Linkedin **Lead Scraper**?

Linkedin Lead Scraper is a tool designed to extract lead addresses and other contact information from LinkedIn profiles.

#### Is it **legal** to scrape leads from LinkedIn?

You must ensure **compliance** with LinkedIn’s terms of service and applicable data protection laws when using the scraper.

#### Can I **extract** data from **private** LinkedIn profiles?

**No**, the scraper can only extract data from **publicly available** LinkedIn profiles.

#### What formats are supported for **export**ing data?

You can export the extracted data in formats such as **CSV** or Excel for easy integration.

#### Is the tool compatible with all LinkedIn accounts?

**Yes**, the tool works with both free and premium LinkedIn accounts.

#### How accurate is the **extract**ed data?

The scraper is designed to provide accurate and reliable data, but we recommend verifying the information before use.

#### Can I customize the scraping criteria?

**Yes**, you can set filters such as job titles, industries, or locations to target specific profiles.

#### Does the tool support batch processing?

**Yes**, Linkedin Lead Scraper can handle batch processing for large-scale data extraction.

#### What is the maximum number of profiles I can scrape?

The tool is scalable and can extract data from thousands of profiles, depending on your requirements.

#### Is **customer support** available?

**Yes**, we offer 24/7 customer support to assist with any issues or questions.

#### How often is the tool updated?

The scraper is regularly updated to ensure compatibility with LinkedIn’s platform changes.

#### Can I use the tool for **lead generation**?

**Yes**, Linkedin Lead Scraper is ideal for generating leads by extracting contact information from LinkedIn profiles.

#### Is my data **secure** while using the scraper?

**Yes**, we prioritize data security and ensure that your information is protected during the scraping process.

#### Do I need technical expertise to use the tool?

**No**, the scraper is **user-friendly** and does not require any technical skills to operate.

### What are other Linkedin scraping tools?

If you want to scrape specific Linkedin data, you can use any of the dedicated scrapers below for faster and more targeted results.

| Scraper Name | Scraper Name |
|---|---|
| [LinkedIn Ads Scraper](https://apify.com/api-empire/linkedin-ads-scraper) | [Linkedin Phone Number Scraper](https://apify.com/api-empire/linkedin-phone-number-scraper) |
| [Linkedin B2b Email Scraper](https://apify.com/api-empire/linkedin-b2b-email-scraper) | [LinkedIn Post Comments Scraper](https://apify.com/api-empire/linkedin-post-comments-scraper) |
| [Linkedin B2b Lead Scraper](https://apify.com/api-empire/linkedin-b2b-lead-scraper) | [Linkedin Post Reactions Scraper](https://apify.com/api-empire/linkedin-post-reactions-scraper) |
| [Linkedin B2b Phone Number Scraper](https://apify.com/api-empire/linkedin-b2b-phone-number-scraper) | [LinkedIn Post Scraper](https://apify.com/api-empire/linkedin-post-scraper) |
| [Linkedin Company About Scraper](https://apify.com/api-empire/linkedin-company-about-scraper) | [LinkedIn Post, Comments and Engagements Scraper](https://apify.com/api-empire/linkedin-post-comments-and-engagements-scraper) |
| [Linkedin Company Employees](https://apify.com/api-empire/linkedin-company-employees) | [LinkedIn Posts URL (Profile)](https://apify.com/api-empire/linkedin-posts-url-profile) |
| [Linkedin Company Employees Scraper](https://apify.com/api-empire/linkedin-company-employees-scraper) | [Linkedin Profile And Company Posts Scraper](https://apify.com/api-empire/linkedin-profile-and-company-posts-scraper) |
| [Linkedin Company Post Scraper](https://apify.com/api-empire/linkedin-company-post-scraper) | [Linkedin Profile Email Scraper](https://apify.com/api-empire/linkedin-profile-email-scraper) |
| [Linkedin Company Profile Scraper](https://apify.com/api-empire/linkedin-company-profile-scraper) | [Linkedin Profile Lead Scraper](https://apify.com/api-empire/linkedin-profile-lead-scraper) |
| [LinkedIn Company Scraper](https://apify.com/api-empire/linkedin-company-scraper-actor) | [Linkedin Profile Phone Number Scraper](https://apify.com/api-empire/linkedin-profile-phone-number-scraper) |
| [Linkedin Email Scraper](https://apify.com/api-empire/linkedin-email-scraper) | [Linkedin Profile Post Scraper](https://apify.com/api-empire/linkedin-profile-post-scraper) |
| [Linkedin Jobs Scraper](https://apify.com/api-empire/linkedin-jobs-scraper) | [LinkedIn Profile Scraper](https://apify.com/api-empire/linkedin-profile-scraper) |
| [Linkedin Open Profile Status](https://apify.com/api-empire/linkedin-open-profile-status) | [LinkedIn Search Jobs Scraper](https://apify.com/api-empire/linkedin-search-jobs-scraper) |

# Actor input Schema

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

List of keywords to search for on Linkedin (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Linkedin profiles/posts containing these keywords and extract email addresses.

## `platform` (type: `string`):

Select platform.

## `location` (type: `string`):

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

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

Maximum number of emails to collect per keyword (default: 20).

## `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.

## `proxyConfiguration` (type: `object`):

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Linkedin",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-empire/linkedin-lead-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": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("api-empire/linkedin-lead-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": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call api-empire/linkedin-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin Lead Scraper",
        "description": "LinkedIn Lead Scraper extracts professional lead data from LinkedIn profiles and search results. Collect names, job titles, companies, locations, and profile URLs. Ideal for B2B lead generation, sales prospecting, recruitment research, and market outreach.",
        "version": "0.1",
        "x-build-id": "5Clet1bwJA7boE4R7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~linkedin-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-linkedin-lead-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/api-empire~linkedin-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-linkedin-lead-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/api-empire~linkedin-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-linkedin-lead-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"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Linkedin (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Linkedin profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Linkedin"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Linkedin"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "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"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
