# LinkedIn Profile Reactions Scraper · No Cookies · $1/1k ✅ (`linkedintel/cheapest-linkedin-profile-reactions-no-cookies-1-1k`) Actor

Cheapest LinkedIn profile reactions scraper. Every post a profile reacted to - reaction type, post content, author. No login, no ban risk. $1/1k.

- **URL**: https://apify.com/linkedintel/cheapest-linkedin-profile-reactions-no-cookies-1-1k.md
- **Developed by:** [LinkedIntel](https://apify.com/linkedintel) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 reaction extracteds

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 Profile Reactions Scraper — No Login, No Cookies, Pay Per Result

For any LinkedIn profile, extract **every post they've publicly reacted to** — reaction type (Like / Celebrate / Love / Support / Insightful / Funny / Curious), full post content, post author, engagement metrics, media attachments. Clean structured JSON. **No LinkedIn login required. No cookies. No browser session. No account ban risk.**

The fastest, cheapest, safest way to map a LinkedIn profile's reaction activity at scale — built for **B2B sales prospecting, account-based marketing (ABM), buying-signal monitoring, audience research, competitive intelligence, and influencer audit**.

---

### How this compares to other LinkedIn profile reactions scrapers

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

| | harvestapi/linkedin-profile-reactions | apimaestro/linkedin-profile-reactions | **This actor** |
|---|---|---|---|
| **Pricing** | $2.00/1k | $5.00/1k | **$1.00/1k (50% cheaper than harvestapi, 80% cheaper than apimaestro)** |
| **Output fields per record** | ~10 | ~10 | **28 fields** |
| **Reaction type detection** | ID + verb | text only | ✅ **Parsed enum: LIKE / PRAISE / APPRECIATION / EMPATHY / INTEREST / ENTERTAINMENT / MAYBE** |
| **Distinguishes post vs comment reactions** | ❌ | ❌ | ✅ **`reactionTargetType`** field |
| **Detects reshares (`targetIsReshare`)** | ❌ | ❌ | ✅ |
| **Distinguishes PERSON vs COMPANY post author** | ❌ | ❌ | ✅ **`targetAuthorType`** |
| **Media attachments URL list** | Partial | Partial | ✅ **`targetMediaContent` array + `targetMediaCount`** |
| **Login required** | ✅ No | ✅ No | ✅ **No login, no cookies** |
| **Account ban risk** | ✅ Zero | ✅ Zero | ✅ **Zero** |
| **Pay-per-result** | ✅ Yes | ✅ Yes | ✅ **Yes** |

**Bottom line:** $1/1k is the **cheapest LinkedIn profile reactions scraper on Apify Store**, with the richest output schema, the only one that parses reaction types into a clean enum, and the only one that distinguishes post vs comment reactions.

### What you get — every reaction the profile made

For every public reaction the queried profile has given, this actor returns 28 fields per record:

- **The reactor** — username (input) + LinkedIn dash URN
- **The reaction itself** — parsed enum (`reactionType`: LIKE / PRAISE / APPRECIATION / EMPATHY / INTEREST / ENTERTAINMENT / MAYBE), target type (`reactionTargetType`: post vs comment), raw header text
- **The target post** — URN, URL, full content, preview, edit flag, ISO + Unix ms timestamps, reshare flag
- **The target author** — name, headline, profile URL, dash URN, member ID, type (PERSON vs COMPANY), profile picture URL
- **Engagement on the target** — total reactions, comments count, reposts count, reactions breakdown by type
- **Media on the target** — array of images/videos + count

One record per reaction. Flat JSON. Ready to drop into Airtable, Google Sheets, HubSpot, Salesforce, Pipedrive, Zapier, Make, n8n, or any webhook.

### Top use cases

#### 1. Buying-signal detection
"Did my target prospect react to a competitor's launch announcement?" Pull their last 500 reactions. Filter by `targetAuthorName` containing competitor names. **Real-time switcher detection** — most powerful B2B sales signal LinkedIn offers.

#### 2. Account-based marketing (ABM)
Pass your top-50 target accounts' decision-makers as profile URLs. Get every post they've reacted to. **Aggregate the target post authors → your warmest content + topics for ABM messaging.**

#### 3. Personal-brand engagement audit
Pass your own profile URL. See every post you've reacted to publicly. **Audit your own digital footprint** — what message does your reaction pattern send to prospects who check?

#### 4. Competitor radar — who do they engage with?
Run this monthly on your competitor's CMO, product lead, or founder. Get a stream of every post they react to → reveals their partners, customers, peer leaders, content sources. **The hidden network behind the public LinkedIn presence.**

#### 5. Influencer + creator vetting
Before paying for a sponsored post, audit what the creator publicly endorses. Their reaction pattern reveals real interests vs. paid alignment. **One run shows you what they actually believe in publicly.**

#### 6. Content strategy research
Track which posts your industry's thought leaders react to. Aggregate the topics + authors → your content calendar gold mine. **What resonates with the people you're trying to reach?**

#### 7. Recruitment + candidate intel
Pass a candidate's profile URL. Their reaction pattern reveals professional interests, peer network, and recent topics of attention. **Better than the résumé.**

### Quick start (3 steps, 30 seconds)

#### Step 1 — Get the profile URL
Open the LinkedIn profile and copy the URL — `https://www.linkedin.com/in/<username>/`. You can also pass just the username slug (e.g., `satyanadella`) via the **Profile usernames** field.

#### Step 2 — Run the actor
1. Click the green **Start** button
2. Paste one or more profile URLs into **Profile URLs**
3. Set **Max reactions per profile** to control cost (default 500)
4. Click **Start**

#### Step 3 — Get your data
Results stream into the **Dataset** tab. Click **Export** for JSON, CSV, or Excel — or push directly to Zapier, Make, Google Sheets, Airtable, HubSpot, Salesforce, or any webhook via Apify's native integrations.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `profileUrls` | array of strings | `[]` | LinkedIn profile URLs of the people whose reactions you want to extract. |
| `profileIds` | array of strings | `[]` | Alternative to URLs — pass just the username slugs (e.g., `"satyanadella"`). |
| `maxReactionsPerProfile` | integer | `500` | Hard cap on reaction records per profile. Lower runs faster and costs less. |
| `proxyConfiguration` | object | Apify residential | Proxy settings (defaults are correct for most users). |

At least one of `profileUrls` or `profileIds` is required.

#### Example input

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella/",
    "https://www.linkedin.com/in/reidhoffman/"
  ],
  "maxReactionsPerProfile": 250
}
````

