# Linkedin Post Scraper (`scrapelabsapi/linkedin-post-scraper`) Actor

📝 LinkedIn Post Scraper (linkedin-post-scraper) extracts public posts: text, author, date, reactions, comments, shares, hashtags & media URLs. 📊 Ideal for content research, competitor tracking, social listening & lead gen. ⚡ Fast, reliable, CSV/JSON-ready. #LinkedIn

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 Scraper

The Linkedin Post Scraper is a fast, reliable LinkedIn post extractor that collects public post content, authors, timestamps, images, reactions, and comments from LinkedIn company and personal profile URLs. It helps you scrape LinkedIn posts at scale for content research, competitor tracking, and social listening — ideal for marketers, developers, data analysts, and researchers. With a focus on clean exports and automation, it enables repeatable LinkedIn feed scraper workflows without browser extensions.

### What data / output can you get?

This LinkedIn post scraping tool outputs structured JSON for each post, ready to export LinkedIn posts to CSV, JSON, or Excel. Below are real fields the actor writes to the Apify dataset:

| Data field | Description | Example |
| --- | --- | --- |
| urn | Stable post identifier derived from activity URL | urn:li:activity:7234567890123456789 |
| text | Post text content | “Excited to announce our new product launch!” |
| url | Canonical post URL (when available in page data) | https://www.linkedin.com/feed/update/urn:li:activity:7234567890123456789 |
| postedAtTimestamp | Milliseconds since epoch (UTC) | 1742299200000 |
| postedAtISO | ISO timestamp | 2026-03-18T12:00:00.000Z |
| timeSincePosted | Relative time helper | 2d |
| authorType | “Company” or “Person” | Company |
| authorProfileUrl | Source profile or company URL that was scraped | https://www.linkedin.com/company/google/ |
| authorProfileId | Author identifier (derived from URL or author data) | google |
| authorFullName | Author display name from page metadata | Google |
| authorHeadline | Author/company description from page metadata | “Our mission is to…” |
| type | Post type inferred from media (“image” or “text”) | image |
| image | Primary image URL if present | https://media.licdn.com/dms/image/… |
| images | Array of image URLs extracted from the post | ["https://media.licdn.com/dms/image/…"] |
| author.firstName | Author’s first name (for Person) | Sundar |
| author.lastName | Author’s last name (for Person) | Pichai |
| author.publicId | Public ID derived from the URL | google |
| numLikes | Parsed like/reaction count | 152 |
| numComments | Parsed comment count | 12 |
| numShares | Share count field (defaults to 0 when unavailable) | 0 |
| comments | Array of comment objects with author and text | [{"text": "Congrats!", …}] |
| reactions | Array of reaction objects with reactor profiles | [{"type": "LOVE", …}] |
| attributes | Mentions extracted from text/HTML (PROFILE_MENTION) | [{"type":"PROFILE_MENTION", …}] |
| commentsTruncated | True if only a subset of comments are included | true |
| commentsComplete | True if all comments are included | false |
| reactionsTruncated | True if only a subset of reactions are included | true |
| canReact / canPostComments / canShare | Capability flags (booleans) | true |
| commentingDisabled | Whether comments are disabled | false |
| allowedCommentersScope | Commenting scope | ALL |
| rootShare | Whether the post is a root share | true |
| shareAudience | Post audience | PUBLIC |

Notes:
- When “raw data” is enabled in input, each post also includes rawHtml containing the underlying HTML document.
- Exports are available in JSON, CSV, or Excel via Apify Dataset. A full JSON array is also saved to the key-value store as linkedin_posts.json.

### Key features

- ⚡ Fast public post extraction  
  Collects post text, timestamps, images, comments, and reactions from public LinkedIn pages — a dependable LinkedIn post extractor for research and monitoring.

- 🔍 Deep engagement capture  
  Enable deepScrape to enrich output with more engagement details like reactions and comments, making it a capable LinkedIn post reactions scraper and LinkedIn post comments scraper.

- 🗓️ Date cutoff filtering  
  Use scrapeUntil to include only posts from a specified date onward — perfect for time-bounded LinkedIn post analytics scraper workflows.

- 📦 Clean, structured outputs  
  Dataset-ready JSON with stable field names and arrays (comments, reactions, images). Easily export LinkedIn posts to CSV, JSON, or Excel.

- 🧪 Raw HTML (advanced)  
  Toggle rawData to include rawHtml for each post — ideal for custom parsing, QA, or building your own LinkedIn post scraping tool logic downstream.

- 📚 Batch scraping control  
  Limit results per source with limitPerSource to build reliable pipelines across multiple profiles — a practical LinkedIn profile posts scraper for teams.

