# Bluesky Email Scraper (`api-empire/bluesky-email-scraper`) Actor

Automate email extraction from Bluesky with Bluesky Email Scraper. The actor scans profiles and external links to pull available contact emails into structured datasets for CRM enrichment.

- **URL**: https://apify.com/api-empire/bluesky-email-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Lead generation, Automation, Social media
- **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** Email Scraper 📱

**Bluesky** Email Scraper allows users to **extract** a variety of **data** types from the **Bluesky** platform. This includes email addresses, user profile information, and other relevant **contact** details.

The tool is designed to provide accurate and comprehensive **data** for your specific needs. It is capable of **extract**ing information from public profiles, posts, and other accessible areas of the platform.

The **data** collected can be used for lead generation, outreach campaigns, or market research. **Bluesky** Email Scraper ensures that the **data** is organized and ready for use in your preferred format.

With its advanced algorithms, it minimizes errors and maximizes efficiency. This makes it an essential tool for those looking to streamline their **data** collection processes on **Bluesky**.

Bluesky Email Scraper is an advanced tool designed to extract email addresses and other valuable data from the Bluesky platform efficiently. It simplifies the process of gathering contact information for businesses and individuals seeking to expand their networks.

With Bluesky Email Scraper, you can automate the tedious task of email collection, saving time and effort. This tool is ideal for lead generation, marketing campaigns, and building professional connections.

Our email scraping software ensures accuracy and compliance with data privacy regulations. It is a reliable solution for anyone looking to extract emails from Bluesky without manual effort.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.apiempire@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email Addresses | Extract publicly available email addresses from Bluesky user profiles. |
| Usernames | Retrieve usernames associated with profiles for identification purposes. |
| Profile Bios | Collect information from user bios to understand interests or professional details. |
| Profile Links | Extract links shared in user profiles for further exploration or contact. |
| Post Content | Gather text content from posts to analyze user activity or preferences. |
| Follower Counts | Retrieve follower statistics to identify influential users. |
| Profile Images | Download profile pictures for identification or analysis purposes. |
| Location Data | Extract location details if shared publicly in user profiles. |

### Key Features of **Bluesky** Email Scraper

Here are the **standout features** that make the **Bluesky** Email Scraper a **top-tier tool** for **marketers**, **agencies**, and **researchers**:

- ⭐ **Automated** email extraction from **Bluesky** profiles and posts
- ⭐ **High**ly accurate data collection with minimal errors
- ⭐ User-friendly interface for easy operation and customization
- ⭐ Support for exporting data in multiple formats like CSV and JSON
- ⭐ **Advanced** filtering options to target specific profiles or posts
- ⭐ Compliance with data privacy regulations and ethical guidelines
- ⭐ **Regular** updates to ensure compatibility with **Bluesky**s platform changes
- ⭐ Scalable performance for handling large-scale data extraction tasks
- ⭐ **Customizable** scraping parameters for tailored data collection
- ⭐ Detailed logs and reports for monitoring scraping activities
- ⭐ **Secure** and encrypted data handling to protect user privacy
- ⭐ 247 customer support to assist with any issues or queries

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

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

1. ✅ **Sign up** for an account or **log in** to access the **Bluesky** Email Scraper
2. ✅ Install the software or access the web-based application
3. ✅ Enter your **Bluesky** login credentials to connect your account securely
4. ✅ **Configure** the scraping parameters such as target profiles or keywords
5. ✅ **Select** the data types you want to extract like emails or profile details
6. ✅ **Start** the scraping process and monitor its progress in real-time
7. ✅ Pause resume or stop the scraping task as needed
8. ✅ **Export** the collected data in your preferred format such as CSV or JSON
9. ✅ **Review** the extracted data for accuracy and completeness
10. ✅ Use the data for your intended purposes such as lead generation or research
11. ✅ Adjust the scraping settings for future tasks to optimize results
12. ✅ Contact customer support if you encounter any issues during the process

### Use Cases 🎯

Lead Generation
🎯 Extract email addresses from **Bluesky** profiles for targeted outreach
🎯 Build a comprehensive database of potential customers or clients
🎯 **Identify** key influencers and decision-makers in your industry

Market Research
🎯 **Analyze** user profiles and posts to understand market trends
🎯 Gather data on competitor activity and audience engagement
🎯 **Identify** potential gaps in the market based on user behavior

Recruitment
🎯 **Find** potential candidates by extracting contact details from profiles
🎯 **Analyze** user bios and activity to identify suitable talent
🎯 Build a database of qualified professionals for future hiring needs

Networking
🎯 Expand your professional network by collecting contact information
🎯 Connect with like-minded individuals or industry leaders
🎯 **Use** extracted data to organize events or collaborations

