# LinkedIn Post Comments Scraper (`scraper-engine/linkedin-post-comments-scraper`) Actor

Extract comments from any LinkedIn post quickly and reliably. This Apify actor captures comment text, usernames, timestamps, and engagement data. Perfect for sentiment analysis, audience insights, and tracking discussions with clean, structured output ready for use.

- **URL**: https://apify.com/scraper-engine/linkedin-post-comments-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:** Social media, Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### LinkedIn Post Comments Scraper

The LinkedIn Post Comments Scraper is a purpose-built tool that helps you scrape LinkedIn post comments at scale — including replies, authors, timestamps, and reactions — in clean, structured JSON. It solves the manual effort of collecting comment threads and engagement data, giving marketers, developers, data analysts, and researchers a fast LinkedIn comments scraper for insights, sentiment, and lead enrichment. With this LinkedIn post comment extractor, you can automate LinkedIn comments scraping across multiple posts and export results for analysis.

### What data / output can you get?

Below are the exact fields this LinkedIn post comments scraping tool pushes to the dataset for each comment. This makes it a reliable LinkedIn comments export to CSV/JSON/Excel for downstream analytics and CRM workflows.

| Data type | Description | Example value |
| --- | --- | --- |
| postUrl | Source LinkedIn post URL you provided | https://www.linkedin.com/feed/update/urn:li:activity:7289521182721093633/ |
| comment_id | Parsed LinkedIn comment ID | 1234567890123 |
| text | Comment text (sanitized of extra whitespace) | Great announcement — congrats to the team! |
| posted_at.timestamp | Unix timestamp (ms) when the comment was created | 1713648000000 |
| posted_at.date | Local datetime string derived from timestamp | 2024-04-20 14:22:13 |
| posted_at.relative | Relative age string (e.g., s/m/h/d/w/y) | 3h |
| is_edited | Whether the comment was edited | false |
| is_pinned | Whether the comment is pinned | false |
| comment_url | Comment permalink (built if missing) | https://www.linkedin.com/feed/update/urn:li:activity:7289521182721093633/?commentUrn=urn%3Ali%3Acomment%3A%281234567890123%29 |
| author.name | Comment author name | Jane Doe |
| author.headline | Author headline (only when profileScraperMode=full) | Product Marketing @ Acme |
| author.profile_url | Link to the author’s profile | https://www.linkedin.com/in/janedoe |
| author.profile_picture | Best-effort profile picture URL (only when profileScraperMode=full) | https://media.licdn.com/dms/image/... |
| stats.total_reactions | Total reactions count on the comment | 12 |
| stats.reactions | Reaction-type breakdown (keys include like, appreciation, empathy, interest, praise) | {"like": 9, "appreciation": 2, "empathy": 0, "interest": 1, "praise": 0} |
| stats.comments | Number of replies under this comment | 3 |
| replies | Nested replies array (structure identical to parent comments); included when scrapeReplies=true and pass filters | [ { ...reply object... } ] |
| post_input | Post ID parsed from URNs (string) | 7289521182721093633 |
| totalComments | Total top-level comments reported for the post (when available) | 150 |

Notes:
- Comments are fetched in reverse chronological order.
- Replies are included only when scrapeReplies is enabled; they inherit the same structure as top-level comments.
- You can download Apify datasets in CSV, JSON, or Excel to power analytics, enrichment, and reporting.

### Key features

- 🚀 Fast LinkedIn post comments scraping
  - Collect clean, structured comments and replies with author details, timestamps, and engagement data in a single run.

- 🧠 Accurate reactions and engagement stats
  - Extract total reactions plus a reaction-type map with keys like like, appreciation, empathy, interest, and praise for each comment.

- 🧵 Optional replies capture
  - Toggle scrapeReplies to collect nested comment threads, making this a complete LinkedIn reactions and comments scraper.

- 👤 Flexible author details
  - Use profileScraperMode to choose short (no profile details) or full (headline and profile picture) author metadata.

- 📅 Powerful time filtering
  - Filter results by postedLimit: any, 24h, week, month, 3months, 6months, year to keep only recent comments.

- 📈 Scale control per post
  - Set resultLimitPerPost (1–500) to cap how many comments you collect per post, ideal for batch runs across many posts.

- 🔒 Smart connection handling
  - Optional liAt cookie support for authenticated access. The actor builds a session with CSRF and handles rate limits with delays and exponential backoff; it can also escalate from no proxy to datacenter to residential when blocked.

- 🔌 Developer-friendly on Apify
  - Run via Apify UI or API, integrate with workflows, and automate LinkedIn comments lead extraction or sentiment analysis pipelines.

