# LinkedIn Post Reactions Scraper (No Cookies) (`data-slayer/linkedin-post-reactions`) Actor

Extract people and entities that reacted to public LinkedIn posts. Get reaction type, name, headline, LinkedIn URL, IDs, and timestamps in clean JSON or CSV—no cookies or LinkedIn login required.

- **URL**: https://apify.com/data-slayer/linkedin-post-reactions.md
- **Developed by:** [Data Slayer](https://apify.com/data-slayer) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 post reaction results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## LinkedIn Post Reactions Scraper (No Cookies)

Turn public LinkedIn post URLs into a structured reaction-level dataset. Each row represents one unique reaction and includes the reaction type, reactor name, headline, LinkedIn URL, encoded ID, entity type, post ID, source URL, and retrieval timestamp.

### Watch the demo

YouTube video coming soon.

Use it for engaged-audience research, campaign analysis, social listening, lead-list preparation, and CRM or BI workflows. No LinkedIn cookies, login credentials, browser session, or proxy configuration are required—paste one or more post URLs and run the Actor.

### Quick start

1. Add one or more public LinkedIn post URLs under **LinkedIn Post URLs**.
2. Keep the default maximum of 100 reactions per post or choose another limit.
3. Keep **All reaction types** or select the reactions you need.
4. Click **Start** and open the Dataset when the run finishes.

The maximum is an upper bound, not a guaranteed result count. The Actor stops when it reaches your limit or when the available source reactions are exhausted.

### What data can you extract?

Every reaction row uses the same flat schema:

| Field | Type | Description |
|---|---|---|
| `post_url` | string | Normalized LinkedIn post URL requested in the input. |
| `post_id` | string | Numeric LinkedIn post ID stored as a string to prevent precision loss. |
| `reaction_urn` | string or null | Derived LinkedIn reaction URN when the required identifiers are available. |
| `reaction_type` | string | `LIKE`, `PRAISE`, `EMPATHY`, `APPRECIATION`, `INTEREST`, or `ENTERTAINMENT`. |
| `reactor_entity_type` | string | `person`, `company`, or `unknown`. |
| `reactor_name` | string or null | Display name returned for the reactor. |
| `reactor_headline` | string or null | LinkedIn headline or position when available. |
| `reactor_linkedin_url` | string or null | LinkedIn URL returned for the person or company. |
| `reactor_id` | string or null | Encoded LinkedIn profile or company identifier. |
| `reactor_image_url` | string or null | Valid media image URL when available. Profile-page URLs are not mislabeled as images. |
| `input_index` | integer | Zero-based position of the post URL in the normalized input. |
| `reaction_index` | integer | Zero-based reaction order for that post after filtering and deduplication. |
| `fetched_at` | string | UTC retrieval timestamp in ISO 8601 format. |

All fields are always present. Unavailable optional values are `null` in JSON and empty cells in CSV.

### Input

| Field | Required | Default | Description |
|---|---|---|---|
| `post_urls` | Yes | Example URL in the form | Add 1–1,000 LinkedIn post URLs. Supported formats include `/posts/...-activity-...`, `/posts/...-ugcPost-...`, and `/feed/update/urn:li:activity:...`. Comment URLs are not supported. |
| `max_reactions_per_post` | No | `100` | Maximum matching reactions saved per post. Use `0` to request all available reactions, with a 100-page safety cap. |
| `reaction_types` | No | `["ALL"]` | Keep every supported reaction type or select one or more specific types. |

#### Example input

```json
{
  "post_urls": [
    "https://www.linkedin.com/feed/update/urn:li:activity:7408723748973056001"
  ],
  "max_reactions_per_post": 100,
  "reaction_types": ["ALL"]
}
````

Existing API automations can continue using the supported aliases `posts`, `postUrls`, `linkedin_post_url`, `maxItems`, and `reactionTypeFilter`. New integrations should use the canonical fields shown above.

### Reaction types

The output uses LinkedIn's stable reaction categories:

| Output value | LinkedIn label |
|---|---|
| `LIKE` | Like |
| `PRAISE` | Celebrate |
| `EMPATHY` | Support |
| `APPRECIATION` | Love |
| `INTEREST` | Insightful |
| `ENTERTAINMENT` | Funny |

Filters are applied before `max_reactions_per_post`, so the maximum counts matching saved reactions rather than discarded reaction types.

### Example output

Each default-dataset item represents one reaction:

```json
{
  "post_url": "https://www.linkedin.com/feed/update/urn:li:activity:7408723748973056001",
  "post_id": "7408723748973056001",
  "reaction_urn": "urn:li:fsd_reaction:(urn:li:fsd_profile:ACoAAExampleProfileId,urn:li:activity:7408723748973056001,0)",
  "reaction_type": "LIKE",
  "reactor_entity_type": "person",
  "reactor_name": "Example Person",
  "reactor_headline": "Growth Marketing Lead",
  "reactor_linkedin_url": "https://www.linkedin.com/in/ACoAAExampleProfileId",
  "reactor_id": "ACoAAExampleProfileId",
  "reactor_image_url": null,
  "input_index": 0,
  "reaction_index": 0,
  "fetched_at": "2026-07-25T10:00:00Z"
}
```

Results can be downloaded from Apify as JSON, JSONL, CSV, Excel/XLSX, XML, or HTML table data. The configured dataset view keeps the 13 canonical fields in a practical export order.

### Per-URL run summary

The default key-value store includes `RUN_SUMMARY`. It preserves one status for every requested URL without mixing error placeholders into the reaction dataset.

```json
{
  "requested_url_count": 1,
  "successful_url_count": 1,
  "failed_url_count": 0,
  "reactions_saved": 77,
  "inputs": [
    {
      "input_index": 0,
      "post_url": "https://www.linkedin.com/feed/update/urn:li:activity:7408723748973056001",
      "status": "succeeded",
      "reactions_received": 77,
      "reactions_saved": 77,
      "pages_fetched": 1,
      "source_exhausted": true,
      "limit_reached": false,
      "reported_total": null,
      "error_code": null,
      "error_message": null
    }
  ]
}
```

Possible per-URL statuses are `succeeded`, `no_results`, and `error`. A mixed batch can finish successfully while reporting individual URL errors. If every requested URL fails, the summary is written and the Actor run fails.

### Common use cases

- Build a list of people who engaged with a campaign, announcement, or thought-leadership post.
- Compare reaction types across posts for audience and content analysis.
- Research public engagement on industry, company, or competitor posts.
- Export reactor data to spreadsheets, CRM workflows, dashboards, or enrichment pipelines.
- Monitor selected posts on a schedule and compare reaction datasets over time.
- Feed structured LinkedIn reaction data into internal tools, AI agents, or analytics systems.

### Use the Actor as a LinkedIn reactions API

Run the Actor with the Apify API, JavaScript client, Python client, CLI, schedules, Tasks, or webhooks. The default dataset contains reaction records and the default key-value store contains `RUN_SUMMARY`.

#### JavaScript example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('data-slayer/linkedin-post-reactions').call({
  post_urls: [
    'https://www.linkedin.com/feed/update/urn:li:activity:7408723748973056001',
  ],
  max_reactions_per_post: 100,
  reaction_types: ['ALL'],
});

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

### Limits and expected behavior

- The Actor extracts reactions available through its public-data source. It cannot guarantee every reaction visible on LinkedIn.
- `max_reactions_per_post` is an upper bound. A post may return fewer reactions when the source is exhausted or exposes fewer records.
- Public, deleted, restricted, private, or region-limited posts can return no results or an error.
- Comment reaction URLs are not supported. Use a supported LinkedIn post URL.
- Encoded LinkedIn profile URLs may be returned instead of vanity profile URLs.
- This Actor does not open or enrich individual LinkedIn profiles. It does not return emails, phone numbers, full work histories, or other profile-enrichment fields.
- `reactor_image_url` is `null` when the source does not provide a valid media image URL.
- Reactions are deduplicated by post ID and reactor ID and are emitted in normalized input order, then source order.
- A value of `0` for `max_reactions_per_post` requests all available pages with a 100-page safety cap per post.

### Pricing and cost control

Current pricing is shown in the Actor's **Pricing** tab. Use `max_reactions_per_post` to control the maximum number of reactions requested for each post. Because the maximum is an upper bound, your actual output can be smaller.

### Responsible use

LinkedIn reaction data can contain personal data such as names, headlines, and profile URLs. Use the Actor only for legitimate purposes and comply with applicable laws, privacy requirements, and platform terms. Do not use the output for spam, harassment, unlawful profiling, or unauthorized collection of private information.

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by LinkedIn Corporation.

### FAQ

#### Do I need a LinkedIn account, cookie, or login?

No. The input contains only post URLs and optional result controls. The Actor does not ask for LinkedIn credentials or session cookies.

#### Can I process multiple LinkedIn posts in one run?

Yes. Add up to 1,000 supported post URLs to `post_urls`. Duplicate normalized URLs are removed before processing.

#### Can I filter by reaction type?

Yes. Choose Like, Celebrate, Support, Love, Insightful, Funny, or all supported reaction types. Multiple specific types can be selected.

#### Does the Actor return every reaction on a post?

Not necessarily. It returns the reactions exposed by the source until the selected maximum or source exhaustion is reached. The maximum is not a completeness guarantee.

#### Why is `reactor_image_url` sometimes null?

The field is kept only when the source returns a valid media image URL. A LinkedIn profile page is not an image, so it is intentionally converted to `null` rather than mislabeled.

#### Can I export reactions to CSV or Excel?

Yes. Open the run's Dataset tab and choose CSV, Excel/XLSX, JSON, or another Apify-supported export format.

#### What happens if one URL fails in a batch?

The Actor continues with the remaining URLs. Check `RUN_SUMMARY` for the status, counts, and safe error details for every input URL.

#### Does it scrape reactions on LinkedIn comments?

No. This Actor accepts supported LinkedIn post URLs only; comment URLs are rejected.

### Support

Use the Actor's **Issues** tab for bug reports, questions, or feature requests. Include the run ID, a non-sensitive example input, the expected result, and what happened.

# Actor input Schema

## `post_urls` (type: `array`):

Required. Add 1–1,000 LinkedIn post URLs. Supported formats include linkedin.com/posts/…-activity-…, linkedin.com/posts/…-ugcPost-…, and linkedin.com/feed/update/urn:li:activity:…. Comment URLs are not supported.

## `max_reactions_per_post` (type: `integer`):

Maximum number of matching reactions to save for each post. Enter 0 to fetch all available reactions, with a 100-page safety cap per post.

## `reaction_types` (type: `array`):

Choose which LinkedIn reactions to keep. “All reaction types” ignores the other selections.

## Actor input object example

```json
{
  "post_urls": [
    "https://www.linkedin.com/posts/satyanadella_today-at-microsoft-build-we-showed-you-how-activity-7330296202275495938-EWFD"
  ],
  "max_reactions_per_post": 100,
  "reaction_types": [
    "ALL"
  ]
}
```

# Actor output Schema

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

One canonical dataset row per unique reaction.

## `runSummary` (type: `string`):

Per-URL success, no-result, and error details.

# 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 = {
    "post_urls": [
        "https://www.linkedin.com/posts/satyanadella_today-at-microsoft-build-we-showed-you-how-activity-7330296202275495938-EWFD"
    ],
    "max_reactions_per_post": 100,
    "reaction_types": [
        "ALL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data-slayer/linkedin-post-reactions").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 = {
    "post_urls": ["https://www.linkedin.com/posts/satyanadella_today-at-microsoft-build-we-showed-you-how-activity-7330296202275495938-EWFD"],
    "max_reactions_per_post": 100,
    "reaction_types": ["ALL"],
}

# Run the Actor and wait for it to finish
run = client.actor("data-slayer/linkedin-post-reactions").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 '{
  "post_urls": [
    "https://www.linkedin.com/posts/satyanadella_today-at-microsoft-build-we-showed-you-how-activity-7330296202275495938-EWFD"
  ],
  "max_reactions_per_post": 100,
  "reaction_types": [
    "ALL"
  ]
}' |
apify call data-slayer/linkedin-post-reactions --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Post Reactions Scraper (No Cookies)",
        "description": "Extract people and entities that reacted to public LinkedIn posts. Get reaction type, name, headline, LinkedIn URL, IDs, and timestamps in clean JSON or CSV—no cookies or LinkedIn login required.",
        "version": "1.0",
        "x-build-id": "Rtf3fLxrrvObDkvEU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data-slayer~linkedin-post-reactions/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data-slayer-linkedin-post-reactions",
                "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/data-slayer~linkedin-post-reactions/runs": {
            "post": {
                "operationId": "runs-sync-data-slayer-linkedin-post-reactions",
                "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/data-slayer~linkedin-post-reactions/run-sync": {
            "post": {
                "operationId": "run-sync-data-slayer-linkedin-post-reactions",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "post_urls": {
                        "title": "LinkedIn Post URLs",
                        "minItems": 1,
                        "maxItems": 1000,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Required. Add 1–1,000 LinkedIn post URLs. Supported formats include linkedin.com/posts/…-activity-…, linkedin.com/posts/…-ugcPost-…, and linkedin.com/feed/update/urn:li:activity:…. Comment URLs are not supported.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "max_reactions_per_post": {
                        "title": "Maximum reactions per post",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of matching reactions to save for each post. Enter 0 to fetch all available reactions, with a 100-page safety cap per post."
                    },
                    "reaction_types": {
                        "title": "Reaction types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose which LinkedIn reactions to keep. “All reaction types” ignores the other selections.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ALL",
                                "LIKE",
                                "PRAISE",
                                "EMPATHY",
                                "APPRECIATION",
                                "INTEREST",
                                "ENTERTAINMENT"
                            ],
                            "enumTitles": [
                                "All reaction types",
                                "Like",
                                "Celebrate",
                                "Support",
                                "Love",
                                "Insightful",
                                "Funny"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
