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

Cheapest LinkedIn profile engagement scraper. Every commenter on any profile - names, profiles, headlines, reactions. No login, no ban risk. $1/1k.

- **URL**: https://apify.com/linkedintel/cheapest-linkedin-profile-engagement-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 engagement record 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 Engagement Scraper — No Login, No Cookies, Pay Per Result

For any LinkedIn profile, extract **every public commenter on their posts** — names, profile URLs, headlines, comment text, reaction counts, full target-post context. Clean structured JSON. **No LinkedIn login required. No cookies. No browser session. No account ban risk.**

The fastest, cheapest, safest way to extract LinkedIn profile engagement at scale — built for **B2B sales prospecting, account-based marketing (ABM), audience research, lead generation, and competitive intelligence**.

---

### How this compares to other LinkedIn engagement scrapers

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

| | Cookie-based scrapers | Rental scrapers ($30/mo) | Per-post scrapers ($1.10/1k) | "Comments by user" ($5/1k) | **This actor** |
|---|---|---|---|---|---|
| **Input** | Profile URL | Profile URL | One post URL | Profile slug | **Multiple profile URLs (batch)** |
| **Output direction** | Mixed | Post metrics only | Single post commenters | Comments user left elsewhere | **Every commenter on the profile's posts** |
| **Login required** | ❌ Yes — `li_at` cookie | ❌ Varies | ✅ No | ✅ No | ✅ **No login, no cookies** |
| **Account ban risk** | 🔴 High | 🔴 Varies | ✅ Zero | ✅ Zero | ✅ **Zero** |
| **Output fields per record** | 5–10 | counts only | 5 | 8–12 | **32 fields** |
| **Includes nested replies** | Limited | n/a | Sometimes | Yes | ✅ **Yes, tagged with `isReply`** |
| **Target post context** | Limited | n/a | Implicit (single post) | Implicit | ✅ **Full post URN, URL, author, date, reactions** |
| **Pricing** | Varies (often $5+/1k) | $30+/month flat | $1.10 per 1,000 | $5.00 per 1,000 | **$1.00 per 1,000** |
| **Pay-per-result (no waste on low volume)** | Varies | ❌ Monthly minimum | ✅ Yes | ✅ Yes | ✅ **Yes** |

**Bottom line:** $1/1k is the cheapest in the category. We're the only scraper that batches by profile URL AND returns every public commenter with full target-post context — at half the price of the next-cheapest alternative.

### What you get — every engaged commenter on a prospect's posts

For every public engagement on the queried profile's posts, this actor returns 32 fields per record:

- **Commenter identity** — full name, headline, public profile URL, member URN, dash URN, profile picture URL
- **The comment itself** — full text (Unicode + emoji safe), edit flag, ISO + Unix ms timestamps, permalink, reactions breakdown, reply count
- **Reply detection** — `isReply` boolean (true when the record is a threaded reply, not top-level)
- **Target context** — which of the prospect's posts the comment is on: URN, URL, preview text, author info, timestamp, total engagement metrics
- **Self-filter** — `isFromTargetProfile` flag lets you exclude the prospect's own replies in one line of code

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

### Top use cases — built for B2B sales, ABM, and audience research

#### 1. Account-based marketing (ABM) prospecting
Pass your top-50 target prospects as profile URLs. Get back every public commenter on their LinkedIn content. **Dedupe by company → ABM target list pre-warmed by topic interest.** This is engagement-based lead generation done at scale — no cold-list outreach, no Sales Navigator gymnastics.

#### 2. Sales prospecting from buyer engagement signals
Targeting a CEO or decision-maker? Pull every commenter on their posts → those people are in the buying committee or adjacent. Reply-rate from buyer-engagement outreach beats raw cold-lists 2–4×. **Tag the records with `isFromTargetProfile=false` to filter out the prospect's own replies and get only external commenters.**

