# LinkedIn Search Scraper · No Cookies · 6 Types · From $1/1k ✅ (`linkedintel/linkedin-search-scraper-no-cookies`) Actor

Search LinkedIn by keyword across 6 entity types (people, companies, posts, jobs, services, schools). No cookies, no login. Pay-per-result from $1/1k.

- **URL**: https://apify.com/linkedintel/linkedin-search-scraper-no-cookies.md
- **Developed by:** [LinkedIntel](https://apify.com/linkedintel) (community)
- **Categories:** Lead generation
- **Stats:** 19 total users, 5 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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.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 Search Scraper — No Login, 6 Entity Types in One

Search LinkedIn by keyword across **6 entity types** with one input schema: **people, companies, posts, jobs, services, and schools**. Clean structured JSON output. **No LinkedIn login, no cookies, no browser session, no account ban risk.**

Built for **B2B sales prospecting, lead generation, competitive intelligence, recruiting, market research, and CRM enrichment**.

---

### How this compares to other LinkedIn search scrapers

We benchmarked the direct competitors on Apify Store. Here's the honest landscape:

| | harvestapi/linkedin-profile-search | supreme_coder/linkedin-profile-scraper | supreme_coder/linkedin-post | get-leads/linkedin-scraper | practicaltools/linkedin-jobs | **This actor** |
|---|---|---|---|---|---|---|
| **People** | $4/1k (search-page) → $10/1k (with email) | $3/1k (URL enrichment, not search) | — | $2/1k | — | **$3/1k** ✅ undercuts harvestapi 25% |
| **Companies** | — | — | — | $2/1k | — | **$2/1k** ✅ matches market |
| **Posts** | — | — | $1/1k | $1.50/1k | — | **$1.50/1k** ✅ matches market |
| **Jobs** | — | — | — | $1/1k | $1/1k | **$1/1k** ✅ matches market |
| **Services** | — | — | — | — | — | **$2/1k** 🆕 only option |
| **Schools** | — | — | — | — | — | **$2/1k** 🆕 only option |
| **One input schema for all entity types?** | ❌ | ❌ | ❌ | ❌ (8 separate modes) | ❌ | ✅ Pick `entityType`, that's it |
| **No login / no cookies** | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
| **Source code visibility** | Public | Public | Public | Public | Public | **Hidden (paid-tier protection)** |

**Bottom line:** Most competitors are single-entity scrapers — one for people, one for posts, one for jobs. **This actor is the consolidator priced at market rates for every entity type.** One integration, one billing line, six search modes — and you pay the going rate for each, not a "bundle penalty."

### What you get — 6 record types

For each search run, the actor returns records of one type matching your `entityType` setting:

#### 1. `personResult` — PEOPLE search (10+ fields)
- Identity: fullName, firstName, lastName, profileId, profileUrl
- Profile: headline, location, profilePictureUrl, isPremium
- Search metadata: searchKeyword, entityType, scrapedAt

#### 2. `companyResult` — COMPANIES search (10+ fields)
- Identity: companyName, companyId, linkedinUrl
- Detail: summary, industry, location, followersCountDisplay, logoUrl
- Search metadata: searchKeyword, entityType, scrapedAt

#### 3. `postResult` — POSTS search (17+ fields)
- Post: postId, postUrl, postUrn, text, textAttributes, postedAt
- Author: authorName, authorHeadline, authorProfileUrl, authorProfileId
- Engagement: reactionsCount, commentsCount, repostsCount
- Media: mediaType, mediaUrl, mediaCount
- Search metadata: searchKeyword, entityType, scrapedAt

#### 4. `jobResult` — JOBS search (13+ fields)
- Job: jobId, jobUrl, title, location, isPromoted, isEasyApply, insightText
- Company: companyName, companyLogoUrl
- Timing: listedAt (ISO 8601), listedAtMs (Unix ms)
- Search metadata: searchKeyword, entityType, scrapedAt

#### 5. `serviceResult` — SERVICES search (10+ fields)
- Service: serviceId, serviceUrl, title
- Provider: providerName, providerHeadline, providerLocation, providerPhotoUrl
- Search metadata: searchKeyword, entityType, scrapedAt

#### 6. `schoolResult` — SCHOOLS search (9+ fields)
- School: schoolId, schoolUrl, name, location
- Scale: studentsAndAlumniCount
- Media: logoUrl
- Search metadata: searchKeyword, entityType, scrapedAt

Plus a `diagnostic` record when no results are returned, and a final `summary` record per run.

### Use cases (top 8)

#### 1. B2B lead generation — find decision-makers by title + company
Set `entityType=PEOPLE`, `keyword="CEO"`, `company="Series A startup"`. Get a list of founders/CEOs with public profile data ready to enrich.

#### 2. Account-Based Marketing (ABM) — find prospect companies by industry
Set `entityType=COMPANIES`, `keyword="fintech"`, `industry="Financial Services"`. Pull target accounts for outreach campaigns.

#### 3. Competitive intelligence — track competitor activity via posts
Set `entityType=POSTS`, `keyword="<competitor name>"`. Pull their recent LinkedIn activity, reaction counts, comment volume. Identify their loudest content themes.

#### 4. Recruiting — sourcing candidates by skill + location
Set `entityType=PEOPLE`, `keyword="Rust developer"`, `location="Berlin"`. Build a candidate list with public profile data.

#### 5. Job-market intelligence — analyze open roles for a target company
Set `entityType=JOBS`, `keyword="<your competitor>"`. Map their hiring intent — engineering hires signal product investments, sales hires signal GTM expansion.

#### 6. Vendor/freelancer discovery — find LinkedIn services providers
Set `entityType=SERVICES`, `keyword="brand strategy"`. Surface freelancers + agencies offering specific services.

#### 7. University alumni outreach
Set `entityType=SCHOOLS`, `keyword="Stanford"`. Get school IDs that you can then use to find specific alumni at LinkedIn-scale.

#### 8. Topic-based content monitoring
Set `entityType=POSTS`, `keyword="AI agents"`. Daily monitor the topic — feeds your content team's editorial calendar with trending themes.

### How it works

1. Set `keyword` to your search query (required).
2. Set `entityType` to one of `PEOPLE`, `COMPANIES`, `POSTS`, `JOBS`, `SERVICES`, `SCHOOLS` (default `PEOPLE`).
3. Set `maxResults` (1-1000, default 50).
4. Optionally add filters: `location`, `company`, `title`, `industry` (filters apply where the underlying source supports them).
5. The actor paginates through results and emits records as they arrive.

No login required. No cookies. The actor uses a managed data partnership that gives us cookieless LinkedIn access at vendor cost — no account ban risk on your side, no session management.

### Example input

```json
{
  "keyword": "head of growth",
  "entityType": "PEOPLE",
  "location": "United States",
  "title": "Head of Growth",
  "maxResults": 100
}
````

Returns up to 100 `personResult` records, each with name, headline, location, profile URL, and search metadata.

### Pricing — pay only for results, priced for each entity type

**Differential pay-per-result pricing — pay the right rate for each entity type:**

| Entity type | Price per 1,000 records | Why this price |
|---|---|---|
| **PEOPLE** | $3.00 | Undercuts harvestapi search-page ($4/1k) by 25%; matches market for search-level depth |
| **COMPANIES** | $2.00 | Matches get-leads market rate |
| **POSTS** | $1.50 | Between supreme\_coder ($1/1k) and get-leads ($1.50/1k); 17 fields = richer output |
| **JOBS** | $1.00 | Matches practicaltools/get-leads — commodity-data segment |
| **SERVICES** | $2.00 | No direct competitor (uncontested niche) |
| **SCHOOLS** | $2.00 | No direct competitor (uncontested niche) |

- ✅ No subscription, no monthly minimum, no per-run start fee
- ✅ No charge for failed runs or unresolvable queries (clean diagnostic record)
- ✅ Apify's free tier ($5/month platform credit) covers ~5,000 records of cheapest type
- ✅ Each entity type priced at market rate — never paying a bundle penalty

### Combine with other LinkedIn actors

Build a complete LinkedIn intelligence pipeline:

- Pipe `personResult.profileUrl` into a LinkedIn profile enricher
- Pipe `postResult.postUrn` into the **LinkedIn Post Comments Scraper** for full comment threads
- Pipe `postResult.postUrn` into the **LinkedIn Post Reactions Scraper** for full reactor lists
- Pipe `companyResult.companyId` into the **LinkedIn Company Scraper** for full firmographics
- Pipe `jobResult.jobUrl` into LinkedIn jobs scrapers for full job descriptions

### FAQ

**Q: Why is this cheaper than harvestapi?**
Direct vendor partnership at scale. We negotiated cookieless LinkedIn access at lower vendor cost and pass the savings through. Pure pay-per-result, no monthly fees.

**Q: Do you store my search queries or returned data?**
No. Apify's standard data-retention applies (default 7 days, configurable). Data exists in your dataset only.

**Q: What if my search returns 0 results?**
The actor emits a single `diagnostic` record with the reason. You aren't charged for the 0 results — only for actual records returned.

**Q: How many results can I get per search?**
LinkedIn's vendor API caps at ~1000 results per search query (vendor limit, not ours). The `maxResults` input caps at 1000.

**Q: Can I run multiple searches in parallel?**
Yes. Apify lets you queue multiple runs of the same actor. Each run is billed independently.

**Q: Do you support boolean operators in keyword?**
LinkedIn's search treats keyword as a free-text query. Quoting, AND, OR, NOT are supported at the LinkedIn-search level. Use natural-language queries for best results.

**Q: What's the difference between `keyword` and filter fields (location/title/company)?**
`keyword` is the primary search term. `location`/`title`/`company` are post-filters applied to PEOPLE results. For other entity types, filters are best-effort (vendor support varies).

**Q: Why is `industry` filter sometimes empty?**
LinkedIn's industry filter uses numeric IDs (URNs) for strict matching. Free-text industry names work sometimes. For consistent industry filtering, use the keyword field directly.

**Q: Is this safe to use vs my LinkedIn account?**
Yes. No login, no cookies, no browser session. The actor never authenticates as you. Your LinkedIn account is not involved.

**Q: Where do I report bugs?**
Open an issue on the actor's Apify Store page or message the publisher directly.

### Privacy & compliance

This actor scrapes **publicly accessible LinkedIn search results**. We do not access private profiles, gated content, or content requiring login. The data returned is the same data any logged-out visitor can see by browsing LinkedIn's public search.

LinkedIn user content may be subject to LinkedIn's Terms of Use, applicable copyright laws, and platform rate limits. Customers are responsible for compliance with applicable data protection laws (GDPR, CCPA, etc.) when processing scraped data.

Not affiliated with, endorsed by, or sponsored by LinkedIn Corporation or Microsoft Corporation.

# Actor input Schema

## `keyword` (type: `string`):

The search term. Examples: 'python developer', 'OpenAI', 'AI agents', 'Senior Engineer', 'Marketing Strategy', 'Harvard'.

## `entityType` (type: `string`):

Which LinkedIn entity type to search across.

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

Hard cap on how many records to return. Vendor returns 10 per page; cap is 1000.

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

Optional. Free-text location filter (e.g. 'United States', 'London', 'Berlin'). Most useful for PEOPLE and JOBS.

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

Optional. Filter results by current company (e.g. 'Microsoft'). Most useful for PEOPLE.

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

Optional. Filter results by job title (e.g. 'CEO', 'Software Engineer'). Most useful for PEOPLE.

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

Optional. Filter results by industry name (e.g. 'Software', 'Financial Services'). Most useful for PEOPLE and COMPANIES.

## Actor input object example

```json
{
  "keyword": "python developer",
  "entityType": "PEOPLE",
  "maxResults": 50
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("linkedintel/linkedin-search-scraper-no-cookies").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("linkedintel/linkedin-search-scraper-no-cookies").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 '{}' |
apify call linkedintel/linkedin-search-scraper-no-cookies --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Search Scraper · No Cookies · 6 Types · From $1/1k ✅",
        "description": "Search LinkedIn by keyword across 6 entity types (people, companies, posts, jobs, services, schools). No cookies, no login. Pay-per-result from $1/1k.",
        "version": "1.0",
        "x-build-id": "NjI8rzCs6ORk7Z3Uk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/linkedintel~linkedin-search-scraper-no-cookies/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-linkedintel-linkedin-search-scraper-no-cookies",
                "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/linkedintel~linkedin-search-scraper-no-cookies/runs": {
            "post": {
                "operationId": "runs-sync-linkedintel-linkedin-search-scraper-no-cookies",
                "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/linkedintel~linkedin-search-scraper-no-cookies/run-sync": {
            "post": {
                "operationId": "run-sync-linkedintel-linkedin-search-scraper-no-cookies",
                "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": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "The search term. Examples: 'python developer', 'OpenAI', 'AI agents', 'Senior Engineer', 'Marketing Strategy', 'Harvard'."
                    },
                    "entityType": {
                        "title": "What to search for",
                        "enum": [
                            "PEOPLE",
                            "COMPANIES",
                            "POSTS",
                            "JOBS",
                            "SERVICES",
                            "SCHOOLS"
                        ],
                        "type": "string",
                        "description": "Which LinkedIn entity type to search across.",
                        "default": "PEOPLE"
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on how many records to return. Vendor returns 10 per page; cap is 1000.",
                        "default": 50
                    },
                    "location": {
                        "title": "Filter: Location",
                        "type": "string",
                        "description": "Optional. Free-text location filter (e.g. 'United States', 'London', 'Berlin'). Most useful for PEOPLE and JOBS."
                    },
                    "company": {
                        "title": "Filter: Current company",
                        "type": "string",
                        "description": "Optional. Filter results by current company (e.g. 'Microsoft'). Most useful for PEOPLE."
                    },
                    "title": {
                        "title": "Filter: Job title",
                        "type": "string",
                        "description": "Optional. Filter results by job title (e.g. 'CEO', 'Software Engineer'). Most useful for PEOPLE."
                    },
                    "industry": {
                        "title": "Filter: Industry",
                        "type": "string",
                        "description": "Optional. Filter results by industry name (e.g. 'Software', 'Financial Services'). Most useful for PEOPLE and COMPANIES."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