### Output

Each reaction is a single dataset record:

```json
{
  "type": "reaction",
  "reactorUsername": "satyanadella",
  "reactorDashUrn": "ACoAAAA...",
  "reactionType": "LIKE",
  "reactionTargetType": "post",
  "reactionHeader": "Satya Nadella likes this",
  "targetUrn": "urn:li:activity:7400000000000000000",
  "targetUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7400000000000000000",
  "targetText": "Excited to announce our latest product launch...",
  "targetTextPreview": "Excited to announce our latest product launch...",
  "targetEdited": false,
  "targetCreatedAt": "2026-04-15T14:22:30.000000+00:00",
  "targetCreatedAtMs": 1776264150000,
  "targetIsReshare": false,
  "targetAuthorName": "Example Founder",
  "targetAuthorHeadline": "Founder & CEO at Example Corp",
  "targetAuthorUrl": "https://www.linkedin.com/in/examplefounder",
  "targetAuthorUrn": "urn:li:fsd_profile:ACoAAAB...",
  "targetAuthorId": "urn:li:member:123456789",
  "targetAuthorType": "PERSON",
  "targetAuthorProfilePictureUrl": "https://media.licdn.com/...",
  "targetTotalReactions": 542,
  "targetCommentsCount": 87,
  "targetRepostsCount": 23,
  "targetReactionBreakdown": [
    { "reactionType": "LIKE", "reactionCount": 480 },
    { "reactionType": "PRAISE", "reactionCount": 45 },
    { "reactionType": "EMPATHY", "reactionCount": 17 }
  ],
  "targetMediaContent": [
    { "type": "image", "url": "https://media.licdn.com/..." }
  ],
  "targetMediaCount": 1,
  "scrapedAt": "2026-05-17T12:00:00.000000+00:00"
}
```

A final `summary` record is also pushed: `totalReactions`, `profilesSuccessful`, `profilesFailed`, `profilesTotal`.

