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

Bluesky Email Scraper helps you collect creator and community emails from Bluesky profiles. Use the data for partnerships, promotions, newsletters, and direct communication at scale.

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

## Pricing

$14.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 you to **extract** a wide range of **data** from the **Bluesky** platform efficiently and accurately. This includes not only email addresses but also other relevant **contact** and profile information.

The tool is designed to collect publicly available **data** while adhering to legal and ethical standards. It is ideal for creating email **data**bases, analyzing user engagement, and building targeted marketing campaigns.

With its automation capabilities, you can gather large volumes of **data** in a fraction of the time it would take manually. **Bluesky** Email Scraper is versatile and customizable, making it suitable for various industries and use cases.

Bluesky Email Scraper is an advanced tool designed to extract email addresses and other relevant contact information from the Bluesky platform. It simplifies the process of gathering valuable data for outreach, marketing, and networking purposes.

With its automated email scraping capabilities, this tool eliminates the need for manual data collection, saving you time and effort. It is perfect for businesses, researchers, and marketers who need accurate and efficient data extraction.

Bluesky Email Scraper ensures compliance with ethical guidelines while providing reliable results. It is a powerful solution for building email databases and enhancing your contact lists.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: hello.scrapio@gmail.com*
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract publicly available email addresses from Bluesky profiles. |
| Usernames | Collect usernames associated with Bluesky accounts. |
| Profile names | Retrieve the display names of Bluesky users. |
| Bio information | Extract user bios and descriptions for additional context. |
| Profile links | Gather links to Bluesky profiles for direct access. |
| Location data | Identify location details if made available by the user. |
| Website links | Collect website URLs shared on Bluesky profiles. |
| Engagement metrics | Analyze follower counts and other engagement data. |

### 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 scraping for efficient data collection
- ⭐ Supports large-scale data extraction from **Bluesky** profiles
- ⭐ **Customizable** filters to target specific user demographics
- ⭐ User-friendly interface with no technical expertise required
- ⭐ Adheres to legal and ethical data scraping practices
- ⭐ **Fast** and reliable performance for time-sensitive projects
- ⭐ Export data in multiple formats for easy integration
- ⭐ **Regular** updates to ensure compatibility with **Bluesky** changes
- ⭐ **Secure** and private data handling to protect user information
- ⭐ Scalable solutions for businesses of all sizes

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

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

1. ✅ **Sign up** for an Apify account or **log in** to your existing account
2. ✅ Navigate to the **Bluesky** Email Scraper in the Apify Actors library
3. ✅ Click Try for free or Run to start using the scraper
4. ✅ Enter your search parameters such as keywords or profile filters
5. ✅ Adjust the settings to customize the data extraction process
6. ✅ Click Run to initiate the email scraping task
7. ✅ Monitor the progress of the scraping process in real-time
8. ✅ Download the extracted data in your preferred format once completed
9. ✅ **Review** the data to ensure accuracy and completeness
10. ✅ Use the extracted information for your intended purpose such as marketing or research

### Use Cases 🎯

Lead Generation
🎯 Build targeted email lists for marketing campaigns
🎯 **Identify** potential clients or collaborators on **Bluesky**

Market Research
🎯 **Analyze** user data to understand audience demographics
🎯 Gather insights for product development and strategy

Networking
🎯 Connect with professionals and influencers in your industry
🎯 Expand your network by reaching out to **Bluesky** users

Content Promotion
🎯 Distribute your content to relevant **Bluesky** users
🎯 Increase engagement by targeting active profiles

Competitor Analysis
🎯 Monitor competitor activity and engagement metrics
🎯 **Identify** trends and strategies used by industry leaders

### Why choose us? 💎

**Bluesky** Email Scraper offers unparalleled efficiency and accuracy in data extraction, making it the ideal tool for professionals and businesses. Our email scraping tool is designed to save you time and effort by automating the data collection process.

We prioritize user experience by providing a simple and intuitive interface that requires no technical expertise. With customizable settings, you can tailor the scraping process to meet your specific needs, ensuring you get the most relevant data.

Our tool is built to handle large-scale data extraction, making it suitable for businesses of all sizes. We adhere to strict legal and ethical guidelines, ensuring that your data collection activities remain compliant.

**Bluesky** Email Scraper is **regular**ly updated to stay compatible with platform changes, providing you with a **reliable** and future-proof solution. Choose us for a secure, **scalable**, and efficient email scraping service that delivers results.

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

**Bluesky** Email Scraper is designed to scale with your needs, whether you're a small business or a large enterprise. Our tool can handle **extensive** data extraction tasks without compromising on speed or accuracy.

With its robust infrastructure, **Bluesky** Email Scraper supports simultaneous scraping operations, allowing you to collect data from multiple profiles or keywords at once. The tool's **customizable** settings enable you to focus on specific data points, ensuring that you only extract the information you need.

As your data requirements grow, **Bluesky** Email Scraper can adapt to meet the increased demand, providing a reliable and **efficient** solution for any scale of operation.

### **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
⚖️ **Only** extract publicly available data to respect user privacy
⚖️ **Do not** use the tool for spamming or unsolicited email campaigns
⚖️ Verify the legality of data scraping in your jurisdiction before use
⚖️ **Avoid** collecting sensitive or personal information without consent
⚖️ **Use** the extracted data responsibly and ethically
⚖️ Provide an opt-out option for individuals who wish to be removed from your database
⚖️ Regularly review and update your practices to remain compliant with data protection laws

### 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 that extracts email addresses and other data from Bluesky profiles for marketing, research, and networking purposes.

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

**Yes**, as long as you comply with Bluesky's terms of service and only extract **publicly available** data.

#### What data can I **extract** using this tool?

You can extract email addresses, usernames, profile names, bios, profile links, location data, website links, and engagement metrics.

#### Do I need technical skills to use Bluesky **Email Scraper**?

**No**, the tool is **user-friendly** and requires no technical expertise to operate.

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

**Yes**, you can adjust the settings to target specific profiles or data points.

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

**Yes**, Bluesky Email Scraper ensures **secure** and private handling of all extracted data.

#### How often is the tool updated?

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

#### Can I use this tool for **large-scale** data **extract**ion?

**Yes**, Bluesky Email Scraper is designed to handle large-scale data extraction efficiently.

#### What formats are available for data **export**?

You can export the extracted data in multiple formats, such as **CSV** and **JSON**.

#### Is there a free trial available?

**Yes**, you can try Bluesky Email Scraper for free with limited features.

#### Can I scrape data from **private** profiles?

**No**, the tool only extracts data from **publicly available** profiles to respect user privacy.

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

Contact our support team for assistance with any technical issues or questions.

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bluesky Email Scraper",
        "description": "Bluesky Email Scraper helps you collect creator and community emails from Bluesky profiles. Use the data for partnerships, promotions, newsletters, and direct communication at scale.",
        "version": "0.1",
        "x-build-id": "SrgrWcgxX7jGg6mPP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapio~bluesky-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapio-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/scrapio~bluesky-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapio-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/scrapio~bluesky-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapio-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```