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

Scrape Bluesky posts, profiles, followers and keyword search without an API key. Export to JSON, CSV or Excel. Free AT Protocol data, no OAuth setup.

- **URL**: https://apify.com/night\_space/bluesky-scraper.md
- **Developed by:** [Night space](https://apify.com/night_space) (community)
- **Categories:** Social media, SEO tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 posts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Scraper — Export Posts, Profiles, Followers & Keyword Search

**Scrape Bluesky without an API key.** Export Bluesky posts, profiles, followers, following lists and keyword search results to JSON, CSV or Excel in one run. No developer account, no OAuth setup, no monthly API fee.

Built on the AT Protocol, the open standard behind Bluesky — so this scraper reads public data the way Bluesky intends it to be read.

---

### What you can do with it

#### Monitor your brand on Bluesky
Search every public post on Bluesky for your brand, product or competitor names and export the results with engagement counts. Track mentions daily, spot complaints early, and measure share of voice as Bluesky grows past 30 million users.

#### Build lead and creator lists
Find accounts by keyword — "SaaS founder", "python developer", "travel blogger" — and export handles, bios, follower counts and profile links straight to a spreadsheet.

#### Export your Bluesky followers to CSV
Pull the complete follower or following list for any public account, with bios and follower counts included. Useful for audience analysis, influencer research and audits.

#### Research and dataset building
Collect Bluesky posts with timestamps, languages, hashtags, links and engagement metrics for academic research, sentiment analysis or training data.

#### Track competitors
Watch what competitor accounts post, how often, and which posts actually land.

---

### Sample output

Each row is one flat record, ready for a spreadsheet or a database.

**Post**

```json
{
  "type": "post",
  "queriedHandle": "bsky.app",
  "uri": "at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post/3kb2xyz",
  "url": "https://bsky.app/profile/bsky.app/post/3kb2xyz",
  "authorHandle": "bsky.app",
  "authorDisplayName": "Bluesky",
  "text": "We just shipped a new feature.",
  "lang": "en",
  "createdAt": "2026-07-14T09:12:44.000Z",
  "replyCount": 128,
  "repostCount": 640,
  "likeCount": 3204,
  "quoteCount": 51,
  "isReply": false,
  "hashtags": ["buildinpublic"],
  "mentions": [],
  "links": ["https://bsky.social/about/blog"],
  "images": ["https://cdn.bsky.app/img/feed_fullsize/..."]
}
````

**Profile**

```json
{
  "type": "profile",
  "did": "did:plc:z72i7hdynmk6r22z27h6tvur",
  "handle": "bsky.app",
  "displayName": "Bluesky",
  "description": "Official Bluesky account.",
  "followersCount": 1420331,
  "followsCount": 42,
  "postsCount": 1893,
  "createdAt": "2023-04-12T04:53:57.000Z",
  "url": "https://bsky.app/profile/bsky.app"
}
```

Followers and following rows use the same profile shape, tagged with the handle you queried.

***

### Quick start

1. Click **Try for free**.
2. Leave everything as-is and press **Start** — the defaults scrape a real profile and its posts, so you can see the output shape immediately.
3. Replace the handle with the accounts you care about.
4. Download from the **Storage** tab as JSON, CSV, Excel, XML or HTML.

Handles are flexible. All three of these work:

```
alice.bsky.social
@alice.bsky.social
https://bsky.app/profile/alice.bsky.social
```

***

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `handles` | array | `["bsky.app"]` | Accounts to scrape. Handle, @handle or profile URL. |
| `scrapeProfiles` | boolean | `true` | Return the profile record for each handle. |
| `scrapePosts` | boolean | `true` | Return posts from each handle's feed. |
| `maxPostsPerHandle` | integer | `100` | Cap on posts per handle. `0` skips posts. |
| `scrapeFollowers` | boolean | `false` | Return each handle's followers. |
| `maxFollowersPerHandle` | integer | `500` | Cap on followers per handle. |
| `scrapeFollowing` | boolean | `false` | Return accounts each handle follows. |
| `maxFollowingPerHandle` | integer | `500` | Cap on following per handle. |
| `searchTerms` | array | `[]` | Keyword post search across all of Bluesky. Requires login. |
| `maxPostsPerSearch` | integer | `100` | Cap on results per search term. |
| `searchPeopleTerms` | array | `[]` | Find accounts by keyword. No login needed. |
| `maxPeoplePerSearch` | integer | `50` | Cap on accounts per people-search term. |
| `blueskyIdentifier` | string | — | Your Bluesky handle. Only for keyword post search. |
| `blueskyAppPassword` | string | — | A Bluesky **app password**. Only for keyword post search. |

#### Example input

Brand monitoring plus a competitor's audience:

```json
{
  "handles": ["competitor.bsky.social"],
  "scrapeProfiles": true,
  "scrapePosts": true,
  "maxPostsPerHandle": 200,
  "scrapeFollowers": true,
  "maxFollowersPerHandle": 2000,
  "searchTerms": ["your brand name", "yourproduct"],
  "maxPostsPerSearch": 500,
  "blueskyIdentifier": "you.bsky.social",
  "blueskyAppPassword": "xxxx-xxxx-xxxx-xxxx"
}
```

***

### Why keyword search needs a login

Bluesky serves profiles, posts, followers and people search anonymously. **Post search is the one endpoint that requires an authenticated session** — that is Bluesky's rule, not this scraper's.

If you want keyword search, create an **app password**:

> Bluesky → Settings → Privacy and Security → App Passwords → Add App Password

Use that, never your real password. An app password cannot change your account email or password, and you can revoke it at any time. It is stored as a secret input and never written to the dataset or logs.

Everything else works with no credentials at all.

***

### FAQ

**Do I need a Bluesky API key?**
No. The AT Protocol serves public data without authentication. Only keyword post search needs a login, and that uses a revocable app password.

**Is scraping Bluesky legal?**
This scraper reads only public data through Bluesky's own public API, which is an open protocol explicitly designed for third-party clients and interoperability. It does not bypass logins, solve CAPTCHAs, or touch private data. As always, how you use exported data — especially personal data under GDPR or India's DPDP Act — is your responsibility.

**How is this different from scraping Twitter/X or Reddit?**
Both now charge for API access and actively block scrapers. Bluesky's public API is free and open by design, which makes Bluesky data cheaper and more reliable to collect.

**How many posts can I get per account?**
Up to 10,000 per handle per run. For more, split by handle across runs.

**Can I get posts from a private account?**
No. Only public data is available.

**What formats can I export?**
JSON, CSV, Excel, XML, HTML, or straight from the Apify API into your own app.

**Can I run this on a schedule?**
Yes — use Apify **Schedules** to run it daily or hourly and build a growing dataset. Combine with **webhooks** to push new mentions into Slack, Google Sheets or your database.

**Does it handle rate limits?**
Yes. Requests are throttled well below Bluesky's limit, and 429 responses are retried with exponential backoff, honouring the `ratelimit-reset` header.

**Will it break when Bluesky changes?**
It reads versioned AT Protocol endpoints rather than parsing HTML, which is far more stable than page scraping. Report an issue and it gets fixed.

***

### Output fields

**Posts:** `uri`, `cid`, `url`, `authorDid`, `authorHandle`, `authorDisplayName`, `text`, `lang`, `createdAt`, `indexedAt`, `replyCount`, `repostCount`, `likeCount`, `quoteCount`, `isReply`, `hashtags`, `mentions`, `links`, `embedType`, `images`

**Profiles, followers, following:** `did`, `handle`, `displayName`, `description`, `avatar`, `banner`, `followersCount`, `followsCount`, `postsCount`, `createdAt`, `indexedAt`, `url`

***

### Integrations

Send Bluesky data anywhere with Apify integrations: Google Sheets, Airtable, Slack, Zapier, Make, Google Drive, Amazon S3, or any webhook. Or call it from code with the Apify API, or the JavaScript and Python clients.

***

### Support

Found a bug or need a field that isn't here? Open an issue on the Actor's **Issues** tab. Issues are usually answered within a few hours.

# Actor input Schema

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

Accounts to scrape. Accepts a bare handle (alice.bsky.social), an @handle, or a full profile URL (https://bsky.app/profile/alice.bsky.social).

## `scrapeProfiles` (type: `boolean`):

Return the profile record for each handle: display name, bio, avatar, banner, follower/following/post counts and join date.

## `scrapePosts` (type: `boolean`):

Return posts from each handle's feed, including engagement counts, hashtags, mentions, links and images.

## `maxPostsPerHandle` (type: `integer`):

Upper limit on posts returned for each handle. Set to 0 to skip posts.

## `scrapeFollowers` (type: `boolean`):

Return the accounts following each handle. Off by default because large accounts produce a lot of rows.

## `maxFollowersPerHandle` (type: `integer`):

Upper limit on followers returned for each handle.

## `scrapeFollowing` (type: `boolean`):

Return the accounts each handle follows.

## `maxFollowingPerHandle` (type: `integer`):

Upper limit on followed accounts returned for each handle.

## `searchTerms` (type: `array`):

Search all of Bluesky for posts matching these keywords - useful for brand monitoring and sentiment tracking. Bluesky requires a logged-in session for post search, so this needs the credentials below. Leave empty to skip.

## `maxPostsPerSearch` (type: `integer`):

Upper limit on posts returned for each search term.

## `blueskyIdentifier` (type: `string`):

Your own Bluesky handle, e.g. yourname.bsky.social. Only used for keyword post search.

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

Create one at Bluesky Settings > Privacy and Security > App Passwords. Never use your real account password - an app password cannot change your email or password, so it is safe to revoke.

## `searchPeopleTerms` (type: `array`):

Find Bluesky accounts by keyword, name or topic. Works without login. Leave empty to skip.

## `maxPeoplePerSearch` (type: `integer`):

Upper limit on accounts returned for each people-search term.

## Actor input object example

```json
{
  "handles": [
    "bsky.app",
    "@jay.bsky.team"
  ],
  "scrapeProfiles": true,
  "scrapePosts": true,
  "maxPostsPerHandle": 100,
  "scrapeFollowers": false,
  "maxFollowersPerHandle": 500,
  "scrapeFollowing": false,
  "maxFollowingPerHandle": 500,
  "searchTerms": [
    "claude code",
    "#buildinpublic"
  ],
  "maxPostsPerSearch": 100,
  "searchPeopleTerms": [
    "indie hacker",
    "python developer"
  ],
  "maxPeoplePerSearch": 50
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped rows as JSON. Each row is one post, profile, follower, following or search result.

## `resultsCsv` (type: `string`):

The same rows as CSV, ready for Excel or Google Sheets.

## `datasetView` (type: `string`):

Open the dataset in Apify Console to filter and preview the results.

# 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("night_space/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("night_space/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 night_space/bluesky-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Scraper — Export Posts, Profiles & Followers",
        "description": "Scrape Bluesky posts, profiles, followers and keyword search without an API key. Export to JSON, CSV or Excel. Free AT Protocol data, no OAuth setup.",
        "version": "0.1",
        "x-build-id": "x0RGXId0FOH7oeorn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/night_space~bluesky-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-night_space-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/night_space~bluesky-scraper/runs": {
            "post": {
                "operationId": "runs-sync-night_space-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/night_space~bluesky-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-night_space-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": "Bluesky handles",
                        "type": "array",
                        "description": "Accounts to scrape. Accepts a bare handle (alice.bsky.social), an @handle, or a full profile URL (https://bsky.app/profile/alice.bsky.social).",
                        "default": [
                            "bsky.app"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeProfiles": {
                        "title": "Scrape profiles",
                        "type": "boolean",
                        "description": "Return the profile record for each handle: display name, bio, avatar, banner, follower/following/post counts and join date.",
                        "default": true
                    },
                    "scrapePosts": {
                        "title": "Scrape posts",
                        "type": "boolean",
                        "description": "Return posts from each handle's feed, including engagement counts, hashtags, mentions, links and images.",
                        "default": true
                    },
                    "maxPostsPerHandle": {
                        "title": "Max posts per handle",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Upper limit on posts returned for each handle. Set to 0 to skip posts.",
                        "default": 100
                    },
                    "scrapeFollowers": {
                        "title": "Scrape followers",
                        "type": "boolean",
                        "description": "Return the accounts following each handle. Off by default because large accounts produce a lot of rows.",
                        "default": false
                    },
                    "maxFollowersPerHandle": {
                        "title": "Max followers per handle",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Upper limit on followers returned for each handle.",
                        "default": 500
                    },
                    "scrapeFollowing": {
                        "title": "Scrape following",
                        "type": "boolean",
                        "description": "Return the accounts each handle follows.",
                        "default": false
                    },
                    "maxFollowingPerHandle": {
                        "title": "Max following per handle",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Upper limit on followed accounts returned for each handle.",
                        "default": 500
                    },
                    "searchTerms": {
                        "title": "Keyword post search",
                        "type": "array",
                        "description": "Search all of Bluesky for posts matching these keywords - useful for brand monitoring and sentiment tracking. Bluesky requires a logged-in session for post search, so this needs the credentials below. Leave empty to skip.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerSearch": {
                        "title": "Max posts per search term",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Upper limit on posts returned for each search term.",
                        "default": 100
                    },
                    "blueskyIdentifier": {
                        "title": "Bluesky handle (for login)",
                        "type": "string",
                        "description": "Your own Bluesky handle, e.g. yourname.bsky.social. Only used for keyword post search."
                    },
                    "blueskyAppPassword": {
                        "title": "Bluesky app password",
                        "type": "string",
                        "description": "Create one at Bluesky Settings > Privacy and Security > App Passwords. Never use your real account password - an app password cannot change your email or password, so it is safe to revoke."
                    },
                    "searchPeopleTerms": {
                        "title": "People search",
                        "type": "array",
                        "description": "Find Bluesky accounts by keyword, name or topic. Works without login. Leave empty to skip.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPeoplePerSearch": {
                        "title": "Max people per search term",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Upper limit on accounts returned for each people-search term.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```