# Bluesky Lead Scraper (`simpleapi/bluesky-lead-scraper`) Actor

🔎 Bluesky Lead Scraper automates lead gen on Bluesky—collecting profiles, bios, links, followers, keywords & engagement. 📊 Target by hashtags/queries and export CSV. 🚀 Ideal for sales, growth, and recruiting. ⚡ Fast, accurate, scalable.

- **URL**: https://apify.com/simpleapi/bluesky-lead-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** Automation, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### **Bluesky** Lead Scraper 📱

**Bluesky** Lead Scraper allows you to **extract** a wide range of **data** from the **Bluesky** platform with ease. This includes lead addresses, usernames, and other relevant **contact** details for targeted outreach.

The tool ensures that all **extract**ed **data** is accurate and formatted for immediate use. You can also **extract** meta**data** associated with user profiles, such as profile descriptions and activity timestamps.

By using this lead **data** **extract**ion tool, you can streamline your marketing efforts and focus on building meaningful connections. **Bluesky** Lead Scraper is designed to handle large volumes of **data** while maintaining precision and compliance with ethical standards.

It is the best lead scraper software for professionals and businesses looking for reliable lead scraping solutions.

Bluesky Lead Scraper is a powerful tool designed to extract lead addresses from the Bluesky platform quickly and efficiently. It is an ideal solution for businesses and marketers looking to streamline their lead data collection processes.

Our lead scraping tool offers automated lead scraping capabilities, saving you time and effort. With Bluesky Lead Scraper, you can gather valuable contact information for marketing and outreach campaigns.

Bluesky Lead Scraper is built using advanced technology to ensure accurate and reliable data extraction. It is the best lead scraper software for those who need precise results without manual effort.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: dev.scraperengine@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead addresses | Extract verified lead addresses associated with Bluesky user profiles. |
| Usernames | Retrieve usernames linked to the extracted lead addresses for better identification. |
| Profile descriptions | Capture user profile descriptions to gain insights into their interests or professional background. |
| Activity timestamps | Extract timestamps of user activities to understand engagement patterns. |
| Profile links | Collect direct links to user profiles for easy navigation and further research. |
| Location data | Retrieve location details if available within user profiles for targeted outreach. |
| Follower counts | Extract follower metrics to identify influential users. |
| Custom tags | Capture any custom tags or labels associated with user profiles for categorization. |

### Key Features of **Bluesky** Lead Scraper

Here are the **standout features** that make the **Bluesky** Lead Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** lead scraping for quick and efficient data extraction
- ⭐ User-friendly interface designed for ease of use and customization
- ⭐ Supports large-scale data scraping without compromising accuracy
- ⭐ Extracts multiple data types including leads usernames and profile descriptions
- ⭐ Ensures compliance with ethical and legal standards during data extraction
- ⭐ Allows filtering and sorting of extracted data for better organization
- ⭐ Provides detailed logs and reports for transparency and auditing
- ⭐ Compatible with various operating systems and platforms for flexibility
- ⭐ Offers robust customer support to assist with any issues or queries
- ⭐ **Regular** updates to ensure compatibility with **Bluesky** platform changes
- ⭐ **Secure** data handling to protect user privacy and maintain confidentiality
- ⭐ **Customizable** scraping parameters to meet specific project requirements

### How to use **Bluesky** Lead Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Bluesky** leads today:

1. ✅ Download and install the **Bluesky** Lead Scraper software on your device
2. ✅ Log in to your **Bluesky** account through the scraper tool to establish a connection
3. ✅ Set your scraping parameters such as keywords user profiles or hashtags to target
4. ✅ **Start** the scraping process and allow the tool to extract the desired data automatically
5. ✅ Monitor the progress through the dashboard and view real-time extraction logs
6. ✅ Once scraping is complete review the extracted data in the tools interface
7. ✅ **Export** the data in your preferred format such as CSV or Excel for further use
8. ✅ Use the extracted lead addresses and other data for marketing or research purposes

### Use Cases 🎯

Marketing Campaigns
🎯 Extract lead addresses for targeted lead marketing campaigns
🎯 **Identify** potential leads and build a comprehensive lead list