Content Analysis
🎯 **Analyze** post content to identify trending topics or user interests
🎯 Gather data for sentiment analysis or content strategy planning
🎯 Monitor user engagement with specific hashtags or keywords

### Why choose us? 💎

**Bluesky** Email Scraper stands out as a **reliable** and efficient email scraping tool for the **Bluesky** platform. Our software is designed with **advanced** algorithms to ensure accurate and comprehensive data collection.

We prioritize user experience by offering a simple and intuitive interface that caters to both beginners and professionals. Our tool is highly customizable, allowing users to tailor scraping parameters to their specific needs.

We stay up-to-date with **Bluesky**'s platform changes to maintain compatibility and performance. With robust security measures, we ensure that all data is handled securely and ethically.

Our software is compliant with data privacy regulations, giving users peace of mind while using our services. We offer 24/7 customer support to assist with any issues or questions.

Choose **Bluesky** Email Scraper for a dependable and effective solution to your email scraping needs.

### **Bluesky** Email Scraper Scalability 📈

**Bluesky** Email Scraper is designed to handle data extraction tasks of any scale. Whether you need to scrape a few profiles or thousands, our tool ensures consistent performance and accuracy.

It is optimized for speed, allowing you to complete **large-scale** scraping projects **efficient**ly. Our software supports batch processing, enabling users to extract data from multiple profiles simultaneously.

With **advanced** filtering options, you can target specific data sets, reducing unnecessary processing. **Bluesky** Email Scraper is built on a robust infrastructure that ensures stability even under heavy workloads.

This makes it suitable for businesses, researchers, and individuals with varying data extraction needs. Our scalable solution grows with your requirements, making it a versatile tool for long-term use.

### **Bluesky** Email Scraper Legal Guidelines ⚖️

**Yes**—scraping **Bluesky** is **legal** as long as you follow **ethical** and **compliant** practices. The **Bluesky** Email 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** scrape private or restricted data without proper authorization
⚖️ **Use** the extracted data responsibly and ethically for legitimate purposes
⚖️ **Avoid** spamming or misusing the contact information collected
⚖️ Respect user privacy and adhere to data protection laws in your region
⚖️ Inform users if their data is being collected and provide an opt-out option if required
⚖️ **Do not** use the scraper for malicious activities or unauthorized access
⚖️ Regularly review and update your practices to remain compliant with legal standards

### Input Parameters 🧩
📦 Example Input (JSON)
```json
{
  "keywords": ["Bluesky Email Scraper"],
  "country": "Global",
  "maxEmailNumbers": 20,
  "platform": "Bluesky",
  "engine": "legacy"
}
````

### Input Table

| Data Type | Description |
| --- | --- |
| keywords | Keywords to find relevant profiles |
| country | Country setting (Global) |
| maxEmailNumbers | Maximum emails 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 Email 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",
    "email": "before@gmail.com"
  }
]
```

### Output Table

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

### FAQ ❓

#### What is Bluesky **Email Scraper**?

Bluesky Email Scraper is a tool designed to extract email addresses and other data from the Bluesky platform efficiently.

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

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

#### Can I **extract** data other than emails?

**Yes**, the scraper can extract usernames, profile bios, links, post content, and more.

#### Is the tool easy to use for **beginners**?

**Yes**, Bluesky Email Scraper features a **user-friendly** interface suitable for beginners and professionals alike.

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

You can export the data in formats like **CSV** and **JSON** for easy integration with other tools.

#### Does the scraper comply with data privacy laws?

**Yes**, the tool is designed to comply with data privacy laws and ethical guidelines.

#### Can I customize the scraping parameters?

**Yes**, you can customize parameters such as target profiles, keywords, and data types.

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

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

#### How often is the tool updated?

The tool is regularly updated to ensure compatibility with Bluesky's platform changes.

#### Can I scrape data in bulk?

**Yes**, the scraper supports bulk data extraction for large-scale projects.

#### Is my data **secure** while using the scraper?

**Yes**, we use robust security measures to ensure that your data is handled **secure**ly.

#### What are the system requirements for the scraper?

The system requirements vary based on the version, but it is compatible with most modern devices and browsers.

#### Can I pause or stop the scraping process?

**Yes**, you can pause, resume, or stop the scraping process at any time.

#### Does the tool support multiple languages?

Currently, the tool supports English, but additional language support may be added in future updates.

#### Is there a free trial available?

**Yes**, we offer a free trial to help you evaluate the tool before purchasing.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Email Scraper",
        "description": "Automate email extraction from Bluesky with Bluesky Email Scraper. The actor scans profiles and external links to pull available contact emails into structured datasets for CRM enrichment.",
        "version": "0.1",
        "x-build-id": "bWKADqpGTyMTITmE7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~bluesky-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-bluesky-email-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/api-empire~bluesky-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-bluesky-email-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/api-empire~bluesky-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-bluesky-email-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```