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

Scrape Bluesky posts, profiles, search, threads & followers via the public AT Protocol. Clean flat JSON/CSV with image alt-text & quoted posts. No login.

- **URL**: https://apify.com/eszetael\_lab/bluesky-scraper.md
- **Developed by:** [Radosław Szal](https://apify.com/eszetael_lab) (community)
- **Categories:** Social media, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Posts, Profiles & Search Scraper (AT Protocol)

> 🔗 Part of the **[Apify actors collection](https://github.com/Eszetael/apify-actors)** — 6 reliable, tested scrapers & data tools.

Export **Bluesky** data at scale — posts, profiles, keyword search, full reply
threads and follower graphs — as clean JSON, CSV or Excel. Built directly on the
public **AT Protocol**, so scraping public posts and profiles needs **no login**.

One actor, seven jobs. No browser, no proxies, no fragile HTML parsing — just the
official protocol Bluesky itself runs on.

---

### What you can scrape

| Mode | What it does | Login? |
|------|--------------|--------|
| **Author posts** | Every post from one or more accounts (with replies / media filters) | No |
| **Search posts** | Keyword search across all of Bluesky (date, language, author, hashtag filters) | App password |
| **Profiles** | Full profile details for given accounts | No |
| **Search profiles** | Find accounts by keyword | No |
| **Post thread** | The complete reply tree under a post | No |
| **Followers** | An account's followers | No |
| **Follows** | Who an account follows | No |

Only **keyword post search** needs an app password (Bluesky doesn't serve that
endpoint anonymously). Everything else runs on the public AppView out of the box.

---

### Why this scraper

- **Clean, flat, stable schema** — not a raw API dump. Engagement counts,
  hashtags, mentions, links and media are pulled up to top-level fields, and
  every post gets a real `https://bsky.app/...` URL you can click.
- **Richer than the rest** — we extract **image alt-text** (great for AI, search
  and accessibility), pull out the **quoted post** in full when a post quotes
  another, and flag unresolved handles (`handleResolved`) with a working profile
  URL either way. Details other scrapers quietly drop.
- **Everything in one actor** — posts, profiles, search, threads and the social
  graph. No juggling five different tools.
- **Monitoring built in** — flip on **`onlyNew`** and any scrape becomes a change
  monitor: each scheduled run returns only posts you haven't seen yet. Wire it to
  a Bluesky mention search and you have brand-alert / social-listening on a timer.
- **Predictable pricing** — pay per result, flat. No surprise "compute unit" bills.
- **No proxies to configure** — the AT Protocol AppView serves public data directly.

---

### Quick start

**Get a user's latest posts** (no login):

```json
{
  "mode": "author_posts",
  "handles": ["nytimes.com", "bsky.app"],
  "maxItems": 100
}
````

**Search posts by keyword** (needs an app password — see below):

```json
{
  "mode": "search_posts",
  "searchQuery": "electric vehicles",
  "lang": "en",
  "since": "2026-07-01",
  "sort": "latest",
  "maxItems": 500,
  "blueskyIdentifier": "you.bsky.social",
  "blueskyAppPassword": "<your-app-password>"
}
```

**Monitor mentions of your brand** (schedule it, e.g. hourly):

```json
{
  "mode": "search_posts",
  "searchQuery": "\"YourBrand\"",
  "onlyNew": true,
  "stateKey": "yourbrand-mentions",
  "blueskyIdentifier": "you.bsky.social",
  "blueskyAppPassword": "<your-app-password>"
}
```

**Get the full thread under a post** (no login):

```json
{
  "mode": "post_thread",
  "postUrls": ["https://bsky.app/profile/bsky.app/post/3l..."],
  "threadDepth": 6
}
```

***

### How to get a Bluesky app password (for post search only)

1. Open Bluesky → **Settings → Privacy and Security → App Passwords**.
2. **Add App Password**, name it (e.g. "Apify"), copy the generated value (format `xxxx-xxxx-xxxx-xxxx`).
3. Paste your handle into **Bluesky handle** and the value into **Bluesky app password**.

An app password is revocable and scoped — it is **not** your main password. It is
only ever sent to Bluesky's own `createSession` endpoint to sign in, and is never
stored in the dataset or logs.

***

### Output

Each **post** record:

```json
{
  "uri": "at://did:plc:.../app.bsky.feed.post/3l...",
  "url": "https://bsky.app/profile/handle/post/3l...",
  "cid": "bafy...",
  "text": "the post text",
  "createdAt": "2026-07-20T10:00:00.000Z",
  "indexedAt": "2026-07-20T10:00:01.000Z",
  "langs": ["en"],
  "author": { "did": "did:plc:...", "handle": "handle", "displayName": "Name", "avatar": "https://..." },
  "likeCount": 6512, "repostCount": 539, "replyCount": 88, "quoteCount": 12, "bookmarkCount": 4,
  "author": { "did": "did:plc:...", "handle": "handle", "handleResolved": true, "displayName": "Name", "avatar": "https://..." },
  "hashtags": ["climate"], "mentions": ["did:plc:..."], "links": ["https://..."],
  "embedType": "images",
  "media": [{ "url": "https://...", "alt": "a solar farm at sunset", "type": "image" }],
  "quotedPost": { "uri": "at://...", "url": "https://bsky.app/profile/.../post/...", "author": "quoted.handle", "text": "the quoted post" },
  "external": null,
  "isReply": false, "isRepost": false, "replyParent": null, "replyRoot": null,
  "labels": []
}
```

> Note the richness most scrapers skip: **image alt-text** (`media[].alt` — the
> author's own description of each image), the **quoted post** pulled out in full
> (`quotedPost`), and **`handleResolved`** so you can tell verified handles from
> unresolved ones (`handle.invalid`) — with a working profile URL either way.

Each **profile** record: `did, handle, handleResolved, url, displayName, description,
avatar, banner, followersCount, followsCount, postsCount, createdAt, indexedAt, labels`.

Download from the run's **Dataset** tab as JSON, CSV, Excel, or pull via the
Apify API.

***

### Pricing

**Pay per result** — you are charged for each record delivered (`result-item`),
flat, regardless of how many pages were walked to find it. The first few seconds
of every run are free, so you can test inputs at no cost.

### Common uses

- **Social listening / brand monitoring** on the fastest-growing X alternative.
- **Clean, ethically-sourced datasets** for AI / research (public data, open protocol).
- **Tracking accounts, hashtags and topics** as Bluesky adoption grows.
- **Lead and community research** — find and profile accounts around a topic.

### Notes & fair use

- Reads **only public data** through the official public AT Protocol AppView.
  No private posts, no logged-in-only content, no fake accounts.
- Respects the API: automatic backoff on rate limits and transient errors.
- You are responsible for using exported data in line with Bluesky's terms and
  applicable law (e.g. GDPR when handling personal data).

***

*Built on the AT Protocol (`app.bsky.*`). Keywords: bluesky scraper, bluesky api,
at protocol scraper, scrape bluesky posts, bluesky profile scraper, bluesky search,
social media scraper, bluesky data export.*

# Actor input Schema

## `mode` (type: `string`):

Pick the capability. Everything except 'search\_posts' works with no login.

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

e.g. nytimes.com, bsky.app, or did:plc:... . Used by author\_posts, profiles, followers, follows.

## `searchQuery` (type: `string`):

Keyword(s) for 'search\_posts' or 'search\_profiles'. Supports Bluesky search syntax.

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

bsky.app post URLs (or at:// URIs) for 'post\_thread'.

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

Cap results per account/query. 0 or empty = unlimited (until the API runs out).

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

For 'author\_posts': which posts to include.

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

Sort order for search results: 'latest' (newest first) or 'top' (most relevant).

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

Only posts on/after this time, e.g. 2026-07-01 or 2026-07-01T00:00:00Z.

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

Only posts before this date (YYYY-MM-DD). Search modes only.

## `lang` (type: `string`):

Two-letter code, e.g. en, pl.

## `fromAuthor` (type: `string`):

Restrict search to one account's posts.

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

Posts mentioning this account.

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

Posts carrying these tags (no # sign).

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

For 'post\_thread': how many reply levels to walk.

## `onlyNew` (type: `boolean`):

Skip posts already delivered in previous runs of this saved task — turns any scrape into a change monitor / alert feed.

## `stateKey` (type: `string`):

Optional label that groups 'onlyNew' memory. Leave blank to derive from the query/accounts.

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

Only needed for 'search\_posts'. Your Bluesky handle, e.g. you.bsky.social.

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

Create at Bluesky → Settings → App Passwords. NOT your main password. Only used to sign in for post search; never stored.

## Actor input object example

```json
{
  "mode": "author_posts",
  "handles": [
    "bsky.app"
  ],
  "maxItems": 200,
  "authorFeedFilter": "posts_and_author_threads",
  "sort": "latest",
  "threadDepth": 6,
  "onlyNew": 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("eszetael_lab/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("eszetael_lab/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 eszetael_lab/bluesky-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Scraper - Posts, Profiles & Search",
        "description": "Scrape Bluesky posts, profiles, search, threads & followers via the public AT Protocol. Clean flat JSON/CSV with image alt-text & quoted posts. No login.",
        "version": "1.0",
        "x-build-id": "duAlz8NfSCZr3ED1E"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/eszetael_lab~bluesky-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-eszetael_lab-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/eszetael_lab~bluesky-scraper/runs": {
            "post": {
                "operationId": "runs-sync-eszetael_lab-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/eszetael_lab~bluesky-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-eszetael_lab-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "What to scrape",
                        "enum": [
                            "author_posts",
                            "search_posts",
                            "profiles",
                            "search_profiles",
                            "post_thread",
                            "followers",
                            "follows"
                        ],
                        "type": "string",
                        "description": "Pick the capability. Everything except 'search_posts' works with no login.",
                        "default": "author_posts"
                    },
                    "handles": {
                        "title": "Accounts (handles or DIDs)",
                        "type": "array",
                        "description": "e.g. nytimes.com, bsky.app, or did:plc:... . Used by author_posts, profiles, followers, follows.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword(s) for 'search_posts' or 'search_profiles'. Supports Bluesky search syntax."
                    },
                    "postUrls": {
                        "title": "Post URLs",
                        "type": "array",
                        "description": "bsky.app post URLs (or at:// URIs) for 'post_thread'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max results (per target)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap results per account/query. 0 or empty = unlimited (until the API runs out).",
                        "default": 200
                    },
                    "authorFeedFilter": {
                        "title": "Author feed filter",
                        "enum": [
                            "posts_and_author_threads",
                            "posts_no_replies",
                            "posts_with_media",
                            "posts_with_replies"
                        ],
                        "type": "string",
                        "description": "For 'author_posts': which posts to include.",
                        "default": "posts_and_author_threads"
                    },
                    "sort": {
                        "title": "Sort (search_posts)",
                        "enum": [
                            "latest",
                            "top"
                        ],
                        "type": "string",
                        "description": "Sort order for search results: 'latest' (newest first) or 'top' (most relevant).",
                        "default": "latest"
                    },
                    "since": {
                        "title": "Since (ISO date/datetime)",
                        "type": "string",
                        "description": "Only posts on/after this time, e.g. 2026-07-01 or 2026-07-01T00:00:00Z."
                    },
                    "until": {
                        "title": "Until (ISO date/datetime)",
                        "type": "string",
                        "description": "Only posts before this date (YYYY-MM-DD). Search modes only."
                    },
                    "lang": {
                        "title": "Language filter (search_posts)",
                        "type": "string",
                        "description": "Two-letter code, e.g. en, pl."
                    },
                    "fromAuthor": {
                        "title": "From author (search_posts)",
                        "type": "string",
                        "description": "Restrict search to one account's posts."
                    },
                    "mentions": {
                        "title": "Mentions (search_posts)",
                        "type": "string",
                        "description": "Posts mentioning this account."
                    },
                    "hashtags": {
                        "title": "Hashtags (search_posts)",
                        "type": "array",
                        "description": "Posts carrying these tags (no # sign).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "threadDepth": {
                        "title": "Thread depth",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "For 'post_thread': how many reply levels to walk.",
                        "default": 6
                    },
                    "onlyNew": {
                        "title": "Only new since last run (monitoring)",
                        "type": "boolean",
                        "description": "Skip posts already delivered in previous runs of this saved task — turns any scrape into a change monitor / alert feed.",
                        "default": false
                    },
                    "stateKey": {
                        "title": "Monitor state key",
                        "type": "string",
                        "description": "Optional label that groups 'onlyNew' memory. Leave blank to derive from the query/accounts."
                    },
                    "blueskyIdentifier": {
                        "title": "Bluesky handle (for post search)",
                        "type": "string",
                        "description": "Only needed for 'search_posts'. Your Bluesky handle, e.g. you.bsky.social."
                    },
                    "blueskyAppPassword": {
                        "title": "Bluesky app password",
                        "type": "string",
                        "description": "Create at Bluesky → Settings → App Passwords. NOT your main password. Only used to sign in for post search; never stored."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```