- 💾 Export-ready
  - Results land in a dataset so you can export LinkedIn comments to CSV, JSON, or Excel for BI tools and CRM ingestion.

### How to use LinkedIn Post Comments Scraper - step by step

1. Sign in to Apify.
2. Open the LinkedIn Post Comments Scraper actor.
3. Add your input under Posts:
   - In startUrls, paste one or more LinkedIn post URLs or activity/UGC IDs (e.g., https://www.linkedin.com/feed/update/urn:li:activity:7289521182721093633/ or 7289521182721093633).
4. Configure limits and filters:
   - resultLimitPerPost: Set how many comments per post to collect (1–500; default 10).
   - postedLimit: Keep only comments from the last 24h, week, month, 3months, 6months, or year (default any).
   - scrapeReplies: Enable to include nested replies.
   - profileScraperMode: Choose short (no profile details) or full (adds headline and profile picture).
5. Provide authentication:
   - liAt: Paste your LinkedIn li_at cookie for logged-in access. Without a valid li_at, LinkedIn requires authentication to fetch comments and the actor will likely fail.
6. (Optional) Set Proxy Configuration:
   - Leave default for direct connection, or enable Apify Proxy. The actor can automatically escalate to datacenter or residential proxies if blocked.
7. Click Start:
   - The run discovers the required query, builds a session, and fetches comments in reverse chronological order with built-in delays and backoff.
8. Download your results:
   - Go to the run’s Dataset and export as CSV, JSON, or Excel for downstream analysis.

Pro tip: Use this LinkedIn comments API alternative in your data pipelines via the Apify API to automate LinkedIn comments scraping at scale and feed analytics, enrichment, or alerting workflows.

### Use cases

| Use case name | Description |
| --- | --- |
| Market research – comment sentiment tracking | Analyze how audiences react to campaigns by collecting comment text, timestamps, and reaction counts across posts. |
| Social listening – product feedback | Automate LinkedIn post comments scraping to monitor feedback on product announcements, pricing changes, or launches. |
| Lead enrichment – commenters to prospects | Export commenters and their profile links for follow-up in B2B outreach workflows, powering LinkedIn comments lead extraction. |
| Content performance – reactions vs. comments | Use the LinkedIn reactions and comments scraper outputs to correlate engagement types with content formats and topics. |
| Competitive analysis – track rivals’ posts | Scrape LinkedIn post comments for competitors’ posts to benchmark engagement patterns over time. |
| Academic research – public discourse studies | Collect structured comment threads to study discussions, diffusion, and influence on professional networks. |
| Developer pipeline – API automation | Run via Apify API and use the structured fields in Python workflows as a LinkedIn comments scraping Python alternative to brittle browser scripts. |

### Why choose LinkedIn Post Comments Scraper?

This scraper is built for precision, automation, and reliability on Apify — a production-grade alternative to browser extensions and one-off scripts.

- 🎯 Accurate, structured output: Clean fields for text, author, timestamps, reactions, and replies.
- 🧱 Reverse-chronological fetching: Consistent ordering for analytics and dashboards.
- 🧵 Replies on demand: Toggle nested threads with scrapeReplies for deeper context.
- 👤 Configurable author detail depth: Control cost and detail with profileScraperMode (short vs full).
- 📅 Robust filtering: Use postedLimit to focus on the most recent discussions.
- 🧪 Developer access: Run via UI or API and slot into existing pipelines with minimal effort.
- 🛡️ Resilient by design: Handles session setup, CSRF, delays, 429 backoff, and proxy escalation when blocked.
- 💰 Cost control: Cap collection per post with resultLimitPerPost and choose data depth to match your budget.

In short, it’s a production-ready LinkedIn post comments scraping tool that outperforms unstable alternatives while keeping your data clean and analysis-ready.

### Is it legal / ethical to use LinkedIn Post Comments Scraper?

Yes — when used responsibly. This actor is designed to collect publicly available comment data. Users are responsible for complying with LinkedIn’s terms and applicable regulations (e.g., GDPR, CCPA) in their jurisdiction.

Guidelines:
- Only collect data you are authorized to access and use.
- Provide valid authentication (li_at) and avoid abusive request patterns.
- Do not use the data for spam or misuse; respect user privacy and platform policies.
- Consult your legal team for edge cases or jurisdiction-specific requirements.

### Input parameters & output format

#### Example JSON input
```json
{
  "startUrls": [
    "https://www.linkedin.com/feed/update/urn:li:activity:7289521182721093633/",
    "7289521182721093633"
  ],
  "resultLimitPerPost": 50,
  "postedLimit": "month",
  "scrapeReplies": true,
  "profileScraperMode": "full",
  "liAt": "YOUR_LI_AT_COOKIE_HERE",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Parameters

- startUrls (array, required) — Paste one or more LinkedIn post URLs or activity IDs. Each post is scraped separately. Default: \[].
- resultLimitPerPost (integer) — How many comments to collect per post (min 1, max 500). Default: 10.
- postedLimit (string) — Only keep comments from the last 24h, week, month, 3months, 6months, year; or any for all. Default: any.
- scrapeReplies (boolean) — When on, nested replies under each comment are included. Default: false.
- profileScraperMode (string) — short (no profile details) or full (profile picture & headline). Default: short.
- liAt (string) — Optional. Paste your li\_at cookie for logged-in access. Without it, LinkedIn requires authentication and the run will likely fail. Default: "".
- proxyConfiguration (object) — Optional. Use a proxy if needed. Leave default for direct connection. Default: {"useApifyProxy": false}.

#### Example JSON output

```json
[
  {
    "comment_id": "1234567890123",
    "text": "Great announcement — congrats to the team!",
    "posted_at": {
      "timestamp": 1713648000000,
      "date": "2024-04-20 14:22:13",
      "relative": "3h"
    },
    "is_edited": false,
    "is_pinned": false,
    "comment_url": "https://www.linkedin.com/feed/update/urn:li:activity:7289521182721093633/?commentUrn=urn%3Ali%3Acomment%3A%281234567890123%29",
    "author": {
      "name": "Jane Doe",
      "headline": "Product Marketing @ Acme",
      "profile_url": "https://www.linkedin.com/in/janedoe",
      "profile_picture": "https://media.licdn.com/dms/image/..."
    },
    "stats": {
      "total_reactions": 12,
      "reactions": {
        "like": 9,
        "appreciation": 2,
        "empathy": 0,
        "interest": 1,
        "praise": 0
      },
      "comments": 3
    },
    "replies": [
      {
        "comment_id": "1234567890999",
        "text": "Totally agree!",
        "posted_at": {
          "timestamp": 1713649200000,
          "date": "2024-04-20 14:40:00",
          "relative": "2h"
        },
        "is_edited": false,
        "is_pinned": false,
        "comment_url": "https://www.linkedin.com/feed/update/urn:li:activity:7289521182721093633/?commentUrn=urn%3Ali%3Acomment%3A%281234567890999%29",
        "author": {
          "name": "John Smith",
          "headline": "Sales @ Beta",
          "profile_url": "https://www.linkedin.com/in/johnsmith",
          "profile_picture": "https://media.licdn.com/dms/image/..."
        },
        "stats": {
          "total_reactions": 2,
          "reactions": {
            "like": 2,
            "appreciation": 0,
            "empathy": 0,
            "interest": 0,
            "praise": 0
          },
          "comments": 0
        },
        "replies": [],
        "post_input": "7289521182721093633",
        "totalComments": 150
      }
    ],
    "post_input": "7289521182721093633",
    "totalComments": 150,
    "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7289521182721093633/"
  }
]
```

Notes:

- author.headline and author.profile\_picture are included only when profileScraperMode=full.
- replies will be an empty array when scrapeReplies=false or when replies don’t meet the postedLimit filter.
- stats.reactions may include the listed reaction keys; unknown keys are normalized to lowercase when present.

### FAQ

#### Do I need to log in or provide cookies to scrape LinkedIn comments?

Yes. LinkedIn requires authentication to fetch comments. This actor accepts your liAt cookie for logged-in access. If you don’t provide a valid li\_at, the run will likely fail.

#### How many comments can I scrape per post?

You can collect between 1 and 500 comments per post using resultLimitPerPost. The scraper fetches comments in reverse chronological order.

#### Can it include replies to comments?

Yes. Enable scrapeReplies to include nested replies. Replies use the same structure as top-level comments and honor the postedLimit filter.

#### What data fields are included in the output?

Each row includes postUrl, comment\_id, text, posted\_at (timestamp, date, relative), is\_edited, is\_pinned, comment\_url, author (name, headline, profile\_url, profile\_picture), stats (total\_reactions, reactions map, comments), replies, post\_input, and totalComments.

#### Can I filter by recency (e.g., last week or month)?

Yes. Use postedLimit and choose any, 24h, week, month, 3months, 6months, or year to keep only recent comments.

#### Does it support proxies or anti-blocking measures?

Yes. You can supply Proxy Configuration. The actor also handles session setup, random delays, exponential backoff on 429s, and can escalate from no proxy to datacenter to residential when blocked.

#### Can I export the comments to CSV or JSON?

Yes. Results are stored in an Apify dataset, which you can download as CSV, JSON, or Excel. This makes it a practical LinkedIn comment data scraper and LinkedIn comments export to CSV solution.

#### Is this a LinkedIn comments API alternative I can automate?

Yes. You can run the actor programmatically via the Apify API to automate LinkedIn post comments scraping and integrate with your pipelines, including Python-based workflows.

### Closing thoughts

The LinkedIn Post Comments Scraper is built to collect structured, analysis-ready comment threads and engagement data from LinkedIn posts. With flexible limits, time-based filtering, replies capture, and resilient session handling, it helps marketers, developers, analysts, and researchers automate LinkedIn comment downloader workflows at scale. Integrate via the Apify API for end-to-end automation, export to CSV/JSON/Excel, and start extracting smarter insights from the conversations that matter.

# Actor input Schema

## `startUrls` (type: `array`):

Paste one or more LinkedIn post URLs or activity IDs. Each post is scraped separately.

## `resultLimitPerPost` (type: `integer`):

How many comments to collect per post. Higher = more data, longer run.

## `postedLimit` (type: `string`):

Only keep comments from the last 24h, week, month, etc. Leave as 'Any' for all.

## `scrapeReplies` (type: `boolean`):

When on, nested replies under each comment are included.

## `profileScraperMode` (type: `string`):

Short = fewer fields, lower cost. Full = profile picture & headline.

## `liAt` (type: `string`):

Optional. Paste your li\_at cookie for logged-in access. Get it from browser dev tools.

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

Optional. Use a proxy if needed. Leave default for direct connection.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.linkedin.com/feed/update/urn:li:activity:7289521182721093633/"
  ],
  "resultLimitPerPost": 10,
  "postedLimit": "any",
  "scrapeReplies": false,
  "profileScraperMode": "short",
  "liAt": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.linkedin.com/feed/update/urn:li:activity:7289521182721093633/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/linkedin-post-comments-scraper").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 = {
    "startUrls": ["https://www.linkedin.com/feed/update/urn:li:activity:7289521182721093633/"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/linkedin-post-comments-scraper").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 '{
  "startUrls": [
    "https://www.linkedin.com/feed/update/urn:li:activity:7289521182721093633/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/linkedin-post-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Post Comments Scraper",
        "description": "Extract comments from any LinkedIn post quickly and reliably. This Apify actor captures comment text, usernames, timestamps, and engagement data. Perfect for sentiment analysis, audience insights, and tracking discussions with clean, structured output ready for use.",
        "version": "0.1",
        "x-build-id": "3iXSaS6eyiT8QFF4q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-engine~linkedin-post-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-engine-linkedin-post-comments-scraper",
                "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/scraper-engine~linkedin-post-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraper-engine-linkedin-post-comments-scraper",
                "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/scraper-engine~linkedin-post-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-engine-linkedin-post-comments-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗 Posts",
                        "type": "array",
                        "description": "Paste one or more LinkedIn post URLs or activity IDs. Each post is scraped separately.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultLimitPerPost": {
                        "title": "📊 Max Comments Per Post",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many comments to collect per post. Higher = more data, longer run.",
                        "default": 10
                    },
                    "postedLimit": {
                        "title": "📅 Posted Limit (filter)",
                        "enum": [
                            "any",
                            "24h",
                            "week",
                            "month",
                            "3months",
                            "6months",
                            "year"
                        ],
                        "type": "string",
                        "description": "Only keep comments from the last 24h, week, month, etc. Leave as 'Any' for all.",
                        "default": "any"
                    },
                    "scrapeReplies": {
                        "title": "💬 Scrape Replies",
                        "type": "boolean",
                        "description": "When on, nested replies under each comment are included.",
                        "default": false
                    },
                    "profileScraperMode": {
                        "title": "👤 Profile Scraper Mode",
                        "enum": [
                            "short",
                            "full"
                        ],
                        "type": "string",
                        "description": "Short = fewer fields, lower cost. Full = profile picture & headline.",
                        "default": "short"
                    },
                    "liAt": {
                        "title": "🍪 LinkedIn Cookie (li_at)",
                        "type": "string",
                        "description": "Optional. Paste your li_at cookie for logged-in access. Get it from browser dev tools.",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy Configuration",
                        "type": "object",
                        "description": "Optional. Use a proxy if needed. Leave default for direct connection."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