Research and Analysis
🎯 **Collect** data for market research and trend analysis
🎯 **Analyze** user activity and engagement patterns on **Bluesky**

Networking and Outreach
🎯 **Find** and connect with professionals in your industry
🎯 Gather contact information for collaboration opportunities

Influencer Identification
🎯 **Identify** influential users based on follower counts and activity
🎯 Extract profile data to assess potential brand ambassadors

Data Organization
🎯 Sort and categorize extracted data for efficient use
🎯 Export data in structured formats for seamless integration with other tools

### Why choose us? 💎

**Bluesky** Lead Scraper stands out as the **best** lead scraper software due to its **advanced** features and user-centric design. It offers automated lead scraping solutions that save time and effort for businesses and individuals alike.

Our tool is built with precision and reliability in mind, ensuring that all extracted data is accurate and ready for use. We prioritize user privacy and data security, adhering to strict ethical guidelines during the scraping process.

With **Bluesky** Lead Scraper, you can extract lead addresses online and organize them for your specific needs. Our software is compatible with various platforms and offers **regular** updates to keep up with changes on the **Bluesky** platform.

Whether you are a marketer, researcher, or business owner, our lead scraping tool provides the flexibility and scalability you need. Choose **Bluesky** Lead Scraper for a seamless and efficient data extraction experience tailored to your goals.

### **Bluesky** Lead Scraper Scalability 📈

**Bluesky** Lead Scraper is designed to handle data extraction tasks of any scale, making it suitable for both small and large projects. Whether you need to extract a few lead addresses or thousands, our tool ensures consistent performance and accuracy.

The software is equipped with **advanced** algorithms to process large datasets without compromising speed or reliability. It also supports batch processing, allowing you to scrape data from multiple profiles or keywords simultaneously.

**Bluesky** Lead Scraper adapts to your needs, providing **customizable** options for targeted data extraction. As your data requirements grow, our tool scales effortlessly to meet the increasing demand.

With its robust architecture, **Bluesky** Lead Scraper is the ultimate lead scraping solution for businesses and professionals.

### **Bluesky** Lead Scraper Legal Guidelines ⚖️

**Yes**—scraping **Bluesky** is **legal** as long as you follow **ethical** and **compliant** practices. The **Bluesky** Lead Scraper extracts only **publicly available** information from **public** **Bluesky** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Bluesky**s terms of service when using the scraper
⚖️ **Do not** use the tool to extract data for illegal or unethical purposes
⚖️ **Obtain** user consent where required before utilizing their contact information
⚖️ **Avoid** scraping sensitive or personal data that is not publicly available
⚖️ **Use** extracted data responsibly and in accordance with applicable privacy laws
⚖️ **Do not** share or sell extracted data without proper authorization
⚖️ Regularly review and adhere to updates in **Bluesky**s policies and guidelines
⚖️ Consult legal counsel if unsure about the legality of your data scraping activities

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Bluesky Lead Scraper"],
  "country": "Global",
  "maxLeadNumbers": 20,
  "platform": "Bluesky",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxLeadNumbers | Maximum leads to collect (default 20) |
| platform | Platform to scrape (Bluesky) |
| engine | Engine type (legacy) |
| proxyConfiguration | Optional proxy settings |

### Output Format 📤

📝 Example Output (JSON)

```json
[
  {
    "network": "Bluesky",
    "keyword": "Bluesky Lead Scraper",
    "title": "Google's Single-Benefit Marketing Strategy for Chrome ...",
    "description": "✓For years, once we created a Gmail account, we couldn't change the username (the part before @ gmail.com ). ... Grand Rapids Marketing Co. Read more",
    "url": "https://www.linkedin.com/posts/phill-agnew_heres-how-google-marketed-chrome-browser-activity-7404878510214914048-dLxI",
    "lead": "before@gmail.com"
  }
]
```

### Output Table

| Data Type | Description |
| --- | --- |
| network | Identifies Bluesky as the source |
| keyword | Keyword that triggered the result (Bluesky Lead Scraper) |
| title | Profile title or username |
| description | Public bio snippet with contact info |
| url | Direct Bluesky profile link |
| lead | Extracted lead address |

### FAQ ❓

#### What is Bluesky **Lead Scraper**?