#### 3. Influencer audience audit and creator vetting
Before paying a creator for a sponsored post, audit their commenter list. Real audience or paid engagement pods? **One run shows you who has engaged with their content** — look at headlines, employers, account quality. 30 seconds of cost, hours of due diligence saved.

#### 4. Competitive intelligence — track competitor thought leaders
Run this monthly on your competitor's CMO, founder, or product lead. Get a stream of every prospect engaging with their thought leadership. **Those prospects are warm to the topic — and potentially switchable.** Build your switcher pipeline from public LinkedIn signals.

#### 5. Personal branding analytics
Pass your own profile URL. See every public engagement, sorted by reactions. **Identify your strongest content, your warmest commenters, and the gaps in your reach.** Build a feedback loop on what resonates without paying for LinkedIn Premium analytics.

#### 6. Hiring and recruiting signals
Pass a candidate's profile URL. See who engages with their content publicly. **Reveals their professional network, peers, and how active their reputation is.** Real signal beyond the résumé.

#### 7. Audience research for content strategy
Track who comments on industry thought leaders in your space. Aggregate the commenter list across 10 profiles → that's your ICP's public watering hole, mapped.

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

#### Step 1 — Get the profile URL
Open the LinkedIn profile in your browser 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** (one per line)
3. Set **Max engagement records per profile** to cap your cost per profile (default 500)
4. Click **Start**

#### Step 3 — Get your data
Results stream into the **Dataset** tab as the run progresses. 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 engagement you want to extract. |
| `profileIds` | array of strings | `[]` | Alternative to URLs — pass just the username slugs (e.g., `"satyanadella"`). |
| `maxCommentsPerProfile` | integer | `500` | Hard cap on engagement 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/"
  ],
  "maxCommentsPerProfile": 250
}
````

### Output

Each engagement is a single dataset record (commenter + their comment + full target post context):

```json
{
  "type": "engagement",
  "commenterUrn": "urn:li:member:123456789",
  "commenterDashUrn": "ACoAAAA...",
  "commenterFullName": "Jane Doe",
  "commenterHeadline": "VP of Marketing at Example Corp",
  "commenterProfileUrl": "https://www.linkedin.com/in/janedoe",
  "commenterProfilePictureUrl": "https://media.licdn.com/...",
  "commentText": "Congratulations on the launch — looking forward to trying this with our team.",
  "commentEdited": false,
  "commentCreatedAt": "2026-04-15T14:22:30.000000+00:00",
  "commentCreatedAtMs": 1776264150000,
  "commentPermalink": "https://www.linkedin.com/feed/update/.../?commentUrn=...",
  "isReply": false,
  "isFromTargetProfile": false,
  "numLikes": 12,
  "numReplies": 2,
  "reactions": [
    { "reactionType": "LIKE", "reactionCount": 9 },
    { "reactionType": "PRAISE", "reactionCount": 3 }
  ],
  "targetProfileUsername": "examplefounder",
  "targetProfileDashUrn": "ACoAAAB...",
  "targetPostUrn": "urn:li:activity:7400000000000000000",
  "targetPostUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7400000000000000000",
  "targetPostTextPreview": "Excited to announce our latest product launch. Built with the team in 6 weeks...",
  "targetPostHeader": "",
  "targetPostAuthorName": "Example Founder",
  "targetPostAuthorHeadline": "Founder & CEO at Example Corp",
  "targetPostAuthorUrl": "https://www.linkedin.com/in/examplefounder",
  "targetPostCreatedAt": "2026-04-10T10:00:00.000000+00:00",
  "targetPostCreatedAtMs": 1776002400000,
  "targetPostReactionsCount": 542,
  "targetPostCommentsCount": 87,
  "targetPostRepostsCount": 23,
  "scrapedAt": "2026-05-17T12:00:00.000000+00:00"
}
```

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

### Pricing — pay only for results

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

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

**The cheapest LinkedIn profile engagement scraper on Apify Store.** Competitors charge $2–$5 per 1,000 results.

