# Bluesky Scraper — Posts, Profiles, Followers & Search (`apium/bluesky-scraper`) Actor

Bluesky scraper for posts, profiles, followers, likes & search. Uses the public Bluesky posts API (AT Protocol) — no login, no proxies. Fast Bluesky data export to JSON, CSV or Excel for monitoring, research and lead gen.

- **URL**: https://apify.com/apium/bluesky-scraper.md
- **Developed by:** [Tommi Sullivan](https://apify.com/apium) (community)
- **Categories:** Social media, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 result items

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

Scrape **Bluesky posts, profiles, followers, likes and search results** in minutes — no login, no password, no proxies. This Bluesky scraper talks directly to the official **public AT Protocol API** (`public.api.bsky.app`), the same Bluesky posts API that powers the app itself, and exports clean, structured data you can download as **JSON, CSV, Excel or XML**, or pipe straight into your own tools.

Whether you need a one-off **Bluesky data export**, continuous brand monitoring, or a data feed for an AI agent, this actor gets you from a handle or search query to a spreadsheet in under a minute.

### What you get

Every result is a flat, analysis-ready record. Posts look like this:

| Field | Description |
|---|---|
| `text` | Full post text |
| `authorHandle` / `authorDisplayName` / `authorDid` | Who wrote it |
| `createdAt` | ISO 8601 timestamp |
| `likeCount`, `repostCount`, `replyCount`, `quoteCount` | Engagement metrics |
| `langs` | Post language codes |
| `images` | Full-size image URLs from the post's embeds |
| `externalLink` | Link-card URL, if the post shares a link |
| `quotedUri` / `quotedUrl` | The post being quoted, if any |
| `isReply`, `isRepost`, `repostedBy` | Thread/repost context |
| `uri`, `cid`, `url` | Canonical AT URI + shareable bsky.app URL |

Profile records add `followersCount`, `followsCount`, `postsCount`, `description` (bio), `avatar` and `banner`. Follower and like records give you the full account list with handles, DIDs, display names and bios.

### What it can scrape

- **Posts by account** — the full author feed of any handle or DID, with optional replies and reposts
- **Search results** — full-text Bluesky post search, paginated, with date filtering
- **Profiles** — detailed profile metadata for any list of accounts
- **Followers** — complete follower lists (handle, DID, bio, avatar)
- **Post threads** — a post plus its entire reply tree from a bsky.app URL
- **Post likes** — every account that liked a given post

### Use cases

1. **Brand & keyword monitoring** — track every mention of your product, company or founders on Bluesky and route new posts to Slack or a spreadsheet.
2. **Academic & social research** — export post datasets by keyword and date range for discourse analysis, misinformation studies or network science.
3. **Lead generation** — scrape followers of accounts in your niche, or everyone who liked a competitor's launch post, and enrich the handles into a prospect list.
4. **Trend & sentiment analysis** — pull thousands of posts on a topic and feed them to an LLM or sentiment model to see how opinion is shifting.
5. **Influencer discovery & vetting** — compare follower counts, posting frequency and engagement rates across creators before you sponsor them.
6. **Content backup & migration** — export your own (or a client's) full posting history as JSON/CSV for archiving or cross-posting.
7. **Competitive intelligence** — monitor competitors' posts, engagement and audience growth over time on a schedule.
8. **AI agents & RAG pipelines** — give an agent live Bluesky data as a tool (see Integrations below).

### Input example

```json
{
    "handles": ["bsky.app", "jay.bsky.team"],
    "searchQueries": ["\"open source\" ai"],
    "postUrls": ["https://bsky.app/profile/bsky.app/post/3l6oveex3ii2l"],
    "scrapeTypes": ["posts", "profile", "followers"],
    "maxItems": 1000,
    "includeReplies": false,
    "includeReposts": false,
    "dateFrom": "2026-01-01",
    "dateTo": "2026-06-30"
}
````

Only one of `handles`, `searchQueries` or `postUrls` is required — everything else has sensible defaults.

### Output example

```json
{
    "type": "post",
    "uri": "at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post/3l6oveex3ii2l",
    "cid": "bafyreib3vqn...",
    "url": "https://bsky.app/profile/bsky.app/post/3l6oveex3ii2l",
    "text": "Bluesky is an open social network built on the AT Protocol.",
    "createdAt": "2026-05-12T18:04:33.183Z",
    "langs": ["en"],
    "authorDid": "did:plc:z72i7hdynmk6r22z27h6tvur",
    "authorHandle": "bsky.app",
    "authorDisplayName": "Bluesky",
    "replyCount": 214,
    "repostCount": 1830,
    "likeCount": 9421,
    "quoteCount": 96,
    "isReply": false,
    "isRepost": false,
    "embedType": "images",
    "images": ["https://cdn.bsky.app/img/feed_fullsize/plain/did:plc:.../bafkrei...@jpeg"],
    "externalLink": null,
    "indexedAt": "2026-05-12T18:04:34.512Z"
}
```

### Integrations

The dataset produced by this actor plugs into the whole Apify ecosystem:

- **Make, n8n, Zapier** — trigger a scenario on every finished run and push new Bluesky posts into Google Sheets, Airtable, Slack, Discord, Notion or email digests. Use Apify's native Make/Zapier apps or the n8n Apify node.
- **LangChain / LlamaIndex** — load run results with the Apify dataset loaders and build RAG apps over live Bluesky content.
- **MCP & AI agents** — this actor works out of the box with the [Apify MCP server](https://mcp.apify.com), so Claude, ChatGPT, Cursor or any MCP-capable agent can call it as a tool ("find the last 200 posts mentioning our brand on Bluesky and summarize sentiment"). Agentic workflows can also start runs via the Apify API and poll for results — the flat output schema is deliberately LLM-friendly.
- **API & webhooks** — start runs and fetch results via the [Apify REST API](https://docs.apify.com/api/v2), or attach a webhook to feed your own backend.
- **Scheduler** — run it hourly/daily with Apify Schedules for continuous monitoring.

### FAQ

**Is it legal to scrape Bluesky?**
This actor only collects *public* data through Bluesky's *official, documented public API* — the AT Protocol is designed to be open, and public posts are accessible to anyone without an account. That said, you are responsible for how you use the data: comply with GDPR/CCPA and other applicable laws, especially when processing personal data, and review Bluesky's terms for your specific use case. Nothing here is legal advice.

**Does it need my Bluesky password or an API key?**
**No.** It never asks for credentials of any kind. All requests go to the unauthenticated public endpoint `public.api.bsky.app`, which serves public data only. Your account is never involved and cannot be flagged or banned.

**Can it scrape private or logged-in-only content?**
No. It sees exactly what a logged-out visitor can see: public posts, public profiles, public followers and likes. Blocked, deleted and restricted content is skipped automatically.

**How fast is it, and will I get rate-limited?**
It's HTTP-only (no browser), so it typically collects thousands of items per minute. The actor pages at the API's maximum page size and automatically backs off with exponential delays if the API returns 429 or 5xx responses, so runs finish cleanly even under rate limits.

**How do I control cost?**
Set `maxItems`. It is a hard spend cap — the run stops the moment the cap is reached, and with pay-per-result pricing you never pay for more than that number of records.

**Can I get the data as CSV or Excel?**
Yes. Every run's dataset can be downloaded from Apify as JSON, CSV, Excel (XLSX), XML or an RSS feed, and accessed programmatically via the API.

### Related searches this actor answers

Bluesky scraper, scrape Bluesky posts, Bluesky posts API, Bluesky data export, export Bluesky followers, Bluesky search API, download Bluesky data to CSV, AT Protocol scraper, Bluesky monitoring tool.

# Actor input Schema

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

Bluesky accounts to scrape, as handles (e.g. <code>jay.bsky.team</code>), full profile URLs (e.g. <code>https://bsky.app/profile/jay.bsky.team</code>) or DIDs (e.g. <code>did:plc:oky5czdrnfjpqslsw2a5iclo</code>). Used by the <b>posts</b>, <b>profile</b> and <b>followers</b> scrape types.

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

Full-text search queries for Bluesky posts (same syntax as the search box on bsky.app, e.g. <code>"climate change"</code>, <code>from:nasa.gov ai</code>). Each query is paginated until Max items is reached.

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

Individual Bluesky post URLs (e.g. <code>https://bsky.app/profile/bsky.app/post/3l6oveex3ii2l</code>) or AT URIs (<code>at://did:plc:.../app.bsky.feed.post/...</code>). The post and its full reply thread are scraped; with the <b>likes</b> scrape type, accounts that liked each post are scraped too.

## `scrapeTypes` (type: `array`):

Which data to collect for the accounts and posts above. <b>posts</b> = author feed of each handle, <b>profile</b> = profile record of each handle, <b>followers</b> = follower list of each handle, <b>likes</b> = accounts that liked each post URL.

## `maxItems` (type: `integer`):

Hard cap on the total number of results pushed to the dataset across all inputs. The run stops cleanly when the cap is reached, so this directly caps your spend on pay-per-result pricing.

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

When scraping an account's posts, also include the replies it wrote (not just top-level posts).

## `includeReposts` (type: `boolean`):

When scraping an account's posts, also include posts it reposted from other accounts (marked with <code>isRepost: true</code> and <code>repostedBy</code>).

## `dateFrom` (type: `string`):

Only keep posts created on or after this date. Accepts <code>YYYY-MM-DD</code> or a full ISO 8601 timestamp (e.g. <code>2026-01-01</code> or <code>2026-01-01T12:00:00Z</code>).

## `dateTo` (type: `string`):

Only keep posts created on or before this date (inclusive). Accepts <code>YYYY-MM-DD</code> or a full ISO 8601 timestamp.

## Actor input object example

```json
{
  "handles": [
    "bsky.app"
  ],
  "scrapeTypes": [
    "posts",
    "profile"
  ],
  "maxItems": 1000,
  "includeReplies": false,
  "includeReposts": false
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "handles": [
        "bsky.app"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Scraper — Posts, Profiles, Followers & Search",
        "description": "Bluesky scraper for posts, profiles, followers, likes & search. Uses the public Bluesky posts API (AT Protocol) — no login, no proxies. Fast Bluesky data export to JSON, CSV or Excel for monitoring, research and lead gen.",
        "version": "0.1",
        "x-build-id": "U9O6XpgfJe3wyUpT3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apium~bluesky-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apium-bluesky-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/apium~bluesky-scraper/runs": {
            "post": {
                "operationId": "runs-sync-apium-bluesky-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/apium~bluesky-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-apium-bluesky-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": {
                    "handles": {
                        "title": "Handles or DIDs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Bluesky accounts to scrape, as handles (e.g. <code>jay.bsky.team</code>), full profile URLs (e.g. <code>https://bsky.app/profile/jay.bsky.team</code>) or DIDs (e.g. <code>did:plc:oky5czdrnfjpqslsw2a5iclo</code>). Used by the <b>posts</b>, <b>profile</b> and <b>followers</b> scrape types.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Full-text search queries for Bluesky posts (same syntax as the search box on bsky.app, e.g. <code>\"climate change\"</code>, <code>from:nasa.gov ai</code>). Each query is paginated until Max items is reached.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postUrls": {
                        "title": "Post URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Individual Bluesky post URLs (e.g. <code>https://bsky.app/profile/bsky.app/post/3l6oveex3ii2l</code>) or AT URIs (<code>at://did:plc:.../app.bsky.feed.post/...</code>). The post and its full reply thread are scraped; with the <b>likes</b> scrape type, accounts that liked each post are scraped too.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeTypes": {
                        "title": "What to scrape",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which data to collect for the accounts and posts above. <b>posts</b> = author feed of each handle, <b>profile</b> = profile record of each handle, <b>followers</b> = follower list of each handle, <b>likes</b> = accounts that liked each post URL.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "posts",
                                "profile",
                                "followers",
                                "likes"
                            ],
                            "enumTitles": [
                                "Posts (author feed)",
                                "Profile details",
                                "Followers",
                                "Post likes (likers)"
                            ]
                        },
                        "default": [
                            "posts",
                            "profile"
                        ]
                    },
                    "maxItems": {
                        "title": "Max items (spend cap)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the total number of results pushed to the dataset across all inputs. The run stops cleanly when the cap is reached, so this directly caps your spend on pay-per-result pricing.",
                        "default": 1000
                    },
                    "includeReplies": {
                        "title": "Include replies",
                        "type": "boolean",
                        "description": "When scraping an account's posts, also include the replies it wrote (not just top-level posts).",
                        "default": false
                    },
                    "includeReposts": {
                        "title": "Include reposts",
                        "type": "boolean",
                        "description": "When scraping an account's posts, also include posts it reposted from other accounts (marked with <code>isRepost: true</code> and <code>repostedBy</code>).",
                        "default": false
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}([T ].*)?$",
                        "type": "string",
                        "description": "Only keep posts created on or after this date. Accepts <code>YYYY-MM-DD</code> or a full ISO 8601 timestamp (e.g. <code>2026-01-01</code> or <code>2026-01-01T12:00:00Z</code>)."
                    },
                    "dateTo": {
                        "title": "Date to",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}([T ].*)?$",
                        "type": "string",
                        "description": "Only keep posts created on or before this date (inclusive). Accepts <code>YYYY-MM-DD</code> or a full ISO 8601 timestamp."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```