# Bitbucket Email Scraper Fast Advanced And Cheapest (`scraperoka/bitbucket-email-scraper-fast-advanced-and-cheapest`) Actor

🚀 Bitbucket Email Scraper fast, advanced & cost-effective! Extract emails from Bitbucket profiles and repositories with precision. Perfect for B2B outreach, lead gen, recruiting & market research. ⚡ Save time, boost results!

- **URL**: https://apify.com/scraperoka/bitbucket-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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

### Bitbucket Email Scraper - Fast, Advanced and Cheapest 🎯

Manually hunting for Bitbucket contact emails wastes hours and still leaves gaps in your lead lists. **Bitbucket Email Scraper - Fast, Advanced and Cheapest** finds email addresses from publicly available Bitbucket sources using your keywords and domain filters—ideal for marketers, recruiters, and growth teams. This Bitbucket email extractor and Bitbucket email scraper helps you collect leads at speed, from a few targeted searches to thousands of records in a single run.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "network": "Bitbucket.com",
  "keyword": "manager",
  "title": "Example Repository Title",
  "description": "Example repository or profile text that may contain an email address.",
  "url": "https://bitbucket.org/example/repo",
  "email": "lead@example.com"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network used for each lead row (set to `Bitbucket.com`). |
| `keyword` | string | Which keyword (from your input) produced this email, so you can attribute sources easily. |
| `title` | string | The title text captured alongside the email, useful for quick triage. |
| `description` | string | The extracted text context where the email was found—handy for validation and deduping. |
| `url` | string | The Bitbucket page link related to the lead record for follow-up or verification. |
| `email` | string | The extracted email address that you can use for outreach or enrichment. |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Bitbucket Email Scraper - Fast, Advanced and Cheapest?

There are a lot of ways to pull data from Bitbucket sources—here's what sets **Bitbucket Email Scraper - Fast, Advanced and Cheapest** (including Bitbucket email extractor and Bitbucket email harvesting software styles) apart.

#### Fast, keyword-driven lead building

You control the search focus with `keywords` plus optional `location` and `customDomains`, so you’re not collecting random noise. This makes **fast Bitbucket email scraper** workflows more predictable for building contact lists quickly.

#### Domain filtering for better relevance

The actor uses `customDomains` (like `@gmail.com`, `@yahoo.com`) to target emails that match your outreach needs. If you’re trying to get emails from Bitbucket for specific inbox types, this helps you narrow results early.

#### Resumable progress (so you don’t lose work)

If a run stops or you need to pause, the actor saves cursor progress and already seen emails so it can resume without starting over from scratch. This is ideal for bulk email extraction from Bitbucket runs that may take time.

#### Cost control with a clear `maxEmails` cap

You can set `maxEmails` to stop once you’ve collected enough unique emails. That helps keep scraping time bounded and supports “cheapest Bitbucket email scraper” style budgeting through predictable stopping behavior.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["manager", "founder"],
  "location": "Berlin",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 50
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords or queries the actor uses to guide which Bitbucket sources it looks for emails in. |
| `location` | ⬜ | Optional location text to filter results more narrowly. Leave empty for broader coverage. |
| `customDomains` | ⬜ | A list of email domains (for example `@gmail.com`, `@yahoo.com`) used to accept only matching email addresses. |
| `maxEmails` | ⬜ | Maximum number of emails to collect (stops when the unique email count reaches this limit). Higher limits can take longer and don’t guarantee reaching the number. |

***

### Core Capabilities

#### Keyword flexibility for Bitbucket email extractor use cases

Use `keywords` to aim the Bitbucket email scraper toward roles or themes you care about (for example, “manager” or “founder”). With targeted keywords, you get more relevant author email extraction from Bitbucket sources.

#### Custom domain filters for targeted outreach

Set `customDomains` to focus on inbox types that match your strategy. This helps **Bitbucket email lookup** workflows stay clean when you’re building lists for outreach with specific email providers.

#### Resilient collection with continuation support

The actor maintains progress (cursor and already seen emails) so larger harvesting jobs can resume instead of repeating work. This improves reliability for bulk email extraction from Bitbucket when timeouts or interruptions happen.

#### Strong output completeness for analysis and enrichment

Each output row includes the source context you’ll want for downstream validation: `keyword`, `title`, `description`, `url`, and the extracted `email`. That means your dataset is ready for filtering and analysis without needing to reconstruct context.

#### Automation-ready for data pipelines

Results are pushed to the Apify dataset incrementally as they’re found, making it easy to connect to automation or export into your CRM or spreadsheets. This makes the tool a practical **Bitbucket scraper with email extraction** starting point.

***

### Who Gets the Most Out of This

Here's how different teams put Bitbucket Email Scraper - Fast, Advanced and Cheapest to work:

**Outbound sales and SDR teams** — Use targeted `keywords` (like roles) and `customDomains` to build a qualified email list from Bitbucket sources, then export and upload to outreach tools. The `url` and `description` fields help reps quickly validate each lead before sending.

**Recruiters and talent sourcers** — Run narrower domain filters to focus on particular email patterns and reduce manual cleanup. The resulting dataset supports fast review of candidate-related leads by `title` and source link.

**Growth and partnerships marketers** — Combine multiple keywords with domain preferences to find consistent contact points tied to repositories or profiles. You get a structured lead dataset you can slice by keyword to understand which themes produce the best response rates.

**Freelance researchers and data analysts** — Use the consistent dataset fields (`keyword`, `title`, `description`, `url`, `email`) to analyze email coverage and patterns across Bitbucket sources. Because the actor can be resumed, longer collection jobs are easier to manage.

