# PRO Post Reactions LinkedIn Scraper (`dendelabs/linkedin-reactions-scraper-pro`) Actor

Extract all reactions from LinkedIn posts with auto-pagination, incremental scraping, headline filters, and analytics. No LinkedIn account needed.

- **URL**: https://apify.com/dendelabs/linkedin-reactions-scraper-pro.md
- **Developed by:** [Dende Labs API](https://apify.com/dendelabs) (community)
- **Categories:** Social media, Automation, Lead generation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

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 Post Reactions Scraper Pro

Extract detailed reaction data from any LinkedIn post — including reactor names, headlines, profile URLs, and photos. Supports batch processing of up to 1,000 posts in a single run.

**No LinkedIn account or cookies required.**

> 💡 **For other LinkedIn tools by Dende Labs**, check: https://apify.com/dendelabs

---

### ✨ Key Features

| Feature | Description |
|---------|-------------|
| 🔄 **Auto-pagination** | One run extracts ALL reactions. No manual page management. |
| 📦 **Batch processing** | Scrape up to 1,000 posts in a single run. |
| 🔍 **Headline keyword filters** | Only include reactors matching specific keywords (e.g., "CEO", "VP"). |
| 🏢 **Company detection** | Each reactor is flagged as person or company page. |
| 📊 **Incremental tracking** | Compare with previous runs — each reactor is marked as `new` or `existing`. |
| 🚫 **Exclude companies** | Filter out company pages, keep only people. |
| 🔗 **All URL formats** | Paste any LinkedIn post link — even with tracking parameters. |
| 🔐 **No cookies needed** | No risk of account restrictions or bans. |

---

### 📥 Input

#### Basic Usage

Just paste one or more LinkedIn post URLs:

```json
{
  "postUrls": [
    "https://www.linkedin.com/posts/satyanadella_no-one-becomes-a-clinician-to-do-paperwork-activity-7302346926123798528-jitu"
  ]
}
````

#### All Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `postUrls` | string\[] | ✅ Yes | — | LinkedIn post URLs or activity IDs (up to 1,000) |
| `reactionType` | string | No | `ALL` | Filter: `ALL`, `LIKE`, `PRAISE`, `EMPATHY`, `APPRECIATION`, `INTEREST`, `ENTERTAINMENT` |
| `maxReactions` | integer | No | `0` | Max reactions per post. `0` = unlimited |
| `headlineKeywords` | string\[] | No | `[]` | Only include reactors whose headline contains these keywords |
| `excludeCompanies` | boolean | No | `false` | Exclude company/org pages from results |
| `previousDatasetId` | string | No | — | Dataset ID from previous run for incremental tracking |
| `metadataOnly` | boolean | No | `false` | Only fetch reaction counts, not individual reactions (see [Metadata Only Mode](#example-8-metadata-only--check-reaction-count-before-scraping)) |

#### Supported URL Formats

All of these work — just paste whatever you have:

```
✅ https://www.linkedin.com/posts/satyanadella_activity-7302346926123798528-jitu
✅ https://www.linkedin.com/feed/update/urn:li:activity:7302346926123798528/
✅ https://www.linkedin.com/feed/update/urn:li:share:7302346926123798528/
✅ https://www.linkedin.com/posts/user_slug-activity-123/?utm_source=share&utm_medium=...
✅ 7302346926123798528
```

***

### 📤 Output

#### Single Reaction

Each reaction in the dataset looks like this:

```json
{
  "reaction_type": "LIKE",
  "is_company": false,
  "reactor": {
    "id": "ACoAAB8v74YB5oqaAg-4F2VRFh9tEt0zXfRsjpE",
    "name": "Ashish Pandey",
    "headline": "Head of Ops @ Wiz Labs",
    "linkedinUrl": "https://www.linkedin.com/in/ACoAAB8v74YB...",
    "profile_pic": "https://media.licdn.com/dms/image/v2/..."
  },
  "_metadata": {
    "post_url": "https://www.linkedin.com/posts/satyanadella_...",
    "activity_id": "urn:li:activity:7302346926123798528",
    "extracted_at": "2026-03-30T12:00:00.000Z"
  }
}
```

#### Company Reactor Example

When a company page reacts to a post, `is_company` is `true`:

```json
{
  "reaction_type": "LIKE",
  "is_company": true,
  "reactor": {
    "id": "106345960",
    "name": "Dende Labs",
    "headline": "2 followers",
    "linkedinUrl": "https://www.linkedin.com/company/dendelabs/",
    "profile_pic": null
  },
  "_metadata": {
    "post_url": "https://www.linkedin.com/posts/...",
    "activity_id": "urn:li:activity:7399183215997108224",
    "extracted_at": "2026-03-30T12:00:00.000Z"
  }
}
```

#### Output Fields Reference

| Field | Type | Description |
|-------|------|-------------|
| `reaction_type` | string | `LIKE`, `PRAISE`, `EMPATHY`, `APPRECIATION`, `INTEREST`, or `ENTERTAINMENT` |
| `is_company` | boolean | `true` if the reactor is a company page, `false` if a person |
| `is_new` | boolean | Only present when using incremental tracking. `true` = new reactor, `false` = seen before |
| `reactor.id` | string | LinkedIn profile or company URN |
| `reactor.name` | string | Full name of the person or company |
| `reactor.headline` | string | LinkedIn headline / tagline |
| `reactor.linkedinUrl` | string | Direct link to the reactor's LinkedIn profile |
| `reactor.profile_pic` | string | URL to profile photo (800x800) or `null` |
| `_metadata.post_url` | string | The original post URL you provided as input |
| `_metadata.activity_id` | string | LinkedIn activity URN of the post |
| `_metadata.extracted_at` | string | ISO timestamp of when the data was extracted |

***

### 📌 Examples

#### Example 1: Get all reactions from a single post

```json
{
  "postUrls": [
    "https://www.linkedin.com/posts/satyanadella_no-one-becomes-a-clinician-to-do-paperwork-activity-7302346926123798528-jitu"
  ]
}
```

#### Example 2: Batch — scrape reactions from multiple posts

```json
{
  "postUrls": [
    "https://www.linkedin.com/posts/satyanadella_activity-7302346926123798528-jitu",
    "https://www.linkedin.com/posts/billgates_activity-7300000000000000000-abcd",
    "https://www.linkedin.com/feed/update/urn:li:activity:7298765432109876543/"
  ]
}
```

#### Example 3: Only get reactions from decision-makers

Use `headlineKeywords` to filter reactors by their LinkedIn headline:

```json
{
  "postUrls": [
    "https://www.linkedin.com/posts/satyanadella_activity-7302346926123798528-jitu"
  ],
  "headlineKeywords": ["CEO", "CTO", "VP", "Founder", "Director", "Head of"]
}
```

Only reactors whose headline contains at least one of these keywords will be included.

#### Example 4: Only people, no company pages

```json
{
  "postUrls": [
    "https://www.linkedin.com/posts/satyanadella_activity-7302346926123798528-jitu"
  ],
  "excludeCompanies": true
}
```

#### Example 5: Filter by reaction type

```json
{
  "postUrls": [
    "https://www.linkedin.com/posts/satyanadella_activity-7302346926123798528-jitu"
  ],
  "reactionType": "PRAISE"
}
```

Available types: `ALL`, `LIKE`, `PRAISE` (Celebrate), `EMPATHY` (Love), `APPRECIATION` (Insightful), `INTEREST` (Curious), `ENTERTAINMENT` (Funny)

#### Example 6: Limit results per post

```json
{
  "postUrls": [
    "https://www.linkedin.com/posts/satyanadella_activity-7302346926123798528-jitu"
  ],
  "maxReactions": 500
}
```

#### Example 7: Incremental tracking — detect new reactors

First run — scrape all reactions:

```json
{
  "postUrls": ["https://www.linkedin.com/posts/satyanadella_activity-7302346926123798528-jitu"]
}
```

Second run — pass the previous dataset ID to tag each reactor as `new` or `existing`:

```json
{
  "postUrls": ["https://www.linkedin.com/posts/satyanadella_activity-7302346926123798528-jitu"],
  "previousDatasetId": "abc123xyz"
}
```

Each reactor in the output will have an `is_new` field:

- `true` — this reactor was NOT in the previous dataset (new engagement)
- `false` — this reactor was already in the previous dataset

> 💡 You can find the dataset ID in the Apify Console under the **Storage** tab of your previous run.

#### Example 8: Metadata only — check reaction count before scraping

Use `metadataOnly` to quickly check how many reactions a post has **without extracting them all**. This makes just one API call per post and returns only the totals.

```json
{
  "postUrls": [
    "https://www.linkedin.com/posts/satyanadella_activity-7302346926123798528-jitu"
  ],
  "metadataOnly": true
}
```

Output:

```json
{
  "post_url": "https://www.linkedin.com/posts/satyanadella_...",
  "total_reactions": 847,
  "total_pages": 9,
  "extracted_at": "2026-03-31T12:00:00.000Z"
}
```

**When to use this:**

- **Avoid unnecessary scrapes** — Check if a post has new reactions since your last run before paying for a full extraction. For example, if you scraped 847 reactions yesterday and the metadata still shows 847 today, you can skip the full scrape.
- **Cost estimation** — Know exactly how many reactions (and how much it will cost) before committing to a full run.
- **Monitoring dashboards** — Track reaction growth over time without extracting every reactor each time.

> 💡 Metadata-only mode costs just **$0.004** per post (one result in the dataset). A full scrape of 1,000 reactions would cost **$4.00**. Use metadata to decide if the full scrape is worth it.

***

### 🤖 Integration with AI Agents

This actor is optimized for use with AI agents and LLMs via the Apify MCP server.

#### Output Schema

The actor produces a flat dataset where each item represents one reaction. Key fields for agent consumption:

- `reactor.name` — Who reacted
- `reactor.headline` — Their professional context
- `reaction_type` — How they reacted
- `is_company` — Whether it's a company or person

#### Example Agent Prompt

> "Scrape all reactions from this LinkedIn post and find decision-makers (CEOs, VPs, Directors) who engaged with it. Return their names and LinkedIn URLs."

The agent can use `headlineKeywords: ["CEO", "VP", "Director"]` to filter directly at scrape time, reducing post-processing.

***

### 🎯 Use Cases

- **🔎 Sales prospecting** — Find decision-makers engaging with competitor or industry content
- **📊 Market research** — Analyze who engages with thought leaders in your space
- **🏆 Competitor analysis** — Track engagement patterns on competitor posts
- **📋 Lead generation** — Build targeted lists from post engagement data
- **📈 Content strategy** — Understand what types of professionals engage with specific topics
- **🔄 Engagement monitoring** — Track reaction growth over time with incremental mode

***

### ℹ️ Profile URL Format

LinkedIn returns profile URLs in **profile ID format** for reactions, for example:

```
https://www.linkedin.com/in/ACoAAB8v74YB5oqaAg-4F2VRFh9tEt0zXfRsjpE
```

Instead of the human-friendly slug format:

```
https://www.linkedin.com/in/john-doe
```

This is a LinkedIn limitation — the reactions popup only exposes profile IDs, not public slugs. Both formats are valid and redirect to the same profile. This is the standard behavior across all LinkedIn reaction scrapers.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by LinkedIn Corporation. LinkedIn® is a registered trademark of LinkedIn Corporation. All trademarks are property of their respective owners.

# Actor input Schema

## `postUrls` (type: `array`):

List of LinkedIn post URLs or activity IDs. Supports full URLs or just IDs.

## `reactionType` (type: `string`):

Filter reactions by type. ALL returns every reaction type.

## `maxReactions` (type: `integer`):

Maximum reactions to extract per post. 0 = unlimited (extracts all).

## `headlineKeywords` (type: `array`):

Only include reactors whose headline contains at least one of these keywords (case-insensitive). Leave empty for no filter.

## `excludeCompanies` (type: `boolean`):

If enabled, excludes company/organization pages from results (only people).

## `metadataOnly` (type: `boolean`):

If enabled, only fetches the total reaction count for each post without extracting individual reactions. Useful for checking if a post has new reactions before running a full scrape.

## Actor input object example

```json
{
  "postUrls": [
    "https://www.linkedin.com/feed/update/urn:li:share:7404946870776868864/"
  ],
  "reactionType": "ALL",
  "maxReactions": 0,
  "headlineKeywords": [],
  "excludeCompanies": false,
  "metadataOnly": false
}
```

# Actor output Schema

## `reactions` (type: `string`):

No description

# 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 = {
    "postUrls": [
        "https://www.linkedin.com/feed/update/urn:li:share:7404946870776868864/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dendelabs/linkedin-reactions-scraper-pro").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 = { "postUrls": ["https://www.linkedin.com/feed/update/urn:li:share:7404946870776868864/"] }

# Run the Actor and wait for it to finish
run = client.actor("dendelabs/linkedin-reactions-scraper-pro").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 '{
  "postUrls": [
    "https://www.linkedin.com/feed/update/urn:li:share:7404946870776868864/"
  ]
}' |
apify call dendelabs/linkedin-reactions-scraper-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PRO Post Reactions LinkedIn Scraper",
        "description": "Extract all reactions from LinkedIn posts with auto-pagination, incremental scraping, headline filters, and analytics. No LinkedIn account needed.",
        "version": "1.0",
        "x-build-id": "ZNLiGFG7lIl8uOxQS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dendelabs~linkedin-reactions-scraper-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dendelabs-linkedin-reactions-scraper-pro",
                "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/dendelabs~linkedin-reactions-scraper-pro/runs": {
            "post": {
                "operationId": "runs-sync-dendelabs-linkedin-reactions-scraper-pro",
                "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/dendelabs~linkedin-reactions-scraper-pro/run-sync": {
            "post": {
                "operationId": "run-sync-dendelabs-linkedin-reactions-scraper-pro",
                "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": [
                    "postUrls"
                ],
                "properties": {
                    "postUrls": {
                        "title": "Post URLs or IDs",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "List of LinkedIn post URLs or activity IDs. Supports full URLs or just IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "reactionType": {
                        "title": "Reaction Type Filter",
                        "enum": [
                            "ALL",
                            "LIKE",
                            "PRAISE",
                            "EMPATHY",
                            "APPRECIATION",
                            "INTEREST",
                            "ENTERTAINMENT"
                        ],
                        "type": "string",
                        "description": "Filter reactions by type. ALL returns every reaction type.",
                        "default": "ALL"
                    },
                    "maxReactions": {
                        "title": "Max Reactions per Post",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum reactions to extract per post. 0 = unlimited (extracts all).",
                        "default": 0
                    },
                    "headlineKeywords": {
                        "title": "Headline Keywords Filter",
                        "type": "array",
                        "description": "Only include reactors whose headline contains at least one of these keywords (case-insensitive). Leave empty for no filter.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "excludeCompanies": {
                        "title": "Exclude Company Pages",
                        "type": "boolean",
                        "description": "If enabled, excludes company/organization pages from results (only people).",
                        "default": false
                    },
                    "metadataOnly": {
                        "title": "Metadata Only",
                        "type": "boolean",
                        "description": "If enabled, only fetches the total reaction count for each post without extracting individual reactions. Useful for checking if a post has new reactions before running a full scrape.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
