# LinkedIn People Search Scraper (`memo23/linkedin-people-search`) Actor

Search LinkedIn people by keyword, job title, company, school or location — no login needed. Get name, headline, company, location, schools, languages and profile URL as clean JSON/CSV. Cookie-free public mode carries zero ban risk; add your own cookie for exact LinkedIn filters and titles.

- **URL**: https://apify.com/memo23/linkedin-people-search.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Social media, Lead generation, AI
- **Stats:** 22 total users, 14 monthly users, 99.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 profile founds

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

Learn more: https://docs.apify.com/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/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

## LinkedIn People Search Scraper

**Search LinkedIn for people by keyword, job title, company, school or location — and get clean, structured profile rows as JSON or CSV.**

Find the exact people you need — growth leaders in London, engineers who studied at Stanford, marketers at a target company — and export their public professional details in one run. Works **cookie-free by default** (no LinkedIn login, no ban risk), with an optional power mode that uses your own session cookie for exact filters.

No login. No pooled accounts. No browser automation. Just a search in, a spreadsheet out.

![How the LinkedIn People Search Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-linkedin-people-search.png)

---

### Why Use This Scraper?

- **No login required.** Public mode finds public LinkedIn profiles without any cookie or account — so there's zero risk to your LinkedIn login.
- **Search the way recruiters do.** Combine keyword, job title, company, school and location to narrow in on the right people.
- **Clean, structured rows.** Name, headline, current company, location, schools, languages and profile URL — ready for your CRM, sheet or outreach tool.
- **Two modes, one actor.** Start cookie-free; switch to your own cookie later for exact facet filters and unmasked job titles.
- **Pay only for what you get.** Priced per profile returned — no monthly rental, no wasted spend on empty runs.
- **Pure HTTP.** No headless browser, no heavy proxies to configure — fast and reliable.

---

### Overview

The LinkedIn People Search Scraper turns a **people search query** into a **structured dataset of profiles**. You describe who you're looking for using any mix of keyword, job title, company, school and location, and the actor returns one clean row per matching person.

It runs in two modes:

- **Public mode (default):** finds public LinkedIn profiles and reads their publicly visible professional details. No LinkedIn login is used anywhere, so there is no ban risk to any account.
- **Cookie mode (optional):** runs LinkedIn's own people search under **your** session cookie, unlocking exact facet filters (location / company / school URNs, connection degree) and reliably-populated job titles.

The output is a flat table — perfect for lead lists, recruiting shortlists, market maps and research panels. Export to JSON, CSV, Excel or Google Sheets, or pull it via the Apify API.

---

### Supported Inputs

You search by **criteria**, not by URL. Provide any combination of the fields below — they are ANDed together to narrow the result set.

| You want… | Fill in… |
|---|---|
| People matching a free-text search | `keywords` (e.g. `growth marketing`) |
| A specific role | `title` (e.g. `Head of Growth`) |
| People at a company | `company` (e.g. `Stripe`) |
| Alumni of a school | `school` (e.g. `Stanford`) |
| People in a place | `location` (e.g. `London`) |
| A specific person by name | `firstName` + `lastName` |

**Cookie mode adds precise URN filters:** `geoUrns`, `currentCompanyUrns`, `schoolUrns` and `networkDepths` (1st / 2nd / 3rd-degree connections) for pinpoint targeting.

**Not supported:** private profiles you have no access to, connection-request or messaging actions, and any data behind a paywall LinkedIn does not expose to your session. This is a read-only data tool.

---

### Use Cases

| Audience | What they get |
|---|---|
| **Sales & lead gen** | Build targeted prospect lists by role, company and location |
| **Recruiters** | Source candidate shortlists by title, skill keyword and school |
| **Marketers** | Map decision-makers at target accounts for ABM campaigns |
| **Researchers & analysts** | Assemble people panels for market and talent studies |
| **Founders** | Find advisors, hires or partners matching a precise profile |
| **Agencies** | Deliver bulk, structured people data to clients on demand |

---

### How It Works

1. **Describe who to find** — enter any mix of keyword, job title, company, school and location, and pick a mode (public or cookie).
2. **Match people to your query** — the actor finds LinkedIn profiles matching your criteria and paginates through the results automatically.
3. **Open each matching profile** and read the publicly available professional details.
4. **Extract & normalise** — name, headline, current company, location, schools, languages and profile URL become one clean row.
5. **Stream to the dataset** — every profile is pushed as it's found, exportable to JSON, CSV, Excel or Google Sheets.

