# LinkedIn Profile Search by Name (`crawlerbros/linkedin-profile-search-by-name`) Actor

Find LinkedIn profiles by person name. Input a list of names and get matching profiles with name, headline, location, and profile URL.

- **URL**: https://apify.com/crawlerbros/linkedin-profile-search-by-name.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Social media, Automation, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## LinkedIn Profile Search by Name

Find LinkedIn profiles by person name. This actor searches LinkedIn for one or more people and returns matching profiles with their name, headline, location, profile URL, connection degree, and profile picture.

### Features

- Search for multiple people in a single run — provide a list of names and get results for each
- Optional filters: location, current company, and LinkedIn connection degree (1st, 2nd, 3rd+)
- Returns structured data ready for CRM enrichment, prospecting, and people research
- Configurable result limit per name (1–100 profiles per search)

### Use Cases

- **Lead generation**: Find decision-makers at target companies by searching their names
- **CRM enrichment**: Verify and enrich contact records with up-to-date LinkedIn profile data
- **Talent sourcing**: Look up candidates and get their current role and location
- **Research**: Quickly find the LinkedIn profiles of public figures, executives, or colleagues

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `names` | array of strings | Yes | List of person names to search (e.g. `["Bill Gates", "Satya Nadella"]`) |
| `cookie` | string | Yes | Your LinkedIn session cookie — paste the plain `li_at` value, or a full JSON cookie export |
| `maxResultsPerName` | integer | No | Max profiles per name (default: 10, max: 100) |
| `location` | string | No | Filter by location (e.g. `"New York"`, `"United Kingdom"`) |
| `currentCompany` | string | No | Filter by current employer (e.g. `"Microsoft"`) |
| `connectionDegree` | enum | No | LinkedIn connection degree: `""` (all), `"F"` (1st), `"S"` (2nd), `"O"` (3rd+) |
| `proxyConfiguration` | proxy | No | Proxy settings (Apify proxy recommended) |

#### Getting Your LinkedIn Cookie

1. Log into LinkedIn in your browser
2. Open Developer Tools → Application → Cookies → `www.linkedin.com`
3. Copy the value of the `li_at` cookie, **or** use a browser extension like EditThisCookie to export all cookies as JSON

> **Security note**: Your cookie grants full access to your LinkedIn account. Keep it private and never share it publicly.

#### Example Input

```json
{
  "names": ["Bill Gates", "Satya Nadella", "Sundar Pichai"],
  "cookie": "YOUR_LI_AT_TOKEN_HERE",
  "maxResultsPerName": 5,
  "location": "United States",
  "currentCompany": "Microsoft"
}
````

### Output

Each result is one LinkedIn profile record:

| Field | Type | Description |
|---|---|---|
| `name` | string | Full name of the person |
| `profileUrl` | string | Canonical LinkedIn profile URL (e.g. `https://www.linkedin.com/in/billgates/`) |
| `headline` | string | Professional headline (current role / tagline) |
| `location` | string | Location as shown on LinkedIn |
| `connectionDegree` | string | LinkedIn connection degree (`"1st"`, `"2nd"`, `"3rd+"`) |
| `profilePicture` | string | Profile picture URL (CDN link, when available) |
| `searchName` | string | The input name that produced this result |
| `scrapedAt` | string | ISO 8601 timestamp of when this record was scraped |

#### Example Output Record

```json
{
  "name": "Bill Gates",
  "profileUrl": "https://www.linkedin.com/in/billgates/",
  "headline": "Co-chair of the Bill & Melinda Gates Foundation",
  "location": "Seattle, Washington, United States",
  "connectionDegree": "2nd",
  "profilePicture": "https://media.licdn.com/dms/image/v2/.../400_400/profile-displayphoto.jpg",
  "searchName": "Bill Gates",
  "scrapedAt": "2025-06-12T10:30:00.000000+00:00"
}
```

### Frequently Asked Questions

**Q: Why do I need to provide a LinkedIn cookie?**

LinkedIn's people search is only available to authenticated users. The `li_at` cookie authenticates your requests to LinkedIn's API. Without it, search results are not available.

**Q: How many results can I get per name?**

Up to 100 profiles per name (configurable via `maxResultsPerName`). LinkedIn typically returns 10 results per page; the actor paginates automatically.

**Q: Will this get my LinkedIn account limited?**

The actor uses respectful delays between requests and mimics normal browser behavior. However, LinkedIn monitors unusual activity. For large-scale searches, use a residential proxy and keep request volumes reasonable.

**Q: Why are some fields missing from results?**

Fields like `headline`, `location`, `connectionDegree`, and `profilePicture` are only included when LinkedIn returns them. They are omitted (not null) when not available.

**Q: Can I filter by location and company at the same time?**

Yes. All filters (`location`, `currentCompany`, `connectionDegree`) can be combined in a single run.

**Q: What happens if a name matches no results?**

If LinkedIn returns no profiles for a given name, no records are emitted for that name. The actor continues with remaining names in the list.

**Q: Is this actor compliant with LinkedIn's Terms of Service?**

