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

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

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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, focusing primarily on lead addresses. This tool ensures that the **data** collected is accurate, relevant, and well-structured for various use cases.

You can **extract** not only lead addresses but also associated meta**data** such as usernames, profile links, and more. The software is designed to handle bulk lead **extract**ion, making it ideal for large-scale **data** collection projects.

Additionally, the **Bluesky** lead parser organizes the **extract**ed **data** into a format that is easy to analyze and use. Whether you are looking for lead generation or **contact** management, this tool provides a comprehensive solution for your **data** scraping needs.

Bluesky Lead Scraper is a powerful tool designed to help you extract lead addresses from the Bluesky platform efficiently and accurately. This automated lead scraper simplifies the process of gathering contact information for your business or personal use.

With the Bluesky lead extraction tool, you can quickly collect valuable data for lead generation, marketing campaigns, or networking purposes. It is an essential software for anyone looking to streamline their data collection efforts on Bluesky.

Our Bluesky contact scraper is built with advanced technology to ensure precise results while adhering to ethical guidelines. It is user-friendly and suitable for both beginners and professionals alike.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead addresses | Extract verified lead addresses associated with Bluesky profiles. |
| Usernames | Capture usernames linked to the extracted lead addresses. |
| Profile links | Retrieve direct links to the Bluesky profiles of users. |
| Account metadata | Extract additional details such as bio or location, when available. |
| Activity data | Collect user activity information relevant to your data needs. |
| Custom tags | Identify and extract specific tags or keywords from profiles. |
| Follower count | Gather data on the number of followers for each profile. |
| Engagement metrics | Analyze metrics such as likes or comments for better insights. |

### 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** extraction of lead addresses from **Bluesky** profiles
- ⭐ Bulk lead extraction to handle large-scale data scraping efficiently
- ⭐ User-friendly interface suitable for both beginners and experts
- ⭐ **Advanced** filtering options to target specific profiles or data types
- ⭐ Seamless integration with other tools for data analysis and management
- ⭐ **High** accuracy in extracting and organizing relevant data
- ⭐ Compliance with ethical guidelines for responsible scraping
- ⭐ **Customizable** scraping parameters to meet unique project needs
- ⭐ **Regular** updates to ensure compatibility with the **Bluesky** platform
- ⭐ **Secure** and encrypted data handling to protect user privacy
- ⭐ Detailed reporting and export options in multiple formats
- ⭐ 247 customer support to assist with any technical issues

### How to use **Bluesky** Lead Scraper 🚀

Follow this **simple, step-by-step guide** to start extracting **Bluesky** leads today:

1. ✅ **Sign up** or **log in** to your **Bluesky** Lead Scraper account
2. ✅ Navigate to the dashboard and select New Scraping Task
3. ✅ Enter the target keywords or profile criteria for data extraction
4. ✅ Customize the scraping parameters such as filters or limits
5. ✅ **Start** the scraping process and monitor progress in real-time
6. ✅ Once completed review the extracted data for accuracy
7. ✅ **Export** the data to your preferred format such as CSV or JSON
8. ✅ Use the data for lead generation marketing or other purposes
9. ✅ Adjust settings and repeat the process for additional tasks
10. ✅ Access customer support if you encounter any issues

### Use Cases 🎯

Lead Generation
🎯 Extract lead addresses for potential clients or partners
🎯 Build a targeted lead list for marketing campaigns

Market Research
🎯 **Analyze** user profiles to understand audience demographics
🎯 Gather data for competitor analysis and trend identification

Networking
🎯 **Find** contact information for professionals in your industry
🎯 Expand your network by connecting with relevant users

Content Promotion
🎯 Reach out to influencers for collaboration opportunities
🎯 Distribute promotional material to a targeted audience

### Why choose us? 💎

**Bluesky** Lead Scraper stands out as a **reliable** and efficient lead scraping service for the **Bluesky** platform. Our tool is designed with user convenience in mind, offering a simple yet powerful interface that caters to both beginners and experts.

With **advanced** features like bulk lead extraction and customizable parameters, you can tailor the scraping process to meet your specific needs. We prioritize accuracy and data quality, ensuring that the information you collect is relevant and actionable.

Additionally, our software is **regular**ly updated to maintain compatibility with **Bluesky**'s evolving platform. We adhere to ethical guidelines and provide secure data handling to protect user privacy.

Our dedicated customer support team is available 24/7 to assist you with any technical challenges. Choose **Bluesky** Lead Scraper for a comprehensive, **scalable**, and trustworthy solution to your lead scraping needs.

### **Bluesky** Lead Scraper Scalability 📈

**Bluesky** Lead Scraper is designed to handle projects of any size, from small-scale data collection to **large-scale** bulk lead extraction. Our tool is equipped with **advanced** algorithms that ensure **efficient** performance even when dealing with **extensive** datasets.

The software's **customizable** parameters allow you to scale your operations based on your specific requirements. Whether you are a small business owner or part of a large enterprise, **Bluesky** Lead Scraper can adapt to your needs **seamless**ly.

Its robust infrastructure supports concurrent scraping tasks, enabling you to save time and maximize productivity. With regular updates and optimizations, our tool remains reliable and **efficient** as your data scraping demands grow.

### **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 for unauthorized or malicious purposes
⚖️ **Obtain** consent before using extracted data for marketing or outreach
⚖️ **Avoid** scraping sensitive or private information without permission
⚖️ **Use** the tool responsibly to prevent overloading **Bluesky**s servers
⚖️ **Adhere** to applicable data protection laws such as GDPR or CCPA
⚖️ **Do not** sell or distribute extracted data without proper authorization
⚖️ Regularly review and update your scraping practices to align with legal standards

### 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** tool for extracting lead addresses and related data from the Bluesky platform.

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

**Yes**, the tool features a **user-friendly** interface suitable for both beginners and experts.

#### Can I **extract** bulk leads with this tool?

**Yes**, Bluesky Lead Scraper supports bulk lead extraction for large-scale projects.

#### Is the **extract**ed data accurate?

Our tool is designed to ensure high accuracy in data extraction and organization.

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

You can export the extracted data to formats such as **CSV** or **JSON**.

#### Is Bluesky **Lead Scraper** compliant with **legal** guidelines?

**Yes**, the tool is built to adhere to ethical and legal standards for data scraping.

#### Can I customize the scraping parameters?

**Yes**, you can adjust filters and other settings to tailor the scraping process to your needs.

#### Does the tool work with the latest Bluesky updates?

Our software is regularly updated to maintain compatibility with Bluesky's platform.

#### Is **customer support** available?

**Yes**, we offer 24/7 customer support to assist with any technical issues.

#### Can I use the tool for **lead generation**?

**Yes**, Bluesky Lead Scraper is ideal for generating leads and building targeted lead lists.

#### Is the tool **secure**?

**Yes**, we prioritize **secure** and encrypted data handling to protect user privacy.

#### What data types can I **extract**?

You can extract lead addresses, usernames, profile links, and more.

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

**Yes**, the tool supports concurrent scraping tasks for efficiency.

#### Is there a free trial available?

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

#### How do I get started with Bluesky **Lead Scraper**?

Sign up on our website, log in to your account, and follow the step-by-step instructions provided in the tool.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Lead Scraper",
        "version": "0.1",
        "x-build-id": "frrjnabMlTWniP6N0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~bluesky-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-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/scrapapi~bluesky-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-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/scrapapi~bluesky-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```