### Combine with other LinkedIn actors

Build a complete LinkedIn intelligence pipeline:

- Pipe `commenterProfileUrl` into the **LinkedIn Profile Scraper** to enrich every commenter with full firmographic data
- Pipe `targetPostUrn` into the **LinkedIn Post Reactions Scraper** for reactions on the same posts
- Pipe `targetPostUrn` into the **LinkedIn Post Comments Scraper** for full comment threads on those posts

### FAQ

#### Do I need a LinkedIn account?

**No.** This is the killer feature. The actor does not log in to LinkedIn, does not use your session, does not touch your account. It reads public engagement that anyone can view without signing in.

#### 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 "Profile Engagement" different from "Post Comments"?

This actor takes a **profile URL** and returns every commenter on all of that profile's recent posts. The Post Comments Scraper takes a **single post URL** and returns every commenter on just that post. Use this one to track a person; use Post Comments to track a specific post.

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

Direct competitors charge $1.10 to $5.00 per 1,000 results, and some are rental-only at $30+/month. We negotiated a managed data partnership that gives us cookieless LinkedIn access at lower vendor cost — and we pass the savings through. **$1 per 1,000 is the cheapest in the category on Apify Store.**

#### 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 — duplicates in your input are scraped only once, saving credits.

#### Does this work for company pages too?

No — this actor only accepts personal LinkedIn profiles (`linkedin.com/in/<username>/`). Company pages (`linkedin.com/company/<slug>/`) return a clean "URL not supported" diagnostic. For company posts and engagement, see the linkedintel LinkedIn Company Scraper.

#### What does `isFromTargetProfile` do?

When a profile owner replies to comments on their own posts, those replies show up in the result set too. Filter `isFromTargetProfile=false` to get only external commenters (typical lead-gen use case).

#### How fast is it?

1–15 seconds per profile depending on engagement volume. The actor paginates automatically via cursor.

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

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

#### 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, public comments) 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
- 32 fields per record: full commenter context + full target post context
- Reply detection (`isReply` from permalink structure)
- Target profile self-filter (`isFromTargetProfile`)
- Cursor-based pagination, ~99 records per upstream call
- Clean diagnostic records for missing profiles, private profiles, empty engagement
- Native Apify integrations + Agent Payments (x402 / USDC)

### 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 prospects/people whose engagement you want to extract. Each input profile becomes a batch of every public commenter on their posts. 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"]

## `maxCommentsPerProfile` (type: `integer`):

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

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

Apify proxy settings. Residential proxies are recommended.

## Actor input object example

```json
{
  "profileUrls": [
    "https://www.linkedin.com/in/satyanadella/"
  ],
  "maxCommentsPerProfile": 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-engagement-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-engagement-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-engagement-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-engagement-no-cookies-1-1k",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Profile Engagement Scraper · No Cookies · $1/1k ✅",
        "description": "Cheapest LinkedIn profile engagement scraper. Every commenter on any profile - names, profiles, headlines, reactions. No login, no ban risk. $1/1k.",
        "version": "1.0",
        "x-build-id": "53gYFhqPfEmr1MtgD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/linkedintel~cheapest-linkedin-profile-engagement-no-cookies-1-1k/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-linkedintel-cheapest-linkedin-profile-engagement-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-engagement-no-cookies-1-1k/runs": {
            "post": {
                "operationId": "runs-sync-linkedintel-cheapest-linkedin-profile-engagement-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-engagement-no-cookies-1-1k/run-sync": {
            "post": {
                "operationId": "run-sync-linkedintel-cheapest-linkedin-profile-engagement-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 prospects/people whose engagement you want to extract. Each input profile becomes a batch of every public commenter on their posts. 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"
                        }
                    },
                    "maxCommentsPerProfile": {
                        "title": "Max engagement records per profile",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Cap on the number of comment records returned per profile. Lower = faster + cheaper. Default returns up to 500 most recent engagements.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