Bluesky Lead Scraper is an **automated** lead scraping tool designed to extract lead addresses and other data from the Bluesky platform.

#### How does Bluesky **Lead Scraper** work?

The tool connects to your Bluesky account and extracts data based on your specified parameters such as keywords or profiles.

#### Is Bluesky **Lead Scraper** **legal** to use?

**Yes**, it is legal to use as long as you comply with Bluesky's terms of service and applicable privacy laws.

#### Can I customize the data **extract**ion process?

**Yes**, you can set specific parameters such as keywords, profiles, and data types to customize the scraping process.

#### What formats can I **export** the data in?

You can export the extracted data in formats such as **CSV** or Excel for easy use and integration.

#### Does the tool support **large-scale** data scraping?

**Yes**, Bluesky Lead Scraper is designed to handle **large volumes** of data efficiently and accurately.

#### Is my data **secure** when using Bluesky **Lead Scraper**?

**Yes**, the tool prioritizes data security and ensures that all extracted information is handled responsibly.

#### Can I use the tool for marketing purposes?

**Yes**, you can use the extracted lead addresses and data for targeted marketing campaigns, provided you comply with legal requirements.

#### Does Bluesky **Lead Scraper** offer **customer support**?

**Yes**, we provide robust customer support to assist you with any issues or questions.

#### How often is the software updated?

Bluesky Lead Scraper is regularly updated to ensure compatibility with changes on the Bluesky platform.

#### Can I scrape data from multiple profiles simultaneously?

**Yes**, the tool supports batch processing, allowing you to scrape data from multiple profiles at once.

#### Is there a free trial available?

Please check our website for information on free trials or demo versions of the software.

#### What are the system requirements for Bluesky **Lead Scraper**?

The tool is compatible with major operating systems and requires a stable internet connection.

#### Can I use this tool without technical expertise?

**Yes**, Bluesky Lead Scraper is **user-friendly** and designed for individuals with varying levels of technical expertise.

#### What should I do if I encounter issues with the tool?

You can contact our customer support team for assistance with any technical or operational issues.

# Actor input Schema

## `keywords` (type: `array`):

List of keywords to search for on Blueskyweb (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Blueskyweb profiles/posts containing these keywords and extract email addresses.

## `platform` (type: `string`):

Select platform.

## `location` (type: `string`):

Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.

## `emailDomains` (type: `array`):

Optional: Filter results to only include emails from specific domains (e.g., \['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.

## `maxEmails` (type: `integer`):

Maximum number of emails to collect per keyword (default: 20).

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

## `proxyConfiguration` (type: `object`):

Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "platform": "Blueskyweb",
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": 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 = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/bluesky-lead-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 = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/bluesky-lead-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 '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/bluesky-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Lead Scraper",
        "description": "🔎 Bluesky Lead Scraper automates lead gen on Bluesky—collecting profiles, bios, links, followers, keywords & engagement. 📊 Target by hashtags/queries and export CSV. 🚀 Ideal for sales, growth, and recruiting. ⚡ Fast, accurate, scalable.",
        "version": "0.1",
        "x-build-id": "oFGgrETd5FiWd1ino"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/simpleapi~bluesky-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-simpleapi-bluesky-lead-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/simpleapi~bluesky-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-simpleapi-bluesky-lead-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/simpleapi~bluesky-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-simpleapi-bluesky-lead-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Blueskyweb (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Blueskyweb profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Blueskyweb"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Blueskyweb"
                    },
                    "location": {
                        "title": "Location Filter",
                        "type": "string",
                        "description": "Optional: Add location to search query (e.g., 'London', 'New York'). Leave empty to search globally.",
                        "default": ""
                    },
                    "emailDomains": {
                        "title": "Email Domains Filter",
                        "type": "array",
                        "description": "Optional: Filter results to only include emails from specific domains (e.g., ['@gmail.com', '@outlook.com']). Leave empty to collect all email domains.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Maximum Emails per Keyword",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect per keyword (default: 20).",
                        "default": 20
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "legacy"
                        ],
                        "type": "string",
                        "description": "Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE_SERP proxy with traditional selectors - more reliable but slower and more expensive.",
                        "default": "legacy"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used. If Google rejects or blocks the request, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
