# LinkedIn Hashtag Posts Scraper (`crawlerbros/linkedin-hashtag-posts-scraper`) Actor

Scrape posts tagged with any LinkedIn hashtag (e.g. #AI, #marketing). Returns author, content, engagement metrics. Cookie optional for public access, recommended for more results.

- **URL**: https://apify.com/crawlerbros/linkedin-hashtag-posts-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are 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 Hashtag Posts Scraper

Scrape posts tagged with any LinkedIn hashtag (e.g. `#AI`, `#marketing`, `#python`). Returns post content, author information, and engagement metrics for each post.

Cookie is **optional** — public hashtag pages work without authentication, but providing a LinkedIn session cookie unlocks significantly more results and higher pagination limits.

### Features

- Scrape posts for one or more hashtags in a single run
- Accepts hashtags in any format: `#AI`, `AI`, `artificial-intelligence`
- Returns author name, headline, profile URL, post content, media type, and full engagement counts
- Optional LinkedIn cookie for higher result volumes (Voyager API mode)
- Automatic fallback to public HTML mode when no cookie is supplied
- Handles rate limiting with automatic retries and exponential backoff
- Proxy support via Apify proxy configuration

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `hashtags` | array | Yes | List of hashtags to scrape (e.g. `["AI", "marketing"]`) |
| `maxPostsPerHashtag` | integer | No | Max posts per hashtag (default: 50, max: 500) |
| `cookie` | string | No | LinkedIn `li_at` cookie or full browser cookies JSON. Optional but recommended for more results. |
| `proxyConfiguration` | object | No | Apify proxy configuration. Residential proxy recommended. |

#### Hashtag Formats Accepted

The actor normalizes hashtag input — the following are all equivalent:
- `#AI`
- `AI`
- `#artificial-intelligence`
- `artificial-intelligence`

#### Cookie Format

Two formats are supported:

**Plain `li_at` value** (copy from DevTools → Application → Cookies):
````

AQEDATVc5uMEM5s\_AAABnro67c...

````

**Full cookies JSON array** (export from a browser extension like EditThisCookie):
```json
[
  {"name": "li_at", "value": "AQEDATVc5uMEM5s_...", "domain": ".linkedin.com", ...},
  {"name": "JSESSIONID", "value": "ajax:67453...", "domain": ".linkedin.com", ...}
]
````

### Output

Each item in the dataset represents one LinkedIn post:

| Field | Type | Description |
|---|---|---|
| `postId` | string | LinkedIn activity ID |
| `postUrl` | string | Direct link to the post |
| `authorName` | string | Full name of the post author |
| `authorProfileUrl` | string | Author's LinkedIn profile URL |
| `authorHeadline` | string | Author's LinkedIn headline |
| `postedAt` | string | ISO 8601 UTC timestamp of publication |
| `content` | string | Full post text |
| `mediaType` | string | Media type: `text`, `image`, `video`, `article`, `document`, `carousel`, `repost`, `poll`, `event` |
| `reactionsCount` | integer | Total reactions count |
| `commentsCount` | integer | Total comments count |
| `repostsCount` | integer | Total reposts/shares count |
| `hashtag` | string | Normalized hashtag that produced this result (e.g. `ai`) |
| `scrapedAt` | string | ISO 8601 UTC timestamp when scraped |

#### Example Output

```json
{
  "postId": "7381299540293623808",
  "postUrl": "https://www.linkedin.com/feed/update/urn:li:activity:7381299540293623808/",
  "authorName": "Jane Doe",
  "authorProfileUrl": "https://www.linkedin.com/in/janedoe",
  "authorHeadline": "AI Product Manager at Acme Corp",
  "postedAt": "2025-05-23T09:23:20+00:00",
  "content": "Excited to share our latest research on large language models! #AI #MachineLearning",
  "mediaType": "text",
  "reactionsCount": 842,
  "commentsCount": 67,
  "repostsCount": 34,
  "hashtag": "ai",
  "scrapedAt": "2025-05-24T14:00:00.000000+00:00"
}
```

### Cookie vs. Public Mode

| Mode | Cookie | Results Volume | Notes |
|---|---|---|---|
| **Voyager API** | Required | Up to 500 posts per hashtag | Uses authenticated LinkedIn API |
| **Public HTML** | Not needed | Limited (typically 10-20 per hashtag) | Parses embedded SSR JSON from public page |

For best results, provide a valid LinkedIn cookie.

### FAQ

**Do I need to log in to LinkedIn?**
No — the actor works without a cookie by scraping the public hashtag page. However, results will be limited. For full scraping capability, provide your `li_at` cookie.

**How do I get my LinkedIn cookie?**

1. Log in to LinkedIn in your browser
2. Open DevTools (F12) → Application → Cookies → `www.linkedin.com`
3. Copy the value of the `li_at` cookie

**Will this get my account banned?**
The actor uses LinkedIn's official Voyager API with realistic request rates and delays. We recommend using residential proxies for higher volumes to reduce risk.

**How many posts can I scrape per hashtag?**
With a cookie: up to 500. Without a cookie: typically 10-20 posts from the public page.

**What hashtag formats does the actor accept?**
`#AI`, `AI`, `#machine-learning`, `machine-learning` — all are normalized automatically.

**Why are some fields missing from some posts?**
The actor only includes fields that can be reliably populated. Posts with missing author headlines or media types will omit those optional fields.

**Can I scrape multiple hashtags at once?**
Yes — provide a list in the `hashtags` field: `["AI", "marketing", "python"]`.

### Explore the rest of the LinkedIn suite

Need a different LinkedIn surface? Pair this actor with any of the others in the LinkedIn Suite — all published under the same publisher and built to share the same cookie format and output conventions.

| Actor | What it scrapes |
|---|---|
| [LinkedIn Comments Scraper](https://apify.com/crawlerbros/linkedin-comments-scraper) | All comments + reply threads on a post |
| [LinkedIn Company Employees Scraper](https://apify.com/crawlerbros/linkedin-company-employees-scraper) | Employee list for any company (by URN) |
| [LinkedIn Company Info Scraper](https://apify.com/crawlerbros/linkedin-company-info-scraper) | Company About page (size, HQ, industry, specialties) |
| [LinkedIn Company Posts Scraper](https://apify.com/crawlerbros/linkedin-company-posts-scraper) | Posts published from a company page |
| [LinkedIn Events Scraper](https://apify.com/crawlerbros/linkedin-events-scraper) | Events by keyword/URL with full event detail |
| [LinkedIn Jobs Scraper](https://apify.com/crawlerbros/linkedin-jobs-scraper) | Job listings via the public jobs-guest API |
| [LinkedIn Jobs Scraper Ultra](https://apify.com/crawlerbros/linkedin-jobs-scraper-ultra) | Same as jobs-scraper + full detail enrichment |
| [LinkedIn Learning Courses Scraper](https://apify.com/crawlerbros/linkedin-learning-courses-scraper) | LinkedIn Learning course catalog by keyword |
| [LinkedIn People Search Scraper](https://apify.com/crawlerbros/linkedin-people-search-scraper) | People search with every LinkedIn facet (role, company, school, location, etc.) |
| [LinkedIn Post Reactions Scraper](https://apify.com/crawlerbros/linkedin-post-reactions-scraper) | Reactors on a post (name, headline, reaction type) |
| [LinkedIn Post Scraper](https://apify.com/crawlerbros/linkedin-post-scraper) | Full post (text, media, engagement counts, author) |
| [LinkedIn Post Search Scraper](https://apify.com/crawlerbros/linkedin-post-search-scraper) | Posts matching a keyword (with date/author/network filters) |
| [LinkedIn Profile Posts Scraper](https://apify.com/crawlerbros/linkedin-profile-posts-scraper) | All posts/reposts/articles for one profile |
| [LinkedIn Profile Scraper](https://apify.com/crawlerbros/linkedin-profile-scraper) | Public profile fields (name, headline, positions, education, skills) |
| [LinkedIn Profile Scraper Pro](https://apify.com/crawlerbros/linkedin-profile-scraper-pro) | Profile fields + extras (recommendations, organizations, languages) |
| [LinkedIn Profile Scraper Pro Ultra](https://apify.com/crawlerbros/linkedin-profile-scraper-pro-ultra) | Pro + premium fields (contact info, followers list when allowed) |
| [LinkedIn Profile Scraper Ultra](https://apify.com/crawlerbros/linkedin-profile-scraper-ultra) | Profile + the full upstream dash-120 surface |
| [LinkedIn Profile Search by Name](https://apify.com/crawlerbros/linkedin-profile-search-by-name) | Search profiles by person name (great for matching CSVs of names) |
| [LinkedIn Schools Alumni Scraper](https://apify.com/crawlerbros/linkedin-schools-alumni-scraper) | Alumni list for any LinkedIn school page |
| [LinkedIn Top Content Scraper](https://apify.com/crawlerbros/linkedin-top-content-scraper) | Trending / top-engagement posts by topic |
| [LinkedIn User Activity Scraper](https://apify.com/crawlerbros/linkedin-user-activity-scraper) | Reactions + comments + posts feed for one profile |

All actors share the same `cookie` input format (plain `li_at` OR full cookies JSON array) and the same omit-empty output convention.

# Actor input Schema

## `hashtags` (type: `array`):

One or more LinkedIn hashtags to scrape. Accepts formats: #AI, AI, artificial-intelligence. Results are returned for each hashtag separately.

## `maxPostsPerHashtag` (type: `integer`):

Maximum number of posts to scrape per hashtag.

## `datePosted` (type: `string`):

Filter posts by recency. 'Any time' returns all results; the time-based filters restrict to the chosen window.

## `mediaTypeFilter` (type: `string`):

Only return posts of a specific media type. Leave empty to return all types.

## `mediaType` (type: `string`):

Only return posts of a specific media type. Alias for mediaTypeFilter.

## `sortBy` (type: `string`):

Order posts by relevance (best match) or by recency.

## `authorType` (type: `string`):

Restrict results to posts authored by people or by company pages.

## `language` (type: `string`):

Filter posts by language.

## `minReactions` (type: `integer`):

Only return posts with at least this many reactions. Leave empty (or 0) for no minimum.

## `minComments` (type: `integer`):

Only return posts with at least this many comments. Leave empty (or 0) for no minimum.

## `cookie` (type: `string`):

Your LinkedIn session cookie. Optional — public hashtag pages work without it, but a cookie unlocks more results and higher rate limits. Accepts: (1) the li\_at value from browser DevTools, or (2) full cookies JSON array from an extension like EditThisCookie.

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

Optional Apify proxy configuration. Residential proxy recommended for better success rates.

## Actor input object example

```json
{
  "hashtags": [
    "AI",
    "marketing"
  ],
  "maxPostsPerHashtag": 50,
  "datePosted": "",
  "mediaTypeFilter": "",
  "mediaType": "",
  "sortBy": "relevance",
  "authorType": "",
  "language": "",
  "cookie": "AQEDATVc5uMEM5s_AAABnro67cYAAAGe3kdxxk0Ajoj1en-Axa4lUoxvqVMAsMpFO2u4rOjJfIS1U1wrBETHJHqkj5i6KReB53dmYSZDgX9K4XnaFLmn7vE30gVWegfZltSOZVu_-Ny8sl4-aAKzeN-H"
}
```

# 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 = {
    "hashtags": [
        "AI",
        "marketing"
    ],
    "cookie": "AQEDATVc5uMEM5s_AAABnro67cYAAAGe3kdxxk0Ajoj1en-Axa4lUoxvqVMAsMpFO2u4rOjJfIS1U1wrBETHJHqkj5i6KReB53dmYSZDgX9K4XnaFLmn7vE30gVWegfZltSOZVu_-Ny8sl4-aAKzeN-H"
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/linkedin-hashtag-posts-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 = {
    "hashtags": [
        "AI",
        "marketing",
    ],
    "cookie": "AQEDATVc5uMEM5s_AAABnro67cYAAAGe3kdxxk0Ajoj1en-Axa4lUoxvqVMAsMpFO2u4rOjJfIS1U1wrBETHJHqkj5i6KReB53dmYSZDgX9K4XnaFLmn7vE30gVWegfZltSOZVu_-Ny8sl4-aAKzeN-H",
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/linkedin-hashtag-posts-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 '{
  "hashtags": [
    "AI",
    "marketing"
  ],
  "cookie": "AQEDATVc5uMEM5s_AAABnro67cYAAAGe3kdxxk0Ajoj1en-Axa4lUoxvqVMAsMpFO2u4rOjJfIS1U1wrBETHJHqkj5i6KReB53dmYSZDgX9K4XnaFLmn7vE30gVWegfZltSOZVu_-Ny8sl4-aAKzeN-H"
}' |
apify call crawlerbros/linkedin-hashtag-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Hashtag Posts Scraper",
        "description": "Scrape posts tagged with any LinkedIn hashtag (e.g. #AI, #marketing). Returns author, content, engagement metrics. Cookie optional for public access, recommended for more results.",
        "version": "0.5",
        "x-build-id": "2VomSVQ0bFQFuaUE7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~linkedin-hashtag-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-linkedin-hashtag-posts-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/crawlerbros~linkedin-hashtag-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-linkedin-hashtag-posts-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/crawlerbros~linkedin-hashtag-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-linkedin-hashtag-posts-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": [
                    "hashtags"
                ],
                "properties": {
                    "hashtags": {
                        "title": "Hashtags",
                        "type": "array",
                        "description": "One or more LinkedIn hashtags to scrape. Accepts formats: #AI, AI, artificial-intelligence. Results are returned for each hashtag separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerHashtag": {
                        "title": "Max Posts Per Hashtag",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of posts to scrape per hashtag.",
                        "default": 50
                    },
                    "datePosted": {
                        "title": "Date Posted",
                        "enum": [
                            "",
                            "r86400",
                            "r604800",
                            "r2592000"
                        ],
                        "type": "string",
                        "description": "Filter posts by recency. 'Any time' returns all results; the time-based filters restrict to the chosen window.",
                        "default": ""
                    },
                    "mediaTypeFilter": {
                        "title": "Media Type Filter",
                        "enum": [
                            "",
                            "text",
                            "image",
                            "video",
                            "article",
                            "document",
                            "repost",
                            "poll"
                        ],
                        "type": "string",
                        "description": "Only return posts of a specific media type. Leave empty to return all types.",
                        "default": ""
                    },
                    "mediaType": {
                        "title": "Media Type",
                        "enum": [
                            "",
                            "text",
                            "image",
                            "video",
                            "article",
                            "document"
                        ],
                        "type": "string",
                        "description": "Only return posts of a specific media type. Alias for mediaTypeFilter.",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Order posts by relevance (best match) or by recency.",
                        "default": "relevance"
                    },
                    "authorType": {
                        "title": "Author Type",
                        "enum": [
                            "",
                            "PERSON",
                            "COMPANY"
                        ],
                        "type": "string",
                        "description": "Restrict results to posts authored by people or by company pages.",
                        "default": ""
                    },
                    "language": {
                        "title": "Post Language",
                        "enum": [
                            "",
                            "en",
                            "es",
                            "fr",
                            "de",
                            "pt",
                            "it",
                            "nl",
                            "zh",
                            "ja"
                        ],
                        "type": "string",
                        "description": "Filter posts by language.",
                        "default": ""
                    },
                    "minReactions": {
                        "title": "Minimum Reactions",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return posts with at least this many reactions. Leave empty (or 0) for no minimum."
                    },
                    "minComments": {
                        "title": "Minimum Comments",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only return posts with at least this many comments. Leave empty (or 0) for no minimum."
                    },
                    "cookie": {
                        "title": "LinkedIn Cookie (optional)",
                        "type": "string",
                        "description": "Your LinkedIn session cookie. Optional — public hashtag pages work without it, but a cookie unlocks more results and higher rate limits. Accepts: (1) the li_at value from browser DevTools, or (2) full cookies JSON array from an extension like EditThisCookie."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional Apify proxy configuration. Residential proxy recommended for better success rates."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