---

### Input Configuration

| Field | Type | Description |
|---|---|---|
| `mode` | select | `public` (cookie-free, default) or `cookie` (uses your own LinkedIn session) |
| `keywords` | string | Main free-text search (role, skill, name — anything) |
| `title` | string | Filter by job-title keyword, e.g. `Head of Growth` |
| `company` | string | Filter by company-name keyword |
| `school` | string | Filter by school-name keyword |
| `location` | string | Filter by location keyword, e.g. `London` |
| `firstName` | string | Filter by first name |
| `lastName` | string | Filter by last name |
| `cookie` | string (secret) | **Cookie mode only** — your LinkedIn session cookie (contains `li_at` + `JSESSIONID`). Runs the search under your session. Public mode ignores this. |
| `geoUrns` | array | **Cookie mode** — LinkedIn location URN IDs (e.g. `103644278` = United States) |
| `currentCompanyUrns` | array | **Cookie mode** — LinkedIn company URN IDs |
| `schoolUrns` | array | **Cookie mode** — LinkedIn school URN IDs |
| `networkDepths` | array | **Cookie mode** — connection degree: `F` (1st), `S` (2nd), `O` (3rd+) |
| `maxResults` | integer | Hard cap on profiles returned (default 100) |
| `proxy` | object | Optional proxy override. Leave empty — the actor routes through its own residential proxy. |

#### Example 1 — Public mode (cookie-free)