- 🌐 Proxy-ready reliability  
  Optional proxyConfiguration for robust, production-grade runs with fewer rate-limit issues.

- 🔌 API-friendly and automation-ready  
  Run via the Apify API and integrate with n8n or Make.com. Developers can plug results into a LinkedIn post scraper Python workflow for analytics, enrichment, or BI.

- 🧩 No browser extension required  
  Server-side actor — no LinkedIn post scraper Chrome extension needed. More stable than ad-hoc tools and easier to automate.

### How to use Linkedin Post Scraper - step by step

1) Sign in to Apify  
Create or log in to your Apify account.

2) Open the actor  
Find “linkedin-post-scraper” in the Apify Store and click Try for free.

3) Add input URLs  
Paste one or more LinkedIn company or personal profile URLs into urls (e.g., https://www.linkedin.com/company/google/). Multiple sources are supported.

4) Configure limits and date  
Set limitPerSource to control the number of posts per URL. Optionally set scrapeUntil (YYYY-MM-DD) to filter for newer posts only.

5) Choose data depth  
Keep deepScrape enabled to capture richer engagement details. Enable rawData if you need rawHtml for each post.

6) Set proxy (optional)  
Add proxyConfiguration for improved stability and to avoid rate limits (recommended for higher-volume runs).

7) Run the actor  
Click Start. The actor fetches each URL and collects posts. Status logs will show progress per source and totals.

8) Download results  
Go to the Dataset tab to export LinkedIn posts in JSON, CSV, or Excel. You’ll also find a combined JSON array saved as linkedin_posts.json in the key-value store.

Pro tip: Use the Apify API to schedule runs and pipe results into your data warehouse, or connect with n8n/Make for an automated LinkedIn feed scraper pipeline.

### Use cases

| Use case | Description |
| --- | --- |
| Social listening & brand monitoring | Track public posts, comments, and reactions to measure sentiment and engagement over time. |
| Competitor content tracking | Compare posting cadence, topics, and engagement across companies or thought leaders. |
| Content research & analytics | Build a dataset of post text and media for topic analysis, benchmarking, and LinkedIn post analytics scraper workflows. |
| Campaign performance review | Aggregate reactions and comments to assess content resonance without manual copy-paste. |
| Lead gen & outreach enrichment | Use public posts to personalize outreach and identify active accounts for follow-up. |
| Editorial planning | Identify themes that drive engagement and plan your editorial calendar accordingly. |
| Academic & market research | Collect public content for longitudinal studies, content trends, and network analysis. |
| API pipeline for ML/NLP | Feed exported posts into a LinkedIn post scraper Python pipeline for classification, clustering, or sentiment models. |

### Why choose Linkedin Post Scraper?

The Linkedin Post Scraper is built for precision, automation, and stability at scale.

- ✅ Accurate public data extraction: Structured fields for posts, comments, and reactions — no messy parsing downstream.
- 🌍 Scalable across profiles: Control batch size per source and iterate across multiple URLs reliably.
- 💻 Developer-friendly: Works seamlessly with the Apify API and can power a LinkedIn post scraping tool or Python pipeline.
- 🔌 Automation integrations: Natively fits into Make.com and n8n workflows for hands-free operation.
- 🛡️ Safe and responsible: Targets publicly available posts only; no login or private data access.
- 💾 Easy exports: Export LinkedIn posts to JSON, CSV, or Excel for BI and enrichment.
- 🆚 Better than extensions: Server-side infrastructure is more reliable than a LinkedIn post scraper Chrome extension or manual tools.

In short, it’s a production-ready LinkedIn feed scraper that prioritizes clean structure, repeatability, and integration.

### Is it legal / ethical to use Linkedin Post Scraper?

Yes — when used responsibly. This actor collects publicly available LinkedIn content from company and personal profile pages. It does not log in, access private data, or bypass authentication.

Guidelines for responsible use:
- Scrape only public pages and content you’re allowed to process.
- Respect LinkedIn’s terms and applicable regulations (e.g., GDPR, CCPA).
- Avoid using data for spam or other unethical activities.
- Consult your legal team for edge cases or jurisdiction-specific requirements.

### Input parameters & output format

