# LinkedIn Employee Search | X-Ray | No Login & 🍪 | Bulk (`aeonkosmos/linkedin-employee-search`) Actor

Find employees at any company on LinkedIn — by job title, location, and seniority. No login, no cookies, zero ban risk. X-ray search powered. Up to 100 employees per company, multi-country support. Bulk mode: search 100 companies in one run. No results = no charge.

- **URL**: https://apify.com/aeonkosmos/linkedin-employee-search.md
- **Developed by:** [Eugene Volper](https://apify.com/aeonkosmos) (community)
- **Categories:** Automation, Lead generation, Jobs
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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 Employee Search — Find People at Any Company | X-Ray Search

Find employees at any company on LinkedIn — filter by job title, location, and seniority. No login, no cookies, zero ban risk.

**No LinkedIn account needed | X-ray search powered | Results in seconds**

> **Not a scraper.** We use X-ray search — the same technique recruiters use manually, but automated. We never touch LinkedIn's servers. There's nothing for LinkedIn to block.

---

### How to Find Employees on LinkedIn Without an Account

This tool automates LinkedIn X-ray search to find employees at any company. Enter a company name, optionally filter by job title and location, and get structured results in seconds.

1. Enter the company name (as it appears on LinkedIn)
2. Optionally add job title filter (e.g., "VP Sales", "Engineer")
3. Optionally add location filter (e.g., "San Francisco")
4. Choose search pattern (1 = strictest, 4 = broadest)
5. Get employee profiles with name, headline, photo, and LinkedIn URL

---

### What You Get

Each result returns structured JSON:

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Full LinkedIn profile URL |
| `name` | string | Full name as shown on LinkedIn |
| `headline` | string | LinkedIn headline (e.g., "VP Sales at Stripe") |
| `photoUrl` | string | Profile photo URL |
| `firstName` | string | First name (parsed from metadata) |
| `lastName` | string | Last name (parsed from metadata) |

---

### LinkedIn Employee Search Patterns

| Pattern | Query Style | Best For |
|---------|-------------|----------|
| 1 (default) | Strict — exact match in title | Most precise results |
| 2 | Moderate — words matched separately | Slightly broader |
| 3 | Broad — phrase match across profile | More results |
| 4 | Broadest — keyword match | Maximum results |
| 5 | Custom — your own query | Full control |

**Start with Pattern 1** and broaden only if you need more results.

---

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `companyName` | string | Yes* | — | Company name (patterns 1-4) |
| `title` | string | No | `""` | Job title filter (e.g., "VP Sales") |
| `location` | string | No | `""` | Location (e.g., "San Francisco") |
| `excludeWords` | string | No | `""` | Keyword to exclude (e.g., "Intern") |
| `employeePattern` | string | No | `"1"` | Search pattern (1-5) |
| `customQuery` | string | No* | — | Your full query (pattern 5 only) |
| `employeeCountries` | string | No | `""` | Comma-separated country codes |
| `employeeMaxResults` | integer | No | `10` | Max profiles per country (1-100) |
| `loadAll` | boolean | No | `false` | Auto-paginate all results |
| `bulkCompanies` | string | No | — | Bulk mode: one company per line |
| `bulkDelayMs` | integer | No | `1500` | Delay between bulk searches (ms) |

---

### LinkedIn Company Employee Search — Examples

#### Find Engineers at OpenAI

```json
{
    "companyName": "OpenAI",
    "title": "Engineer",
    "employeeMaxResults": 30
}
````

#### Find Sales Leaders Across Countries

```json
{
    "companyName": "Salesforce",
    "title": "VP Sales",
    "employeeCountries": "us, uk, de",
    "employeeMaxResults": 20
}
```

#### Bulk Search — 100 Companies at Once

```json
{
    "bulkCompanies": "Marriott International, CFO\nHilton Worldwide, Director of Sales, London, uk\nGoogle\nAmazon",
    "employeeMaxResults": 10
}
```

#### Custom X-Ray Query (Pattern 5)

```json
{
    "employeePattern": "5",
    "customQuery": "site:linkedin.com/in \"VP Sales\" \"San Francisco\" -recruiter -intern"
}
```

***

### How to Look for Employees on LinkedIn — Use Cases

- **Sales prospecting** — Find decision-makers at target accounts by title and location
- **Recruiting / X-ray search** — Automate the X-ray search recruiters do manually
- **Competitive intelligence** — See who competitors are hiring and where
- **Account-based marketing** — Build contact lists for specific companies
- **Lead list building** — Prospect lists filtered by title, company, and location
- **Conference prep** — Research attendees and their companies before events

***

### Why Use This Instead of LinkedIn Sales Navigator?

| Feature | LinkedIn Sales Navigator | This Tool |
|---------|--------------------------|-----------|
| Monthly cost | $79.99-$149.99/mo | Pay per result |
| LinkedIn account needed | Yes (premium) | **No** |
| Account ban risk | N/A (official) | **Zero** |
| Breaks when LinkedIn updates | Rarely | **Never** |
| Speed per 10 results | Manual clicking | **< 5 seconds** |
| API access | No | **Yes** |
| Bulk search | Manual | **Up to 100 companies** |

***

### Reliable Results — Data That Survives Interruption

- **Incremental saving** — Every profile is saved the moment it's found. If a run stops mid-way, you keep everything collected so far.
- **Automatic deduplication** — Same profile URL never appears twice. You never pay for duplicates.
- **Retry with backoff** — Transient API failures retried automatically (3 attempts with exponential backoff).
- **Stable infrastructure** — We don't depend on LinkedIn's page structure, so updates don't affect us.

***

### API Integration

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("your_api_token")
run = client.actor("aeonkosmos/linkedin-employee-search").call(run_input={
    "companyName": "Stripe",
    "title": "Engineer",
    "employeeMaxResults": 20
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['name']} — {item['url']}")
```

#### JavaScript

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

const client = new ApifyClient({ token: 'your_api_token' });
const run = await client.actor('aeonkosmos/linkedin-employee-search').call({
    companyName: 'Stripe',
    title: 'Engineer',
    employeeMaxResults: 20
});

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

#### cURL

```bash
curl "https://api.apify.com/v2/acts/aeonkosmos~linkedin-employee-search/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer your_api_token" \
  -d '{"companyName":"Stripe","title":"Engineer","employeeMaxResults":20}'
```

***

### Tips for Best Results

1. **Use exact company names** — "National Bank of Canada" not "National Bank"
2. **Start with Pattern 1** — broaden only if too few results
3. **Use the title filter** — "VP Sales" returns better results than no filter
4. **Add exclude words** — "Intern" removes noise
5. **Pattern 5** gives full control — use any search operators you know

***

### Limitations (Honest)

- **Results are not 100% accurate** — may include former employees or loosely related profiles. Manual review recommended.
- **Maximum 100 results per search** — infrastructure limit
- **Returns URLs + basic info only** — not full profile data (experience, education, skills, email)
- **No email enrichment** — pair with an email finder tool if needed
- Results come from publicly indexed data — very new profiles may not appear yet

***

### FAQ

**Q: How is this different from a LinkedIn scraper?**
A: We never touch LinkedIn's servers. We find profiles through publicly indexed data — LinkedIn can't block what doesn't hit their infrastructure.

**Q: How do I find employees of a company on LinkedIn?**
A: Enter the company name, optionally add a job title filter, and run the search. Results include name, headline, photo, and LinkedIn URL for each employee found.

**Q: Can I search without a LinkedIn account?**
A: Yes — that's exactly what this tool does. No LinkedIn account, cookies, or login credentials needed.

**Q: How many employees can I find per company?**
A: Up to 100 per country. With multi-country search (e.g., us, uk, de), each country gets its own limit — 3 countries × 100 = up to 300 profiles.

**Q: What about bulk search?**
A: Use the bulk mode to search up to 100 companies in a single run. One company per line, with optional title and location per line.

***

### Support

Email: grow@nomad.email
Response time: < 24 hours

***

### Legal

This tool finds LinkedIn profile URLs through publicly indexed data. It does not scrape LinkedIn, access private profiles, bypass authentication, or use LinkedIn credentials.

Users are responsible for ensuring their use of extracted data complies with applicable laws, including GDPR and other data protection regulations.

# Actor input Schema

## `service` (type: `string`):

Which mode to use

## `companyName` (type: `string`):

Exact company name as it appears on LinkedIn (e.g., 'National Bank of Canada').

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

Single keyword to include in search (e.g., 'Engineer', 'Manager', 'Sales'). Only one keyword supported.

## `excludeWords` (type: `string`):

One keyword to exclude from results (e.g., 'Intern'). Only one keyword supported.

## `employeePattern` (type: `string`):

How to construct the search query. Start with Pattern 1 (strictest).

## `employeeCountries` (type: `string`):

Comma-separated country codes (e.g. uk, us, de). Leave empty for global search.

## `employeeMaxResults` (type: `integer`):

Max employee profiles to return. Default 100. You pay per profile.

## `bulkCompanies` (type: `string`):

One company per line. Format: CompanyName, Keyword, Country (keyword and country optional).

Example:
Marriott International, CFO
Hilton Worldwide, Director of Sales, uk
Google
Amazon

## `bulkEmployeePattern` (type: `string`):

How to construct the search query. Start with Pattern 1 (strictest).

## `bulkEmployeeKeyword` (type: `string`):

Single keyword to include in every search (e.g., 'Engineer'). Only one keyword. Optional.

## `bulkMaxResultsPerCompany` (type: `integer`):

Max employee profiles per company. Default 100. You pay per profile.

## `bulkDelayMs` (type: `integer`):

Milliseconds to wait between searches. Lower = faster but may hit rate limits.

## `loadAll` (type: `boolean`):

Automatically paginate to load all results up to your max limit. If OFF, returns only the first page (up to 10).

## Actor input object example

```json
{
  "service": "single",
  "companyName": "OpenAI",
  "employeePattern": "1",
  "employeeMaxResults": 100,
  "bulkEmployeePattern": "1",
  "bulkMaxResultsPerCompany": 100,
  "bulkDelayMs": 1500,
  "loadAll": 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 = {
    "companyName": "OpenAI"
};

// Run the Actor and wait for it to finish
const run = await client.actor("aeonkosmos/linkedin-employee-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 = { "companyName": "OpenAI" }

# Run the Actor and wait for it to finish
run = client.actor("aeonkosmos/linkedin-employee-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 '{
  "companyName": "OpenAI"
}' |
apify call aeonkosmos/linkedin-employee-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Employee Search | X-Ray | No Login & 🍪 | Bulk",
        "description": "Find employees at any company on LinkedIn — by job title, location, and seniority. No login, no cookies, zero ban risk. X-ray search powered. Up to 100 employees per company, multi-country support. Bulk mode: search 100 companies in one run. No results = no charge.",
        "version": "1.0",
        "x-build-id": "LQgIYA26DLr0CegHs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/aeonkosmos~linkedin-employee-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-aeonkosmos-linkedin-employee-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/aeonkosmos~linkedin-employee-search/runs": {
            "post": {
                "operationId": "runs-sync-aeonkosmos-linkedin-employee-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/aeonkosmos~linkedin-employee-search/run-sync": {
            "post": {
                "operationId": "run-sync-aeonkosmos-linkedin-employee-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",
                "required": [
                    "service"
                ],
                "properties": {
                    "service": {
                        "title": "Service",
                        "enum": [
                            "single",
                            "bulk"
                        ],
                        "type": "string",
                        "description": "Which mode to use",
                        "default": "single"
                    },
                    "companyName": {
                        "title": "Company Name",
                        "type": "string",
                        "description": "Exact company name as it appears on LinkedIn (e.g., 'National Bank of Canada')."
                    },
                    "title": {
                        "title": "Include Keyword",
                        "type": "string",
                        "description": "Single keyword to include in search (e.g., 'Engineer', 'Manager', 'Sales'). Only one keyword supported."
                    },
                    "excludeWords": {
                        "title": "Exclude Keyword",
                        "type": "string",
                        "description": "One keyword to exclude from results (e.g., 'Intern'). Only one keyword supported."
                    },
                    "employeePattern": {
                        "title": "Search Pattern",
                        "enum": [
                            "1",
                            "2",
                            "3",
                            "4"
                        ],
                        "type": "string",
                        "description": "How to construct the search query. Start with Pattern 1 (strictest).",
                        "default": "1"
                    },
                    "employeeCountries": {
                        "title": "Countries",
                        "type": "string",
                        "description": "Comma-separated country codes (e.g. uk, us, de). Leave empty for global search."
                    },
                    "employeeMaxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Max employee profiles to return. Default 100. You pay per profile.",
                        "default": 100
                    },
                    "bulkCompanies": {
                        "title": "Companies (one per line)",
                        "type": "string",
                        "description": "One company per line. Format: CompanyName, Keyword, Country (keyword and country optional).\n\nExample:\nMarriott International, CFO\nHilton Worldwide, Director of Sales, uk\nGoogle\nAmazon"
                    },
                    "bulkEmployeePattern": {
                        "title": "Search Pattern",
                        "enum": [
                            "1",
                            "2",
                            "3",
                            "4"
                        ],
                        "type": "string",
                        "description": "How to construct the search query. Start with Pattern 1 (strictest).",
                        "default": "1"
                    },
                    "bulkEmployeeKeyword": {
                        "title": "Include Keyword",
                        "type": "string",
                        "description": "Single keyword to include in every search (e.g., 'Engineer'). Only one keyword. Optional."
                    },
                    "bulkMaxResultsPerCompany": {
                        "title": "Max Results Per Company",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Max employee profiles per company. Default 100. You pay per profile.",
                        "default": 100
                    },
                    "bulkDelayMs": {
                        "title": "Delay Between Searches (ms)",
                        "minimum": 500,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Milliseconds to wait between searches. Lower = faster but may hit rate limits.",
                        "default": 1500
                    },
                    "loadAll": {
                        "title": "Load All Results",
                        "type": "boolean",
                        "description": "Automatically paginate to load all results up to your max limit. If OFF, returns only the first page (up to 10).",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```