```json
{
  "mode": "public",
  "keywords": "growth marketing",
  "title": "Head of Growth",
  "location": "London",
  "maxResults": 50
}
````

#### Example 2 — People at a company who studied somewhere

```json
{
  "mode": "public",
  "company": "Stripe",
  "school": "Stanford",
  "maxResults": 100
}
```

#### Example 3 — Cookie mode with exact URN filters

```json
{
  "mode": "cookie",
  "cookie": "li_at=YOUR_TOKEN; JSESSIONID=\"ajax:123...\"",
  "title": "Product Manager",
  "geoUrns": ["103644278"],
  "networkDepths": ["S", "O"],
  "maxResults": 100
}
```

***

### Output Overview

Each row is one person. Public mode returns the richest set of publicly visible fields (company, schools, languages, about); cookie mode returns LinkedIn's search-result fields including reliably-populated job titles and network distance.

Every row carries a `source` (`public` or `cookie`) and a `scrapedAt` timestamp so you always know how and when it was captured.

***

### Output Samples

**Public mode** (`source: "public"`):

```json
{
  "name": "Melissa H.",
  "jobTitle": null,
  "summary": "Melissa H. - rePurpose Global",
  "currentCompany": "rePurpose Global",
  "location": "New York, New York, United States",
  "schools": ["Brandeis University"],
  "languages": ["English"],
  "about": "Growth & partnerships leader focused on climate impact…",
  "imageUrl": "https://media.licdn.com/dms/image/…",
  "profileUrl": "https://www.linkedin.com/in/melissah1028",
  "urnId": null,
  "networkDistance": null,
  "source": "public",
  "scrapedAt": "2026-07-18T09:14:22.500Z"
}
```

**Cookie mode** (`source: "cookie"`):

```json
{
  "name": "Rajat Girdhar",
  "jobTitle": "Head of Growth at Rapido",
  "location": "Delhi, India",
  "summary": "Scaling growth for India's largest mobility platform",
  "profileUrl": "https://www.linkedin.com/in/rajatgirdhar",
  "urnId": "ACoAAB1x…",
  "networkDistance": "DISTANCE_2",
  "source": "cookie",
  "scrapedAt": "2026-07-18T09:14:23.100Z"
}
```

***

### Key Output Fields

**Identity**

- `name` — full name
- `profileUrl` — canonical LinkedIn profile URL
- `imageUrl` — profile photo URL (public mode)
- `urnId` — LinkedIn member URN (cookie mode)

**Professional**

- `jobTitle` — role/title (see FAQ — often `null` in public mode; reliable in cookie mode)
- `summary` — the profile headline
- `currentCompany` — current employer (public mode)
- `location` — city / region / country

**Background**

- `schools` — array of listed schools (public mode)
- `languages` — array of listed languages (public mode)
- `about` — the profile "about" text (public mode)

**Meta**

- `networkDistance` — connection degree (cookie mode)
- `source` — `public` or `cookie`
- `scrapedAt` — ISO timestamp of capture

***

### FAQ

**Do I need a LinkedIn account or cookie?**
No. Public mode (the default) needs no login and no cookie at all. Cookie mode is optional — use it only when you want exact URN filters and unmasked job titles.

**Why is `jobTitle` empty on some public-mode rows?**
LinkedIn hides the precise job title on many profiles when you're not logged in. Public mode reports the title when it's visible and `null` when LinkedIn masks it — the `summary` headline and `currentCompany` are still returned. For a reliable title on every row, use **cookie mode**.

**Is there any risk to my LinkedIn account?**
In public mode, none — no account is used anywhere. In cookie mode you supply your own session, so it behaves like your normal LinkedIn usage; keep `maxResults` reasonable.

**What's the difference between the two modes?**
Public mode is safe, login-free and returns rich public fields (company, schools, languages, about). Cookie mode runs LinkedIn's own people search under your session for exact facet filters (geo/company/school URNs, connection degree) and reliable titles.

**How many results can I get?**
Set `maxResults`. Public results depend on how many public profiles match your query; cookie mode paginates LinkedIn's search results.

**What formats can I export?**
JSON, CSV, Excel and HTML, plus Google Sheets and the Apify API — like any Apify dataset.

**Does it collect emails or phone numbers?**
No. This actor returns the professional profile fields listed above. It does not scrape private contact details.

***

### Support

- **Found a bug or need a new field?** Open an issue on the actor's **Issues** tab.
- Questions and feature requests are welcome — response is usually quick.

***

### Additional Services

Need a tailored export, a different set of fields, enrichment, or a scheduled feed into your CRM or data warehouse? Custom work and bespoke pipelines are available — reach out via the Issues tab.

***

### Explore More Scrapers

Looking for more LinkedIn and lead-generation data? Browse the full collection of professional-data scrapers on the [Apify Store](https://apify.com/memo23) — company pages, profiles, posts, jobs and more.

***

### ⚠️ Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by LinkedIn Corporation or Microsoft Corporation**. "LinkedIn" is a trademark of LinkedIn Corporation; all product and company names are the property of their respective owners and are used here for identification and descriptive purposes only.

This tool is intended for lawful use only. It collects **publicly available information** (in public mode) or information accessible to your own authenticated session (in cookie mode). You are responsible for how you use the data and for ensuring your use complies with LinkedIn's Terms of Service, applicable laws, and data-protection regulations including the GDPR and CCPA. Do not use scraped personal data for unlawful, discriminatory, or unsolicited-contact purposes that violate those regulations. Always obtain a lawful basis before processing personal data.

***

### SEO Keywords

LinkedIn people search scraper, LinkedIn profile scraper, LinkedIn people finder, LinkedIn search export, scrape LinkedIn profiles, LinkedIn people search API, LinkedIn lead scraper, LinkedIn prospecting tool, find people on LinkedIn, LinkedIn recruiter sourcing, LinkedIn candidate search, LinkedIn contact scraper, LinkedIn data extraction, people search by company, people search by school, LinkedIn talent sourcing, LinkedIn B2B leads, LinkedIn profile data export, no-login LinkedIn scraper, LinkedIn CSV export, LinkedIn JSON export, LinkedIn audience builder, sales prospecting LinkedIn, recruiting data scraper

# Actor input Schema

## `mode` (type: `string`):

**public** = cookie-free (recommended). Finds public LinkedIn profiles and reads each public profile page — no LinkedIn login, no cookie, zero ban risk. Works out of the box. **cookie** = uses LinkedIn's own people search under your session cookie for exact facets (geo/company/school/network-depth) — more precise, but you supply your own cookie.

## `keywords` (type: `string`):

Main free-text search (role, skill, name — anything).

## `title` (type: `string`):

Filter by job-title keyword (e.g. `Head of Growth`).

## `company` (type: `string`):

Filter by company-name keyword.

## `school` (type: `string`):

Filter by school-name keyword.

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

Filter by location keyword (e.g. `London`). Used in public mode.

## `firstName` (type: `string`):

Filter by first name (cookie mode).

## `lastName` (type: `string`):

Filter by last name (cookie mode).

## `cookie` (type: `string`):

Your own LinkedIn session cookie containing BOTH li\_at and JSESSIONID. Runs the search under your session (no ban risk to us). Kept secret. Public mode does not need this.

## `geoUrns` (type: `array`):

LinkedIn geo URN IDs, e.g. `103644278` = United States (cookie mode).

## `currentCompanyUrns` (type: `array`):

LinkedIn company URN IDs (cookie mode).

## `schoolUrns` (type: `array`):

LinkedIn school URN IDs (cookie mode).

## `networkDepths` (type: `array`):

Connection degree: `F` (1st), `S` (2nd), `O` (3rd+) — cookie mode.

## `maxResults` (type: `integer`):

Hard cap on profiles returned.

## `proxy` (type: `object`):

Leave empty — the actor routes through its own residential proxy. Only set to use your own proxies.

## Actor input object example

```json
{
  "mode": "public",
  "keywords": "growth marketing",
  "maxResults": 100
}
```

# 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": "growth marketing"
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/linkedin-people-search").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": "growth marketing" }

# Run the Actor and wait for it to finish
run = client.actor("memo23/linkedin-people-search").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": "growth marketing"
}' |
apify call memo23/linkedin-people-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn People Search Scraper",
        "description": "Search LinkedIn people by keyword, job title, company, school or location — no login needed. Get name, headline, company, location, schools, languages and profile URL as clean JSON/CSV. Cookie-free public mode carries zero ban risk; add your own cookie for exact LinkedIn filters and titles.",
        "version": "0.0",
        "x-build-id": "hYOGPRcDsCBnioUaM"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~linkedin-people-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-linkedin-people-search",
                "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/memo23~linkedin-people-search/runs": {
            "post": {
                "operationId": "runs-sync-memo23-linkedin-people-search",
                "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/memo23~linkedin-people-search/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-linkedin-people-search",
                "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",
                "properties": {
                    "mode": {
                        "title": "Search mode",
                        "enum": [
                            "public",
                            "cookie"
                        ],
                        "type": "string",
                        "description": "**public** = cookie-free (recommended). Finds public LinkedIn profiles and reads each public profile page — no LinkedIn login, no cookie, zero ban risk. Works out of the box. **cookie** = uses LinkedIn's own people search under your session cookie for exact facets (geo/company/school/network-depth) — more precise, but you supply your own cookie.",
                        "default": "public"
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Main free-text search (role, skill, name — anything)."
                    },
                    "title": {
                        "title": "Job title",
                        "type": "string",
                        "description": "Filter by job-title keyword (e.g. `Head of Growth`)."
                    },
                    "company": {
                        "title": "Company (keyword)",
                        "type": "string",
                        "description": "Filter by company-name keyword."
                    },
                    "school": {
                        "title": "School (keyword)",
                        "type": "string",
                        "description": "Filter by school-name keyword."
                    },
                    "location": {
                        "title": "Location (keyword)",
                        "type": "string",
                        "description": "Filter by location keyword (e.g. `London`). Used in public mode."
                    },
                    "firstName": {
                        "title": "First name",
                        "type": "string",
                        "description": "Filter by first name (cookie mode)."
                    },
                    "lastName": {
                        "title": "Last name",
                        "type": "string",
                        "description": "Filter by last name (cookie mode)."
                    },
                    "cookie": {
                        "title": "LinkedIn cookie (li_at + JSESSIONID)",
                        "type": "string",
                        "description": "Your own LinkedIn session cookie containing BOTH li_at and JSESSIONID. Runs the search under your session (no ban risk to us). Kept secret. Public mode does not need this."
                    },
                    "geoUrns": {
                        "title": "Location URN IDs",
                        "type": "array",
                        "description": "LinkedIn geo URN IDs, e.g. `103644278` = United States (cookie mode).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "currentCompanyUrns": {
                        "title": "Current-company URN IDs",
                        "type": "array",
                        "description": "LinkedIn company URN IDs (cookie mode).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "schoolUrns": {
                        "title": "School URN IDs",
                        "type": "array",
                        "description": "LinkedIn school URN IDs (cookie mode).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "networkDepths": {
                        "title": "Network depth",
                        "type": "array",
                        "description": "Connection degree: `F` (1st), `S` (2nd), `O` (3rd+) — cookie mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max profiles",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on profiles returned.",
                        "default": 100
                    },
                    "proxy": {
                        "title": "Proxy configuration (optional override)",
                        "type": "object",
                        "description": "Leave empty — the actor routes through its own residential proxy. Only set to use your own proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
