# Bluesky Posts Scraper — Search, Feeds & Threads (`khadinakbar/bluesky-posts-scraper`) Actor

Bluesky Posts Scraper searches public posts, exports author feeds and threads, and returns clean engagement data for research from $0.005 per result.

- **URL**: https://apify.com/khadinakbar/bluesky-posts-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 public bluesky post scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Bluesky Posts Scraper — Search, Feeds & Threads

Search public Bluesky posts, collect posts from public author feeds, or export a public post and its reply thread. Every result has the same analysis-ready shape: post text, stable AT URI, canonical URL, author identity, timestamps, engagement counts, links, hashtags, mentions, media URLs, and discovery metadata.

Use this Actor for social listening, brand and competitor monitoring, journalism, academic research, community discovery, link tracking, or Bluesky datasets for AI workflows. It needs no Bluesky login, cookies, app password, or user session. Results are available as JSON, CSV, Excel, XML, RSS, or through the Apify API and MCP integrations.

Pricing is **$0.005 per validated post** plus a **$0.00005 start event**. Apify platform usage is additional. Duplicate posts, filtered-out records, and invalid records are not charged as results. `maxResults` is a hard run-wide cap, so a value of 100 caps result-event charges at $0.50 plus the start event.

### What it collects

The Actor supports three focused workflows:

- **Keyword search:** submit phrases, hashtags, URLs, or Bluesky search syntax. Sort by latest or top results and optionally filter by time, language, author, mentioned account, linked domain, exact URL, or tags.
- **Author feeds:** submit handles, DIDs, or `bsky.app/profile/...` URLs. Choose whether the feed includes replies, media posts, author threads, or video posts.
- **Posts and threads:** submit a public post URL or AT URI. Return the root post alone or traverse public replies to a configurable depth.

