# Bluesky Brand Monitor — Mentions, Keywords & Hashtags (`vamsi-krishna/bluesky-brand-monitor`) Actor

Monitor Bluesky (bsky.app) for brand mentions, keywords, and hashtags. Deduped mention feed, delta mode for schedules, and engagement spike alerts. Handles/threads need no login; search needs a free app password. JSON for social listening and AI agents.

- **URL**: https://apify.com/vamsi-krishna/bluesky-brand-monitor.md
- **Developed by:** [Vamsi Krishna](https://apify.com/vamsi-krishna) (community)
- **Categories:** Social media, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 post collecteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does Bluesky Brand Monitor do?

**Bluesky Brand Monitor** scrapes public posts, profiles, and threads from [Bluesky](https://bsky.app) (bsky.app). Use it as a **Bluesky API** alternative for **brand mention monitoring**, **keyword search**, **hashtag tracking**, and **account activity** — without a browser.

Collect structured JSON for social listening, competitor research, influencer analysis, and RAG / LLM datasets.

### Why scrape Bluesky?

Bluesky is growing fast for tech, media, and brand conversations. This Actor helps you:

- Track **brand mentions** and competitor keywords in real time
- Build a **deduped mention feed** across keywords, hashtags, and handles in one run
- Use **delta mode** (`onlyNewPosts`) so scheduled runs return only new posts
- Get an **alert summary** with top posts by engagement and spike detection vs the previous run
- Monitor public **handles** and post **threads** (no login required)
- Search posts by **keyword** or **hashtag** (free Bluesky app password)
- Filter by author, domain, mentions, language, and date range

Run on a schedule, call it from the Apify API, or connect it to AI agents via **Apify MCP**.

### What data can Bluesky Brand Monitor extract?

| Field | Description |
|-------|-------------|
| `text` | Post content |
| `url` | Public Bluesky post URL |
| `createdAt` | Post timestamp |
| `likeCount` / `repostCount` / `replyCount` / `quoteCount` | Engagement metrics |
| `engagementTotal` | Sum of engagement counts |
| `authorHandle` / `authorDisplayName` | Author identity |
| `authorFollowers` / `authorBio` | Profile stats (when enrichment is on) |
| `hashtags` / `mentions` / `urls` | Entities in the post |
| `mediaUrls` | Image, video, or link embeds |
| `sourceType` / `sourceQuery` | How the post was found (merged when it matches multiple sources) |

Key-value store also includes **author profiles**, an **alert summary** (top posts, spikes), and **delta state** when `onlyNewPosts` is enabled.

### How to scrape Bluesky posts

1. Open this Actor in [Apify Console](https://console.apify.com).
2. Choose a mode:
   - **Handles** — recent posts from public accounts (no login)
   - **Post URLs** — a post and its reply thread (no login)
   - **Keywords / hashtags** — search public posts (requires a free Bluesky app password)
3. Set `maxResults` (and optional filters like `since`, `authorFilter`, or `domainFilter`).
4. Click **Start** and download results as JSON, CSV, Excel, or HTML.

#### Example: monitor an account (no login)

```json
{
  "handles": ["bsky.app"],
  "maxResults": 50
}
````

#### Example: brand keyword search

Create an app password at [bsky.app](https://bsky.app) → **Settings → App Passwords**, then:

```json
{
  "searchQueries": ["your brand", "competitor"],
  "hashtags": ["yourbrand"],
  "since": "2026-01-01",
  "sort": "latest",
  "blueskyHandle": "yourname.bsky.social",
  "blueskyAppPassword": "xxxx-xxxx-xxxx-xxxx",
  "maxResults": 100
}
```

#### Example: scheduled brand monitoring (only new posts)

```json
{
  "searchQueries": ["your brand"],
  "hashtags": ["yourbrand"],
  "handles": ["competitor.bsky.social"],
  "onlyNewPosts": true,
  "topPostsLimit": 5,
  "blueskyHandle": "yourname.bsky.social",
  "blueskyAppPassword": "xxxx-xxxx-xxxx-xxxx",
  "maxResults": 50
}
```

Schedule this in Apify Console. Each run returns only posts not seen before, plus a `summary` record with `topPosts`, `isSpike`, and engagement deltas for alerts.

### How much does it cost to scrape Bluesky?

This Actor uses **pay-per-event** billing: you pay for posts collected, not for idle browser time. It uses the official AT Protocol HTTP APIs (no browser), so runs stay fast and compute-light.

Configure pricing in Apify Console when you publish or run the Actor. Apify free-tier credits are enough to try small runs.

### Input

See the **Input** tab for the full form. Main options:

| Field | Description |
|-------|-------------|
| `handles` | Bluesky accounts to monitor (default: `bsky.app`) |
| `searchQueries` | Keywords to search (needs app password) |
| `hashtags` | Hashtags without `#` (needs app password) |
| `postUrls` | Post URLs to fetch with reply threads |
| `maxResults` | Max posts per source (default: 50) |
| `maxTotalResults` | Cap across all sources (default: 5000) |
| `authorFilter` / `domainFilter` / `mentionsFilter` | Narrow search results |
| `since` / `until` | Date range for search |
| `enrichAuthorProfiles` | Attach follower counts and bio to posts |
| `onlyNewPosts` | Delta mode: only posts not seen in previous runs |
| `topPostsLimit` | Highest-engagement posts in the alert summary |
| `spikeThreshold` | Multiplier vs previous run to flag `isSpike` |
| `blueskyHandle` / `blueskyAppPassword` | Required only for keyword and hashtag search |

### Output

Results go to the default **dataset**. Download as JSON, CSV, Excel, or HTML.

```json
{
  "type": "post",
  "url": "https://bsky.app/profile/bsky.app/post/3mpok7nkjtc2o",
  "text": "Post content...",
  "createdAt": "2026-07-02T17:21:51.498Z",
  "likeCount": 1200,
  "repostCount": 340,
  "replyCount": 89,
  "quoteCount": 18,
  "engagementTotal": 1647,
  "authorHandle": "bsky.app",
  "authorFollowers": 850000,
  "hashtags": ["opensource"],
  "sourceType": "handle",
  "sourceQuery": "bsky.app"
}
```

Key-value store records:

- `summary` — alert payload: `topPosts`, `isSpike`, `postDelta`, `engagementChangePct`, errors
- `deltaState` — seen post IDs when `onlyNewPosts` is enabled
- `profiles` — author profiles when `includeProfiles` is enabled

### Tips for better Bluesky brand monitoring

- Enable **`onlyNewPosts`** on schedules so you only pay for and alert on new mentions.
- Combine keywords, hashtags, and handles in one run — duplicates are merged into a single mention feed with multi-source attribution.
- Read `summary.isSpike` and `summary.topPosts` for Slack/email alerts or agent workflows.
- Use **handles** or **post URLs** when you only need public feeds — no credentials required.
- Combine `searchQueries` with `domainFilter` or `mentionsFilter` for tighter brand filters.
- Lower `maxResults` and turn off `enrichAuthorProfiles` for cheaper, faster runs.

### FAQ

#### Do I need a Bluesky account?

Only for **keyword** and **hashtag** search. Monitoring handles and post threads works on the public API with no login.

#### Is this a Bluesky API?

It uses Bluesky’s official **AT Protocol** endpoints (`public.api.bsky.app` and authenticated search on `bsky.social`). You get structured post and profile data without building your own client.

#### Can I use this for social listening and sentiment analysis?

Yes. Export posts with engagement metrics, hashtags, mentions, and author stats, then pipe them into your analytics or LLM pipeline.

#### How do I run this from code or an AI agent?

Use the **API** tab in Apify Console for OpenAPI / HTTP access. For AI agents, connect the Actor through [Apify MCP](https://mcp.apify.com) and call it as a tool for brand checks (e.g. “any new mentions of X on Bluesky?” with `onlyNewPosts: true`).

#### Is it legal to scrape Bluesky?

This Actor only collects **public** posts and profiles that users have shared on Bluesky. It does not extract private data such as emails or private messages. Results may still include personal data protected by GDPR and similar laws. Only scrape when you have a legitimate purpose, and consult legal counsel if you are unsure.

For bugs or feature requests, use the **Issues** tab on this Actor’s page.

# Actor input Schema

## `handles` (type: `array`):

Bluesky handles to fetch recent posts from (no login required). Example: \['bsky.app', 'jay.bsky.team']

## `searchQueries` (type: `array`):

Search public Bluesky posts by keyword. Requires Bluesky app password below.

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

Search posts by hashtag (requires Bluesky app password). Do not include the # symbol.

## `postUrls` (type: `array`):

Bluesky post URLs to fetch with reply threads.

## `authorFilter` (type: `string`):

Limit keyword/hashtag search to posts from this handle.

## `domainFilter` (type: `string`):

Limit search to posts linking to this domain (e.g. apify.com).

## `mentionsFilter` (type: `string`):

Limit search to posts mentioning this handle.

## `since` (type: `string`):

Only include posts on or after this date (ISO date YYYY-MM-DD or full datetime). Applies to search.

## `until` (type: `string`):

Only include posts before this date (ISO date YYYY-MM-DD or full datetime). Applies to search.

## `sort` (type: `string`):

Sort order for keyword/hashtag search results.

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

ISO 639-1 language code to filter search results (e.g. en, es).

## `maxResults` (type: `integer`):

Maximum posts to collect per search query, handle, or hashtag.

## `maxTotalResults` (type: `integer`):

Global cap on posts collected across all sources in one run.

## `profileEnrichmentConcurrency` (type: `integer`):

Number of parallel profile fetches when enriching author stats.

## `requestPacingMs` (type: `integer`):

Delay between API requests to reduce rate-limit errors.

## `includeReplies` (type: `boolean`):

When monitoring handles, include reply posts (not just top-level posts).

## `includeThreadReplies` (type: `boolean`):

When fetching post URLs, include nested reply threads.

## `includeProfiles` (type: `boolean`):

Fetch and store full author profiles for monitored handles and unique post authors.

## `enrichAuthorProfiles` (type: `boolean`):

Attach follower counts and bio to each post by fetching author profiles.

## `onlyNewPosts` (type: `boolean`):

For scheduled brand monitoring: only return posts not seen in previous runs. Stores seen post IDs in the key-value store.

## `topPostsLimit` (type: `integer`):

How many highest-engagement posts to include in the run summary for alerts.

## `spikeThreshold` (type: `number`):

Flag isSpike when post count or average engagement is at least this multiple of the previous run (e.g. 1.5 = 50% increase).

## `blueskyHandle` (type: `string`):

Your Bluesky handle (e.g. yourname.bsky.social). Required for keyword/hashtag search.

## `blueskyAppPassword` (type: `string`):

App password from Bluesky Settings → App Passwords. Required for keyword/hashtag search.

## Actor input object example

```json
{
  "handles": [
    "bsky.app"
  ],
  "searchQueries": [],
  "hashtags": [],
  "postUrls": [],
  "authorFilter": "",
  "domainFilter": "",
  "mentionsFilter": "",
  "since": "",
  "until": "",
  "sort": "latest",
  "language": "",
  "maxResults": 50,
  "maxTotalResults": 5000,
  "profileEnrichmentConcurrency": 8,
  "requestPacingMs": 75,
  "includeReplies": false,
  "includeThreadReplies": true,
  "includeProfiles": true,
  "enrichAuthorProfiles": true,
  "onlyNewPosts": false,
  "topPostsLimit": 5,
  "spikeThreshold": 1.5,
  "blueskyHandle": ""
}
```

# Actor output Schema

## `posts` (type: `string`):

No description

## `profiles` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `deltaState` (type: `string`):

No description

# 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 = {
    "handles": [
        "bsky.app"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vamsi-krishna/bluesky-brand-monitor").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 = { "handles": ["bsky.app"] }

# Run the Actor and wait for it to finish
run = client.actor("vamsi-krishna/bluesky-brand-monitor").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 '{
  "handles": [
    "bsky.app"
  ]
}' |
apify call vamsi-krishna/bluesky-brand-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=vamsi-krishna/bluesky-brand-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Brand Monitor — Mentions, Keywords & Hashtags",
        "description": "Monitor Bluesky (bsky.app) for brand mentions, keywords, and hashtags. Deduped mention feed, delta mode for schedules, and engagement spike alerts. Handles/threads need no login; search needs a free app password. JSON for social listening and AI agents.",
        "version": "1.0",
        "x-build-id": "TJqQeRbH6TDzmi0g1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vamsi-krishna~bluesky-brand-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vamsi-krishna-bluesky-brand-monitor",
                "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/vamsi-krishna~bluesky-brand-monitor/runs": {
            "post": {
                "operationId": "runs-sync-vamsi-krishna-bluesky-brand-monitor",
                "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/vamsi-krishna~bluesky-brand-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-vamsi-krishna-bluesky-brand-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "handles": {
                        "title": "Handles to monitor",
                        "type": "array",
                        "description": "Bluesky handles to fetch recent posts from (no login required). Example: ['bsky.app', 'jay.bsky.team']",
                        "default": [
                            "bsky.app"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Keyword search queries",
                        "type": "array",
                        "description": "Search public Bluesky posts by keyword. Requires Bluesky app password below.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "hashtags": {
                        "title": "Hashtags",
                        "type": "array",
                        "description": "Search posts by hashtag (requires Bluesky app password). Do not include the # symbol.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "postUrls": {
                        "title": "Post URLs",
                        "type": "array",
                        "description": "Bluesky post URLs to fetch with reply threads.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "authorFilter": {
                        "title": "Author filter (search)",
                        "type": "string",
                        "description": "Limit keyword/hashtag search to posts from this handle.",
                        "default": ""
                    },
                    "domainFilter": {
                        "title": "Domain filter (search)",
                        "type": "string",
                        "description": "Limit search to posts linking to this domain (e.g. apify.com).",
                        "default": ""
                    },
                    "mentionsFilter": {
                        "title": "Mentions filter (search)",
                        "type": "string",
                        "description": "Limit search to posts mentioning this handle.",
                        "default": ""
                    },
                    "since": {
                        "title": "Since date",
                        "type": "string",
                        "description": "Only include posts on or after this date (ISO date YYYY-MM-DD or full datetime). Applies to search.",
                        "default": ""
                    },
                    "until": {
                        "title": "Until date",
                        "type": "string",
                        "description": "Only include posts before this date (ISO date YYYY-MM-DD or full datetime). Applies to search.",
                        "default": ""
                    },
                    "sort": {
                        "title": "Search sort order",
                        "enum": [
                            "latest",
                            "top"
                        ],
                        "type": "string",
                        "description": "Sort order for keyword/hashtag search results.",
                        "default": "latest"
                    },
                    "language": {
                        "title": "Language filter",
                        "type": "string",
                        "description": "ISO 639-1 language code to filter search results (e.g. en, es).",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum posts to collect per search query, handle, or hashtag.",
                        "default": 50
                    },
                    "maxTotalResults": {
                        "title": "Max total results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Global cap on posts collected across all sources in one run.",
                        "default": 5000
                    },
                    "profileEnrichmentConcurrency": {
                        "title": "Profile enrichment concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of parallel profile fetches when enriching author stats.",
                        "default": 8
                    },
                    "requestPacingMs": {
                        "title": "Request pacing (ms)",
                        "minimum": 0,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Delay between API requests to reduce rate-limit errors.",
                        "default": 75
                    },
                    "includeReplies": {
                        "title": "Include replies in handle feeds",
                        "type": "boolean",
                        "description": "When monitoring handles, include reply posts (not just top-level posts).",
                        "default": false
                    },
                    "includeThreadReplies": {
                        "title": "Include thread replies",
                        "type": "boolean",
                        "description": "When fetching post URLs, include nested reply threads.",
                        "default": true
                    },
                    "includeProfiles": {
                        "title": "Save author profiles",
                        "type": "boolean",
                        "description": "Fetch and store full author profiles for monitored handles and unique post authors.",
                        "default": true
                    },
                    "enrichAuthorProfiles": {
                        "title": "Enrich author stats on posts",
                        "type": "boolean",
                        "description": "Attach follower counts and bio to each post by fetching author profiles.",
                        "default": true
                    },
                    "onlyNewPosts": {
                        "title": "Only new posts (delta mode)",
                        "type": "boolean",
                        "description": "For scheduled brand monitoring: only return posts not seen in previous runs. Stores seen post IDs in the key-value store.",
                        "default": false
                    },
                    "topPostsLimit": {
                        "title": "Top posts in alert summary",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many highest-engagement posts to include in the run summary for alerts.",
                        "default": 5
                    },
                    "spikeThreshold": {
                        "title": "Spike threshold",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "number",
                        "description": "Flag isSpike when post count or average engagement is at least this multiple of the previous run (e.g. 1.5 = 50% increase).",
                        "default": 1.5
                    },
                    "blueskyHandle": {
                        "title": "Bluesky handle (for search)",
                        "type": "string",
                        "description": "Your Bluesky handle (e.g. yourname.bsky.social). Required for keyword/hashtag search.",
                        "default": ""
                    },
                    "blueskyAppPassword": {
                        "title": "Bluesky app password (for search)",
                        "type": "string",
                        "description": "App password from Bluesky Settings → App Passwords. Required for keyword/hashtag search."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