This actor accesses LinkedIn's API using your own session credentials, similar to normal browsing. Users are responsible for ensuring their use complies with LinkedIn's Terms of Service.

### Data Source

Data is sourced from LinkedIn's authenticated people search (Voyager API). Results reflect what is publicly visible on LinkedIn for the authenticated account.

### Explore the rest of the LinkedIn suite

Need a different LinkedIn surface? Pair this actor with any of the others in the LinkedIn Suite — all published under the same publisher and built to share the same cookie format and output conventions.

| Actor | What it scrapes |
|---|---|
| [LinkedIn Comments Scraper](https://apify.com/crawlerbros/linkedin-comments-scraper) | All comments + reply threads on a post |
| [LinkedIn Company Employees Scraper](https://apify.com/crawlerbros/linkedin-company-employees-scraper) | Employee list for any company (by URN) |
| [LinkedIn Company Info Scraper](https://apify.com/crawlerbros/linkedin-company-info-scraper) | Company About page (size, HQ, industry, specialties) |
| [LinkedIn Company Posts Scraper](https://apify.com/crawlerbros/linkedin-company-posts-scraper) | Posts published from a company page |
| [LinkedIn Events Scraper](https://apify.com/crawlerbros/linkedin-events-scraper) | Events by keyword/URL with full event detail |
| [LinkedIn Hashtag Posts Scraper](https://apify.com/crawlerbros/linkedin-hashtag-posts-scraper) | Posts ranked under a `#hashtag` |
| [LinkedIn Jobs Scraper](https://apify.com/crawlerbros/linkedin-jobs-scraper) | Job listings via the public jobs-guest API |
| [LinkedIn Jobs Scraper Ultra](https://apify.com/crawlerbros/linkedin-jobs-scraper-ultra) | Same as jobs-scraper + full detail enrichment |
| [LinkedIn Learning Courses Scraper](https://apify.com/crawlerbros/linkedin-learning-courses-scraper) | LinkedIn Learning course catalog by keyword |
| [LinkedIn People Search Scraper](https://apify.com/crawlerbros/linkedin-people-search-scraper) | People search with every LinkedIn facet (role, company, school, location, etc.) |
| [LinkedIn Post Reactions Scraper](https://apify.com/crawlerbros/linkedin-post-reactions-scraper) | Reactors on a post (name, headline, reaction type) |
| [LinkedIn Post Scraper](https://apify.com/crawlerbros/linkedin-post-scraper) | Full post (text, media, engagement counts, author) |
| [LinkedIn Post Search Scraper](https://apify.com/crawlerbros/linkedin-post-search-scraper) | Posts matching a keyword (with date/author/network filters) |
| [LinkedIn Profile Posts Scraper](https://apify.com/crawlerbros/linkedin-profile-posts-scraper) | All posts/reposts/articles for one profile |
| [LinkedIn Profile Scraper](https://apify.com/crawlerbros/linkedin-profile-scraper) | Public profile fields (name, headline, positions, education, skills) |
| [LinkedIn Profile Scraper Pro](https://apify.com/crawlerbros/linkedin-profile-scraper-pro) | Profile fields + extras (recommendations, organizations, languages) |
| [LinkedIn Profile Scraper Pro Ultra](https://apify.com/crawlerbros/linkedin-profile-scraper-pro-ultra) | Pro + premium fields (contact info, followers list when allowed) |
| [LinkedIn Profile Scraper Ultra](https://apify.com/crawlerbros/linkedin-profile-scraper-ultra) | Profile + the full upstream dash-120 surface |
| [LinkedIn Schools Alumni Scraper](https://apify.com/crawlerbros/linkedin-schools-alumni-scraper) | Alumni list for any LinkedIn school page |
| [LinkedIn Top Content Scraper](https://apify.com/crawlerbros/linkedin-top-content-scraper) | Trending / top-engagement posts by topic |
| [LinkedIn User Activity Scraper](https://apify.com/crawlerbros/linkedin-user-activity-scraper) | Reactions + comments + posts feed for one profile |

All actors share the same `cookie` input format (plain `li_at` OR full cookies JSON array) and the same omit-empty output convention.

# Actor input Schema

## `names` (type: `array`):

List of person names to search on LinkedIn. Each name is searched separately.

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

Your LinkedIn session cookie. Either paste the plain li\_at token value, or a JSON array of cookies exported from a browser extension (e.g. EditThisCookie). Required for accessing LinkedIn's search API.

## `maxResultsPerName` (type: `integer`):

Maximum number of LinkedIn profiles to return for each name in the input list.

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

Free-text location to filter results (e.g. "New York", "United Kingdom", "San Francisco Bay Area").

## `currentCompany` (type: `string`):

Filter results to people currently working at this company (e.g. "Microsoft", "Google").

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

Filter results to alumni of this school (e.g. "Stanford University", "MIT").

## `industry` (type: `string`):

Filter by industry. Accepts free text (e.g. "Software Development", "Financial Services").

## `language` (type: `string`):

Preferred LinkedIn locale for the session.

## `connectionDegree` (type: `string`):

Filter by LinkedIn connection degree. Leave blank for all connections.

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

Optional proxy settings. LinkedIn works best with residential proxies.

## Actor input object example

```json
{
  "names": [
    "John Smith",
    "Jane Williams"
  ],
  "cookie": "AQEDATVc5uMEM5s_AAABnro67cYAAAGe3kdxxk0Ajoj1en-Axa4lUoxvqVMAsMpFO2u4rOjJfIS1U1wrBETHJHqkj5i6KReB53dmYSZDgX9K4XnaFLmn7vE30gVWegfZltSOZVu_-Ny8sl4-aAKzeN-H",
  "maxResultsPerName": 10,
  "language": "en_US",
  "connectionDegree": "",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `profiles` (type: `string`):

Dataset containing all matched LinkedIn profiles.

# 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 = {
    "names": [
        "John Smith",
        "Jane Williams"
    ],
    "cookie": "AQEDATVc5uMEM5s_AAABnro67cYAAAGe3kdxxk0Ajoj1en-Axa4lUoxvqVMAsMpFO2u4rOjJfIS1U1wrBETHJHqkj5i6KReB53dmYSZDgX9K4XnaFLmn7vE30gVWegfZltSOZVu_-Ny8sl4-aAKzeN-H",
    "maxResultsPerName": 10,
    "connectionDegree": "",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/linkedin-profile-search-by-name").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 = {
    "names": [
        "John Smith",
        "Jane Williams",
    ],
    "cookie": "AQEDATVc5uMEM5s_AAABnro67cYAAAGe3kdxxk0Ajoj1en-Axa4lUoxvqVMAsMpFO2u4rOjJfIS1U1wrBETHJHqkj5i6KReB53dmYSZDgX9K4XnaFLmn7vE30gVWegfZltSOZVu_-Ny8sl4-aAKzeN-H",
    "maxResultsPerName": 10,
    "connectionDegree": "",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/linkedin-profile-search-by-name").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 '{
  "names": [
    "John Smith",
    "Jane Williams"
  ],
  "cookie": "AQEDATVc5uMEM5s_AAABnro67cYAAAGe3kdxxk0Ajoj1en-Axa4lUoxvqVMAsMpFO2u4rOjJfIS1U1wrBETHJHqkj5i6KReB53dmYSZDgX9K4XnaFLmn7vE30gVWegfZltSOZVu_-Ny8sl4-aAKzeN-H",
  "maxResultsPerName": 10,
  "connectionDegree": "",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/linkedin-profile-search-by-name --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Profile Search by Name",
        "description": "Find LinkedIn profiles by person name. Input a list of names and get matching profiles with name, headline, location, and profile URL.",
        "version": "1.33",
        "x-build-id": "sugUNgHhOehkY1khI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~linkedin-profile-search-by-name/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-linkedin-profile-search-by-name",
                "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/crawlerbros~linkedin-profile-search-by-name/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-linkedin-profile-search-by-name",
                "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/crawlerbros~linkedin-profile-search-by-name/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-linkedin-profile-search-by-name",
                "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": [
                    "names",
                    "cookie"
                ],
                "properties": {
                    "names": {
                        "title": "Names to search",
                        "type": "array",
                        "description": "List of person names to search on LinkedIn. Each name is searched separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cookie": {
                        "title": "LinkedIn Cookie (li_at)",
                        "type": "string",
                        "description": "Your LinkedIn session cookie. Either paste the plain li_at token value, or a JSON array of cookies exported from a browser extension (e.g. EditThisCookie). Required for accessing LinkedIn's search API."
                    },
                    "maxResultsPerName": {
                        "title": "Max results per name",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of LinkedIn profiles to return for each name in the input list.",
                        "default": 10
                    },
                    "location": {
                        "title": "Location filter",
                        "type": "string",
                        "description": "Free-text location to filter results (e.g. \"New York\", \"United Kingdom\", \"San Francisco Bay Area\")."
                    },
                    "currentCompany": {
                        "title": "Current company filter",
                        "type": "string",
                        "description": "Filter results to people currently working at this company (e.g. \"Microsoft\", \"Google\")."
                    },
                    "school": {
                        "title": "School filter",
                        "type": "string",
                        "description": "Filter results to alumni of this school (e.g. \"Stanford University\", \"MIT\")."
                    },
                    "industry": {
                        "title": "Industry filter",
                        "type": "string",
                        "description": "Filter by industry. Accepts free text (e.g. \"Software Development\", \"Financial Services\")."
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en_US",
                            "en_GB",
                            "es_ES",
                            "fr_FR",
                            "de_DE",
                            "pt_BR",
                            "it_IT",
                            "nl_NL",
                            "ja_JP",
                            "zh_CN"
                        ],
                        "type": "string",
                        "description": "Preferred LinkedIn locale for the session.",
                        "default": "en_US"
                    },
                    "connectionDegree": {
                        "title": "Connection degree",
                        "enum": [
                            "",
                            "F",
                            "S",
                            "O"
                        ],
                        "type": "string",
                        "description": "Filter by LinkedIn connection degree. Leave blank for all connections.",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. LinkedIn works best with residential 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