It deliberately does not scrape private data, direct messages, login-only content, follower lists, or user credentials. For profile biography and account metadata rather than posts, use [Bluesky Profile Details Scraper](https://apify.com/khadinakbar/bluesky-profile-details-scraper).

### Output fields

Each dataset item is a validated `post` record with these field groups:

- Identity: `postUri`, `postUrl`, `cid`
- Content: `text`, `languages`, `hashtags`, `mentions`, `links`, `mediaUrls`, `embedType`
- Author: `authorDid`, `authorHandle`, `authorDisplayName`, `authorAvatar`
- Timing: `createdAt`, `indexedAt`, `scrapedAt`
- Engagement: `likeCount`, `repostCount`, `replyCount`, `quoteCount`
- Thread context: `isReply`, `replyParentUri`, `replyRootUri`, `isRepost`, `repostedByHandle`
- Provenance: `sourceType`, `sourceQuery`, `sourceUrl`, `provider`

The stable `postUri` is the best deduplication key. Handles can change; DIDs and AT URIs are designed to remain stable. Counts are snapshots taken when the run executes.

Example result:

```json
{
    "recordType": "post",
    "postUri": "at://did:plc:example/app.bsky.feed.post/3lxyz",
    "postUrl": "https://bsky.app/profile/example.com/post/3lxyz",
    "text": "A public Bluesky post about climate tech #energy",
    "createdAt": "2026-07-15T11:00:00.000Z",
    "authorDid": "did:plc:example",
    "authorHandle": "example.com",
    "likeCount": 42,
    "repostCount": 8,
    "replyCount": 5,
    "quoteCount": 1,
    "hashtags": ["#energy"],
    "sourceType": "search",
    "sourceQuery": "climate tech",
    "provider": "bluesky-appview",
    "scrapedAt": "2026-07-15T12:00:00.000Z"
}
````

### Input examples

Search recent English posts with minimum engagement:

```json
{
    "queries": ["climate tech", "renewable energy"],
    "sort": "latest",
    "language": "en",
    "minLikes": 10,
    "maxResults": 100
}
```

Collect two public author feeds:

```json
{
    "handles": ["bsky.app", "apify.com"],
    "authorFeedFilter": "posts_with_replies",
    "maxResults": 50
}
```

Export a public conversation:

```json
{
    "postUrls": ["https://bsky.app/profile/example.com/post/3lxyz"],
    "includeThreadReplies": true,
    "threadDepth": 4,
    "maxResults": 200
}
```

When every target field is empty, the Actor performs a small `AI` search so `{}` works as a health-check input. For production automation, always provide explicit targets.

### API usage

Run the Actor from JavaScript with the official Apify client:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/bluesky-posts-scraper').call({
    queries: ['open source AI'],
    sort: 'latest',
    maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Python works the same way:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("khadinakbar/bluesky-posts-scraper").call(run_input={
    "handles": ["bsky.app"],
    "maxResults": 50,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

The default dataset contains posts. The default key-value store always receives `OUTPUT` and `RUN_SUMMARY`, including the terminal outcome, warnings, target counts, provider attempts, validation totals, and charged-event counts. Outcomes distinguish `COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, `UPSTREAM_FAILED`, and `CONFIG_ERROR`, making scheduled workflows easier to monitor accurately.

### AI agents and MCP

Connect Apify to an MCP-compatible client and call this Actor as a focused Bluesky collection tool. A useful agent prompt is: “Search Bluesky for the latest 50 English posts about open-source AI, then summarize recurring product complaints using `postUri` as the citation key.” The compact, consistent record shape avoids making the model infer fields from raw protocol responses.

For recurring research, create an Apify Task with fixed input and let an agent trigger that task. Keep `maxResults` conservative, use engagement filters before downstream analysis, and retain `sourceQuery` or `sourceUrl` for traceability.

### Reliability and data sources

Public Bluesky AppView endpoints are the primary source. The Actor uses bounded retries, respects rate-limit retry guidance, and switches between public AppView hosts when an endpoint is temporarily unavailable. Author feeds and direct posts can use a verified public-data provider fallback when native endpoints are exhausted; search remains native because the fallback does not expose equivalent search semantics. All providers are normalized and validated before a paid dataset write.

The Actor stops pagination on repeated cursors, deduplicates across every input target, persists progress during container migration, and stops accepting new work before the run timeout. A partial upstream failure is reported as `PARTIAL` when useful data was still returned, rather than being hidden as a complete run.

### Responsible use

Collect only public data you are legally permitted to process. Follow Bluesky’s terms, applicable privacy and data-protection laws, intellectual-property rules, and any obligations that apply to your jurisdiction and use case. Do not use the Actor for harassment, surveillance, unlawful profiling, re-identification, or attempts to access non-public content. The Actor is an independent tool and is not affiliated with or endorsed by Bluesky Social PBC.

### FAQ

**Does this require a Bluesky account?**\
No. It collects public data without user credentials.

**Why did a valid run return no items?**\
The search may have no matches, the post may no longer be public, or engagement filters may exclude all records. Check `OUTPUT.outcome` and `RUN_SUMMARY`; a successful empty collection is labeled `VALID_EMPTY`.

**Are results returned in real time?**\
The Actor queries the current public index when run. `latest` favors recent search results, but Bluesky indexing and engagement counts can change after collection.

**How are duplicates billed?**\
They are not. The Actor deduplicates by AT URI before the validated write-and-charge operation.

**Can it collect an entire historical account archive?**\
It paginates the public author-feed endpoint until `maxResults`, the feed ends, a charge cap is reached, or the run approaches its timeout. Availability ultimately depends on the public upstream service.

### Related Actors

- [Bluesky Profile Details Scraper](https://apify.com/khadinakbar/bluesky-profile-details-scraper)
- [Threads Posts Scraper](https://apify.com/khadinakbar/threads-posts-scraper)
- [Instagram Profile Scraper](https://apify.com/khadinakbar/instagram-profile-scraper)
- [Instagram Followers Scraper](https://apify.com/khadinakbar/instagram-followers-scraper)
- [Instagram Trending Reels Scraper](https://apify.com/khadinakbar/instagram-trending-reels-scraper)
- [Facebook Hashtag Scraper](https://apify.com/khadinakbar/facebook-hashtag-scraper)
- [Facebook Page Scraper](https://apify.com/khadinakbar/facebook-page-scraper)
- [YouTube Search Scraper](https://apify.com/khadinakbar/youtube-search-scraper)
- [Social Media Sentiment Analyzer](https://apify.com/khadinakbar/social-media-sentiment-analyzer)
- [Brand Sentiment Analyzer](https://apify.com/khadinakbar/brand-sentiment-analyzer)

# Actor input Schema

## `queries` (type: `array`):

Keywords, phrases, hashtags, URLs, or Bluesky search syntax to find in public posts. Add up to 50 queries. When all target fields are empty, the Actor runs a small 'AI' health-check search.

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

Public Bluesky handles, DIDs, or profile URLs whose feeds should be collected. Examples: 'bsky.app', '@bsky.app', or 'https://bsky.app/profile/bsky.app'.

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

Public Bluesky post URLs or at:// post URIs. The root post is always returned when available; enable thread replies below to traverse public replies.

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

Maximum unique posts returned across the entire run, not per target. Each validated post costs $0.005; the run also has a $0.00005 start event and Apify platform usage is additional.

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

Sort keyword-search results by newest posts or Bluesky relevance. Author feeds remain chronological.

## `authorFeedFilter` (type: `string`):

Choose which public posts are included in author feeds. The default includes posts and replies. This setting does not change keyword-search or direct-thread results.

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

For direct post URLs only, also return public replies below the root post. Replies count toward maxResults and the per-post event charge.

## `threadDepth` (type: `integer`):

Maximum reply levels to traverse for direct post URLs when thread replies are enabled. Zero returns only the root post.

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

Return search posts on or after this ISO date or datetime, for example '2026-07-01' or '2026-07-01T00:00:00Z'.

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

Return search posts before this ISO date or datetime. Leave empty for no upper time bound.

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

Two-letter language code for search results, such as 'en', 'es', or 'de'. Detection depends on the language declared by each post.

## `author` (type: `string`):

Restrict each keyword search to posts from this handle or DID. For a complete author feed, use the Authors field instead.

## `mentions` (type: `string`):

Restrict search results to posts mentioning this public handle or DID.

## `domain` (type: `string`):

Restrict search results to posts linking to this domain, such as 'example.com'. Do not include a URL scheme.

## `exactUrl` (type: `string`):

Restrict search results to posts linking to this exact absolute URL.

## `tags` (type: `array`):

Restrict search results to one or more tags. Enter tags without the leading # character.

## `minLikes` (type: `integer`):

Only write posts with at least this many public likes.

## `minReposts` (type: `integer`):

Only write posts with at least this many public reposts.

## `minReplies` (type: `integer`):

Only write posts with at least this many public replies.

## Actor input object example

```json
{
  "queries": [
    "climate tech",
    "#buildinpublic"
  ],
  "handles": [
    "bsky.app",
    "https://bsky.app/profile/apify.com"
  ],
  "postUrls": [
    "https://bsky.app/profile/bsky.app/post/3lxyz"
  ],
  "maxResults": 50,
  "sort": "latest",
  "authorFeedFilter": "posts_with_replies",
  "includeThreadReplies": false,
  "threadDepth": 2,
  "since": "2026-07-01",
  "until": "2026-07-15",
  "language": "en",
  "author": "bsky.app",
  "mentions": "apify.com",
  "domain": "example.com",
  "exactUrl": "https://example.com/report",
  "tags": [
    "AI",
    "startups"
  ],
  "minLikes": 10,
  "minReposts": 2,
  "minReplies": 1
}
```

# Actor output Schema

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

No description

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

No description

## `diagnostics` (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 = {
    "queries": [
        "AI"
    ],
    "handles": [],
    "postUrls": [],
    "tags": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/bluesky-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 = {
    "queries": ["AI"],
    "handles": [],
    "postUrls": [],
    "tags": [],
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/bluesky-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 '{
  "queries": [
    "AI"
  ],
  "handles": [],
  "postUrls": [],
  "tags": []
}' |
apify call khadinakbar/bluesky-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Posts Scraper — Search, Feeds & Threads",
        "description": "Bluesky Posts Scraper searches public posts, exports author feeds and threads, and returns clean engagement data for research from $0.005 per result.",
        "version": "1.0",
        "x-build-id": "QUayv2svN37eVNXqV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~bluesky-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-bluesky-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/khadinakbar~bluesky-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-bluesky-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/khadinakbar~bluesky-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-bluesky-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",
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords, phrases, hashtags, URLs, or Bluesky search syntax to find in public posts. Add up to 50 queries. When all target fields are empty, the Actor runs a small 'AI' health-check search.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "handles": {
                        "title": "Authors or profile URLs",
                        "type": "array",
                        "description": "Public Bluesky handles, DIDs, or profile URLs whose feeds should be collected. Examples: 'bsky.app', '@bsky.app', or 'https://bsky.app/profile/bsky.app'.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "postUrls": {
                        "title": "Post URLs or AT URIs",
                        "type": "array",
                        "description": "Public Bluesky post URLs or at:// post URIs. The root post is always returned when available; enable thread replies below to traverse public replies.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum unique posts returned across the entire run, not per target. Each validated post costs $0.005; the run also has a $0.00005 start event and Apify platform usage is additional.",
                        "default": 50
                    },
                    "sort": {
                        "title": "Search sort order",
                        "enum": [
                            "latest",
                            "top"
                        ],
                        "type": "string",
                        "description": "Sort keyword-search results by newest posts or Bluesky relevance. Author feeds remain chronological.",
                        "default": "latest"
                    },
                    "authorFeedFilter": {
                        "title": "Author feed content",
                        "enum": [
                            "posts_with_replies",
                            "posts_no_replies",
                            "posts_with_media",
                            "posts_and_author_threads",
                            "posts_with_video"
                        ],
                        "type": "string",
                        "description": "Choose which public posts are included in author feeds. The default includes posts and replies. This setting does not change keyword-search or direct-thread results.",
                        "default": "posts_with_replies"
                    },
                    "includeThreadReplies": {
                        "title": "Include thread replies",
                        "type": "boolean",
                        "description": "For direct post URLs only, also return public replies below the root post. Replies count toward maxResults and the per-post event charge.",
                        "default": false
                    },
                    "threadDepth": {
                        "title": "Thread reply depth",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum reply levels to traverse for direct post URLs when thread replies are enabled. Zero returns only the root post.",
                        "default": 2
                    },
                    "since": {
                        "title": "Published since",
                        "type": "string",
                        "description": "Return search posts on or after this ISO date or datetime, for example '2026-07-01' or '2026-07-01T00:00:00Z'.",
                        "default": ""
                    },
                    "until": {
                        "title": "Published until",
                        "type": "string",
                        "description": "Return search posts before this ISO date or datetime. Leave empty for no upper time bound.",
                        "default": ""
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Two-letter language code for search results, such as 'en', 'es', or 'de'. Detection depends on the language declared by each post.",
                        "default": ""
                    },
                    "author": {
                        "title": "Search by author",
                        "type": "string",
                        "description": "Restrict each keyword search to posts from this handle or DID. For a complete author feed, use the Authors field instead.",
                        "default": ""
                    },
                    "mentions": {
                        "title": "Mentioned account",
                        "type": "string",
                        "description": "Restrict search results to posts mentioning this public handle or DID.",
                        "default": ""
                    },
                    "domain": {
                        "title": "Linked domain",
                        "type": "string",
                        "description": "Restrict search results to posts linking to this domain, such as 'example.com'. Do not include a URL scheme.",
                        "default": ""
                    },
                    "exactUrl": {
                        "title": "Linked URL",
                        "type": "string",
                        "description": "Restrict search results to posts linking to this exact absolute URL.",
                        "default": ""
                    },
                    "tags": {
                        "title": "Tags",
                        "type": "array",
                        "description": "Restrict search results to one or more tags. Enter tags without the leading # character.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minLikes": {
                        "title": "Minimum likes",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only write posts with at least this many public likes.",
                        "default": 0
                    },
                    "minReposts": {
                        "title": "Minimum reposts",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only write posts with at least this many public reposts.",
                        "default": 0
                    },
                    "minReplies": {
                        "title": "Minimum replies",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only write posts with at least this many public replies.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