#### Reaction type enum

| Value | LinkedIn UI label |
|---|---|
| `LIKE` | Like 👍 |
| `PRAISE` | Celebrate 👏 |
| `APPRECIATION` | Support ❤️‍🩹 |
| `EMPATHY` | Love ❤️ |
| `INTEREST` | Curious 🤔 |
| `ENTERTAINMENT` | Funny 😂 |
| `MAYBE` | Insightful 💡 |

### Pricing — pay only for results

**$1.00 per 1,000 reaction records. Pay-per-result.**

- ✅ No subscription
- ✅ No base fee
- ✅ No charge for failed runs
- ✅ No charge for profiles with no public reactions (clean diagnostic record)
- ✅ Apify's free tier ($5/month platform credit) gets you ~5,000 free records to start

**The cheapest LinkedIn profile reactions scraper on Apify Store** — 50% cheaper than the closest competitor ($2.00/1k), 80% cheaper than the established alternative ($5.00/1k).

### Combine with other LinkedIn actors

Build a complete LinkedIn intelligence pipeline:

- Pipe `targetAuthorUrl` into the **LinkedIn Profile Scraper** to enrich every post-author with full firmographic data
- Pipe `targetUrn` into the **LinkedIn Post Comments Scraper** to combine reaction data with full comment threads
- Pipe `reactorUsername` into the **LinkedIn Profile Engagement Scraper** to see who reacts to the reactor's content

### FAQ

#### Do I need a LinkedIn account?

**No.** This actor reads public reaction data without any LinkedIn login, cookie, or browser session.

#### Will my LinkedIn account get banned?

**No — because we never use it.** Cookie-based scrapers risk your account every run. This actor doesn't.

#### How is this different from your other LinkedIn Reactions Scraper?

The **LinkedIn Reactions Scraper** (a5) takes a *post URL* and returns every reactor on that one post. This actor takes a *profile URL* and returns every post the profile reacted to (inverse direction). Use a5 to study a post; use this one to study a person.

#### What if a profile has reacted to a comment instead of a post?

The actor still captures it. The `reactionTargetType` field is set to `"comment"` (vs `"post"`) so you can filter or analyze separately.

#### Why is this cheaper than other LinkedIn reactions scrapers?

Direct competitors charge $2.00 to $5.00 per 1,000 results. We negotiated a managed data partnership that gives us cookieless LinkedIn access at a lower vendor cost — and we pass the savings through.

#### Can I scrape multiple profiles in one run?

Yes. Paste a list of profile URLs into the **Profile URLs** field. The actor processes them sequentially with built-in deduplication by username slug.

#### What's the maximum number of reactions per profile?

Up to **50,000** reactions per profile (controlled by `maxReactionsPerProfile`). LinkedIn typically surfaces the most recent ~3,000 public reactions per profile via the upstream API.

#### How fast is it?

1–30 seconds per profile depending on volume. Pagination via cursor handles large profiles automatically.

#### What if the profile is private or doesn't exist?

The actor returns a clean diagnostic record and continues with the next profile — never crashes mid-batch.

#### Does this work for company pages?

No — this actor only accepts personal LinkedIn profiles (`linkedin.com/in/<username>/`). Company pages return a clean "URL not supported" diagnostic.

#### Can I integrate with Zapier / Make / n8n / HubSpot?

Yes — Apify integrates natively with all of them, plus Salesforce, Airtable, Google Sheets, and any webhook-compatible tool.

#### Can AI agents pay for and run this actor?

Yes — Agent Payments (x402 / USDC) are enabled. AI agents can pay per run in stablecoin.

### Legal & compliance

- Extracts **publicly available** data only — no logins, no access-control bypass, no private content
- You are responsible for complying with LinkedIn's Terms of Service, GDPR (EU), CCPA (California), and other applicable laws
- Personal data returned (names, public profiles, public headlines, reaction events) may require a lawful basis (legitimate interest, consent) before outbound use
- This actor is **not affiliated with, endorsed by, or sponsored by LinkedIn Corporation or Microsoft Corporation.** "LinkedIn" is a registered trademark of LinkedIn Corporation

### Changelog

#### v1.0.0 — 2026-05-17