Example input
```json
{
  "urls": ["https://www.linkedin.com/company/google/"],
  "limitPerSource": 10,
  "scrapeUntil": "2026-03-01",
  "deepScrape": true,
  "rawData": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

Input parameters

- urls (array, required): Add LinkedIn company or person profile URLs to scrape — one or many! Default: none (required).
- limitPerSource (integer): How many posts to collect from each URL (minimum 1). Default: 10.
- scrapeUntil (string, nullable): Filter posts — only include content from this date onwards (YYYY-MM-DD). Default: null.
- deepScrape (boolean): Get richer data — more metadata & engagement details. Default: true.
- rawData (boolean): Include extra raw data (rawHtml) in the output for power users. Default: false.
- proxyConfiguration (object, nullable): Optional proxy configuration for reliability and rate-limit avoidance. Default: null.

Example output (one post)

```json
{
  "urn": "urn:li:activity:7234567890123456789",
  "text": "Excited to announce our new product launch!",
  "url": "https://www.linkedin.com/feed/update/urn:li:activity:7234567890123456789",
  "postedAtTimestamp": 1742299200000,
  "postedAtISO": "2026-03-18T12:00:00.000Z",
  "timeSincePosted": "2d",
  "isRepost": false,
  "authorType": "Company",
  "authorProfileUrl": "https://www.linkedin.com/company/google/",
  "authorProfileId": "google",
  "authorHeadline": "Our mission is to organize the world’s information and make it universally accessible and useful.",
  "authorFullName": "Google",
  "image": "https://media.licdn.com/dms/image/ABC123",
  "type": "image",
  "images": [
    "https://media.licdn.com/dms/image/ABC123"
  ],
  "author": {
    "firstName": null,
    "lastName": null,
    "occupation": "Our mission is to organize the world’s information and make it universally accessible and useful.",
    "id": "google",
    "publicId": "google",
    "trackingId": "Y29uZmlnLWlkLTEyMw",
    "profileId": "google",
    "picture": "https://media.licdn.com/dms/image/DEF456",
    "backgroundImage": ""
  },
  "authorName": "Google",
  "authorTitle": "Our mission is to organize the world’s information and make it universally accessible and useful.",
  "attributes": [
    {
      "start": 0,
      "length": 7,
      "type": "PROFILE_MENTION",
      "profile": {
        "firstName": "alice",
        "lastName": "",
        "occupation": "",
        "id": "user-0",
        "publicId": "alice",
        "trackingId": "YWJjLXRyYWNrLTEyMw",
        "profileId": "user-0",
        "picture": "",
        "backgroundImage": ""
      }
    }
  ],
  "comments": [
    {
      "time": 1742461200000,
      "link": "https://www.linkedin.com/feed/update/urn:li:activity:7234567890123456789",
      "text": "Congrats!",
      "entities": [],
      "pinned": false,
      "originalLanguage": "English",
      "author": {
        "firstName": "Jane",
        "lastName": "Doe",
        "occupation": "",
        "id": "commenter-a1b2c3d4e5f6",
        "publicId": "jane-doe",
        "trackingId": "ZXhhbXBsZS10cmFjay0x",
        "profileId": "commenter-a1b2c3d4e5f6",
        "picture": "",
        "backgroundImage": "",
        "distance": "OUT_OF_NETWORK"
      }
    }
  ],
  "reactions": [
    {
      "type": "LOVE",
      "profile": {
        "firstName": "John",
        "lastName": "Smith",
        "occupation": "",
        "id": "reactor-0a1b2c3d4e5f",
        "publicId": "john-smith",
        "trackingId": "cmVhY3Rvci10cmFjay0y",
        "profileId": "ACoAA0a1b2c3d",
        "picture": "",
        "backgroundImage": ""
      }
    }
  ],
  "numShares": 0,
  "numLikes": 152,
  "numComments": 12,
  "commentsTruncated": true,
  "commentsComplete": false,
  "reactionsTruncated": true,
  "canReact": true,
  "canPostComments": true,
  "canShare": true,
  "commentingDisabled": false,
  "allowedCommentersScope": "ALL",
  "rootShare": true,
  "shareAudience": "PUBLIC"
}
```

Notes:

- When rawData is true, each post also includes "rawHtml".
- The actor saves all posts to the default Dataset and writes the full array to the key-value store key linkedin\_posts.json.

### FAQ

#### Do I need to log in to scrape LinkedIn posts?

No. The actor targets publicly available LinkedIn content and does not require login. It collects posts from public company and personal profile pages.

#### Which LinkedIn URLs are supported?

Company pages, personal profile pages, and feed URLs are supported. Direct post-only links, groups, schools, or hashtag feeds are not supported by this actor and will be treated as unsupported URL types.

#### Can it scrape comments and reactions?

Yes. It extracts comment objects (with authors and text) and reaction objects (with reactor profiles and reaction type such as LIKE, LOVE, CELEBRATE, SUPPORT, FUNNY, INSIGHTFUL) when present on the public page.

#### How do I export results to CSV or Excel?

After the run, open the Dataset and use Apify’s built-in export to download CSV, JSON, or Excel. A combined JSON array is also saved as linkedin\_posts.json in the key-value store.

#### Does it work with Python and APIs?

Yes. You can trigger and fetch results via the Apify API and process them in your own LinkedIn post scraper Python pipelines. This makes it easy to automate end-to-end analytics and enrichment workflows.

#### What does deepScrape change?

With deepScrape enabled, the actor attempts to enrich output with additional engagement details (e.g., more comments/reactions where available). Disable it for faster, lighter runs.

#### Can I filter posts by date?

Yes. Set scrapeUntil (YYYY-MM-DD) to include only posts on or after that date. The actor filters results by postedAtTimestamp during processing.

#### Is this better than a Chrome extension?

For automation and reliability, yes. This server-side LinkedIn post scraping tool avoids manual steps, runs at scale, supports proxies, and integrates with pipelines — making it more stable than a LinkedIn post scraper Chrome extension.

#### Does it support LinkedIn company posts and profile posts?

Yes. It functions as a LinkedIn company posts scraper and a LinkedIn profile posts scraper, collecting public posts from both company and personal profile URLs.

#### Is it legal to use?

Yes — when scraping public data responsibly and in compliance with applicable laws and LinkedIn’s terms. It does not access private or authenticated content. Always ensure your use case is compliant.

### Closing CTA / Final thoughts

The Linkedin Post Scraper is built to reliably collect public LinkedIn posts, comments, reactions, and images from company and personal profiles at scale. With clean JSON output, CSV/Excel exports, and automation-ready design, it empowers marketers, analysts, developers, and researchers to turn the public LinkedIn feed into structured insights. Run it via the Apify API, plug results into your LinkedIn post extractor Python workflow, or orchestrate with n8n/Make. Start extracting smarter, structured LinkedIn post data today.

# Actor input Schema

## `urls` (type: `array`):

📎 Add LinkedIn company or person profile URLs to scrape — one or many!

## `limitPerSource` (type: `integer`):

🎯 How many posts to collect from each URL. More = more data!

## `scrapeUntil` (type: `string`):

🗓️ Filter posts — only include content from this date onwards. Pick from calendar!

## `deepScrape` (type: `boolean`):

✨ Get richer data — more metadata & engagement details. Recommended! 👍

## `rawData` (type: `boolean`):

🔧 For power users — include extra raw data in output. Turn off for cleaner results.

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

🛡️ Optional — use proxy for better reliability & to avoid rate limits.

## Actor input object example

```json
{
  "urls": [
    "https://www.linkedin.com/company/google/"
  ],
  "limitPerSource": 10,
  "deepScrape": true,
  "rawData": 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 = {
    "urls": [
        "https://www.linkedin.com/company/google/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapelabsapi/linkedin-post-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 = { "urls": ["https://www.linkedin.com/company/google/"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapelabsapi/linkedin-post-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 '{
  "urls": [
    "https://www.linkedin.com/company/google/"
  ]
}' |
apify call scrapelabsapi/linkedin-post-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Linkedin Post Scraper",
        "description": "📝 LinkedIn Post Scraper (linkedin-post-scraper) extracts public posts: text, author, date, reactions, comments, shares, hashtags & media URLs. 📊 Ideal for content research, competitor tracking, social listening & lead gen. ⚡ Fast, reliable, CSV/JSON-ready. #LinkedIn",
        "version": "0.2",
        "x-build-id": "DcKYBOYt9C3tIHLdk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapelabsapi~linkedin-post-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapelabsapi-linkedin-post-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/scrapelabsapi~linkedin-post-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapelabsapi-linkedin-post-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/scrapelabsapi~linkedin-post-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapelabsapi-linkedin-post-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "🔗 Source URLs (required)",
                        "type": "array",
                        "description": "📎 Add LinkedIn company or person profile URLs to scrape — one or many!",
                        "items": {
                            "type": "string"
                        }
                    },
                    "limitPerSource": {
                        "title": "📊 Limit per source",
                        "minimum": 1,
                        "type": "integer",
                        "description": "🎯 How many posts to collect from each URL. More = more data!",
                        "default": 10
                    },
                    "scrapeUntil": {
                        "title": "📅 Scrape until date",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$",
                        "type": "string",
                        "description": "🗓️ Filter posts — only include content from this date onwards. Pick from calendar!"
                    },
                    "deepScrape": {
                        "title": "🔍 Scrape additional information",
                        "type": "boolean",
                        "description": "✨ Get richer data — more metadata & engagement details. Recommended! 👍",
                        "default": true
                    },
                    "rawData": {
                        "title": "📦 Get raw data (Advanced)",
                        "type": "boolean",
                        "description": "🔧 For power users — include extra raw data in output. Turn off for cleaner results.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "🛡️ Optional — use proxy for better reliability & to avoid rate limits."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```