**Automation specialists (developers / data engineers)** — Trigger runs, ingest dataset outputs, and push enriched records into downstream systems. This supports repeatable workflows for “get emails from Bitbucket” scenarios without manual scraping work.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Bitbucket Email Scraper - Fast, Advanced and Cheapest from start to finish:

1. **Open the actor on Apify** — visit the actor page on Apify Console: https://console.apify.com
2. **Enter your inputs** — add your `keywords` (required), optionally set `location`, `customDomains`, and `maxEmails` from the Configuration section.
3. **Configure proxy settings** — choose your proxy preference for the run (for best reliability on larger jobs).
4. **Hit Run and watch the live log** — monitor progress and see new emails being pushed incrementally.
5. **View results in the dataset tab** — the dataset fills as the actor finds emails.
6. **Export as JSON, CSV, or Excel** — download your dataset and load it into your CRM or spreadsheet tool.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Bitbucket Email Scraper - Fast, Advanced and Cheapest plugs directly into your existing workflow.

Export formats are available directly from the Apify dataset tab, including JSON, CSV, and Excel, so you can move data into analytics tools or CRMs right away.

You can also use the Apify API to access results programmatically, and connect runs to automation using webhooks, Zapier, or Make. For deeper setup details, use the Apify documentation: https://apify.com/docs/api

Scheduled runs are supported through Apify so you can refresh your Bitbucket email extractor results on a recurring basis.

***

### Pricing & Free Trial

Bitbucket Email Scraper - Fast, Advanced and Cheapest runs on the Apify platform, which offers a **free tier** — no credit card required to get started. The free tier typically includes platform credits enough for several test runs, so you can validate your keywords, domain filters, and email yield before scaling.

For production use, Apify billing is pay-as-you-go based on Actor compute units (CUs). To confirm the latest plan details and pricing, check the Apify pricing page on apify.com.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Resumable runs | Saves cursor and already seen emails so you can continue without losing progress. |
| Result control | Stops once `maxEmails` is reached (unique emails), helping you cap run time. |
| Reliability on larger jobs | Supports proxy usage for more consistent scraping behavior. |
| Duplicate prevention | Tracks `seen_emails` so repeated emails aren’t re-added to your dataset. |
| Incremental data writing | Pushes output rows as they’re found, so partial runs still produce usable results. |

Limitations: the actor extracts emails that are present in publicly available sources. If a run yields fewer results than expected, widening keywords and adding more domains (via `customDomains`) is usually the fastest way to improve coverage.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify provides a free tier so you can run Bitbucket email scraping tests before scaling up.

#### Do I need to log in to Bitbucket to use this?

No. The actor extracts emails from publicly available sources and does not require Bitbucket login credentials.

#### How accurate is the data?

The actor extracts email addresses that appear in the captured text context, and it filters accepted emails using your `customDomains`. Accuracy depends on what’s actually published in those public sources.

#### How many results can I get per run?

You can control output size with `maxEmails`, which caps collection once enough unique emails are found. On a free user tier, a limit is applied (up to 100 emails maximum).

#### How often is the data updated / how fresh is it?

Data freshness depends on when you run the actor. Each run extracts the current publicly available information at the time of execution.

#### Is this legal? Does it comply with GDPR / CCPA?

Use responsibly. The actor works with **publicly available data**, but compliance with GDPR, CCPA, and any applicable platform Terms of Service is your responsibility.

#### Can I export results to Google Sheets or Excel?

Yes. You can export the dataset in JSON, CSV, or Excel directly from the Apify dashboard, then import into Google Sheets or your other tools.

#### Can I run this on a schedule automatically?

Yes. You can schedule runs using Apify so the Bitbucket email extractor results refresh automatically on a recurring basis.

#### Can I access this via API?

Yes. You can use the Apify API to trigger runs and fetch dataset results programmatically.

#### What happens if the actor hits an error?

If the run stops early, you still keep the data already pushed to the dataset. Progress is saved so you can resume and continue collecting without starting from zero.

***

### Need Help or Have a Request?

Got a question about Bitbucket Email Scraper - Fast, Advanced and Cheapest or want a new feature added? Reach out at <dataforleads@gmail.com>. Share what you’re trying to scrape (for example, Bitbucket users email finder scenarios), and we’ll help you get the best setup. We’re also open to requests like batch CSV upload and webhook notifications on completion.

***

### Disclaimer & Responsible Use

*Bitbucket Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to extract Bitbucket contact emails at scale — start your free run today.*

The actor collects **publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, applicable laws, and the platform’s Terms of Service. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A list of keywords or queries to search for.

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

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

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

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# 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": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/bitbucket-email-scraper-fast-advanced-and-cheapest").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": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/bitbucket-email-scraper-fast-advanced-and-cheapest").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": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call scraperoka/bitbucket-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bitbucket Email Scraper Fast Advanced And Cheapest",
        "description": "🚀 Bitbucket Email Scraper fast, advanced & cost-effective! Extract emails from Bitbucket profiles and repositories with precision. Perfect for B2B outreach, lead gen, recruiting & market research. ⚡ Save time, boost results!",
        "version": "1.0",
        "x-build-id": "3efCVlHdq67UwtCfh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~bitbucket-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-bitbucket-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~bitbucket-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-bitbucket-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~bitbucket-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-bitbucket-email-scraper-fast-advanced-and-cheapest",
                "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 or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