- Initial release
- Cookieless architecture — zero account-ban risk
- 28 fields per record: full reactor + target post + target author + engagement context
- Reaction type parsed from header into clean 7-value enum (LIKE / PRAISE / APPRECIATION / EMPATHY / INTEREST / ENTERTAINMENT / MAYBE)
- `reactionTargetType` distinguishes post vs comment reactions
- `targetIsReshare` flag and `targetAuthorType` (PERSON vs COMPANY) detection
- Media attachment URLs array
- Cursor-based pagination for high-volume profiles
- Clean diagnostic records for missing profiles, private profiles, empty engagement
- Native Apify integrations + Agent Payments (x402 / USDC)
- **14/14 tests passed** across 3 tiers (correctness, stress, edge cases)

### Support

Questions, feature requests, or bug reports? Open an issue on the actor's **Issues** tab. We respond within 24 hours.

**Like this actor? Leave a review on the Apify Store — it helps other LinkedIn data teams find it.**

# Actor input Schema

## `profileUrls` (type: `array`):

LinkedIn profile URLs of the people whose reactions you want to extract. Each input profile becomes a stream of every public post the person has reacted to (Like/Celebrate/Love/Support/Insightful/Funny/Curious). Example: \["https://www.linkedin.com/in/satyanadella/"]

## `profileIds` (type: `array`):

Alternative to profileUrls: pass just the username slugs (the part after /in/ in a LinkedIn URL). Example: \["satyanadella", "reidhoffman"]

## `maxReactionsPerProfile` (type: `integer`):

Cap on the number of reaction records returned per profile. Lower = faster + cheaper. Default returns up to 500 most recent reactions.

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

Apify proxy settings. Residential proxies are recommended.

## Actor input object example

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella/"
  ],
  "maxReactionsPerProfile": 500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "profileUrls": [
        "https://www.linkedin.com/in/satyanadella/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("linkedintel/cheapest-linkedin-profile-reactions-no-cookies-1-1k").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 = { "profileUrls": ["https://www.linkedin.com/in/satyanadella/"] }

# Run the Actor and wait for it to finish
run = client.actor("linkedintel/cheapest-linkedin-profile-reactions-no-cookies-1-1k").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 '{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella/"
  ]
}' |
apify call linkedintel/cheapest-linkedin-profile-reactions-no-cookies-1-1k --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Profile Reactions Scraper · No Cookies · $1/1k ✅",
        "description": "Cheapest LinkedIn profile reactions scraper. Every post a profile reacted to - reaction type, post content, author. No login, no ban risk. $1/1k.",
        "version": "1.0",
        "x-build-id": "pYDmwUTTl4eOJjRJf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/linkedintel~cheapest-linkedin-profile-reactions-no-cookies-1-1k/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-linkedintel-cheapest-linkedin-profile-reactions-no-cookies-1-1k",
                "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~cheapest-linkedin-profile-reactions-no-cookies-1-1k/runs": {
            "post": {
                "operationId": "runs-sync-linkedintel-cheapest-linkedin-profile-reactions-no-cookies-1-1k",
                "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~cheapest-linkedin-profile-reactions-no-cookies-1-1k/run-sync": {
            "post": {
                "operationId": "run-sync-linkedintel-cheapest-linkedin-profile-reactions-no-cookies-1-1k",
                "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": {
                    "profileUrls": {
                        "title": "Profile URLs",
                        "type": "array",
                        "description": "LinkedIn profile URLs of the people whose reactions you want to extract. Each input profile becomes a stream of every public post the person has reacted to (Like/Celebrate/Love/Support/Insightful/Funny/Curious). Example: [\"https://www.linkedin.com/in/satyanadella/\"]",
                        "items": {
                            "type": "string"
                        }
                    },
                    "profileIds": {
                        "title": "Profile usernames",
                        "type": "array",
                        "description": "Alternative to profileUrls: pass just the username slugs (the part after /in/ in a LinkedIn URL). Example: [\"satyanadella\", \"reidhoffman\"]",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReactionsPerProfile": {
                        "title": "Max reactions per profile",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Cap on the number of reaction records returned per profile. Lower = faster + cheaper. Default returns up to 500 most recent reactions.",
                        "default": 500
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Residential proxies are recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
