# Tumblr Lead Scraper (`scrapemesh/tumblr-lead-scraper`) Actor

🔎 Tumblr Lead Scraper extracts high-intent leads from Tumblr profiles and posts—capturing names, bios, links, and key details. 📈 Perfect for B2B lead gen, marketing research & outreach. 🚀 Fast, reliable, SEO-ready data.

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

## Pricing

from $3.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

### **Tumblr** Lead Scraper 📱

**Tumblr** Lead Scraper allows users to **extract** valuable **contact** information from **Tumblr** profiles and posts. This includes lead addresses, usernames, profile links, and other relevant **data**.

The tool is designed to simplify the process of finding and organizing user **leads** for outreach campaigns. By using the **Tumblr** lead **extract**ion tool, users can gather **data** efficiently without manual effort.

The **extract**ed **data** is structured and ready for use in marketing, networking, or research purposes. Whether you need to scrape **leads** from **Tumblr** profiles or posts, this software ensures high accuracy and compliance with legal standards.

Tumblr Lead Scraper is a powerful tool designed to extract lead addresses from Tumblr profiles and posts efficiently. This automated Tumblr lead scraper simplifies the process of gathering contact information for marketing or outreach purposes.

With the best Tumblr scraper for leads, users can save time and effort by automating the tedious task of manual lead collection. The Tumblr lead extraction tool ensures accuracy and speed while adhering to legal guidelines.

Using Tumblr lead harvesting software, businesses and individuals can connect with Tumblr users in a targeted and meaningful way. The tool is ideal for extracting Tumblr user leads to enhance communication strategies.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Lead: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Lead addresses | Extract verified lead addresses from Tumblr profiles and posts. |
| Usernames | Collect Tumblr usernames associated with the extracted leads. |
| Profile links | Retrieve direct links to Tumblr profiles for further exploration. |
| Post links | Extract URLs of posts containing lead addresses or contact information. |
| Account activity | Identify active accounts based on recent posts or interactions. |
| Follower count | Gather follower statistics to assess user influence. |
| Bio details | Extract public bio information from Tumblr profiles. |
| Tags used | Collect tags associated with posts to understand content themes. |

### Key Features of **Tumblr** Lead Scraper

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

- ⭐ **Automated** **Tumblr** lead scraping for quick and accurate data extraction
- ⭐ User-friendly interface for seamless operation and minimal learning curve
- ⭐ Supports bulk lead extraction from multiple **Tumblr** profiles and posts
- ⭐ Provides structured data output for easy integration with other tools
- ⭐ **Advanced** filtering options to target specific profiles or posts
- ⭐ Ensures compliance with legal and ethical guidelines during data collection
- ⭐ **High**-speed performance for handling large-scale scraping tasks efficiently
- ⭐ **Customizable** settings to tailor the scraping process to individual needs
- ⭐ Real-time data updates to ensure the most accurate and relevant results
- ⭐ **Secure** data handling to protect user privacy and extracted information

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

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

1. ✅ Download and install the **Tumblr** Lead Scraper software on your device
2. ✅ Open the tool and **log in** with your credentials or create a new account
3. ✅ Enter the **Tumblr** profile URLs or keywords you want to scrape leads from
4. ✅ Adjust the settings to specify the type of data you want to extract
5. ✅ Click on the **Start** Scraping button to initiate the data extraction process
6. ✅ Monitor the progress through the tools dashboard or activity log
7. ✅ Once the scraping is complete review the extracted data in the results section
8. ✅ **Export** the data to your preferred format such as CSV or Excel for further use
9. ✅ Use the filtering options to refine the extracted data based on your criteria
10. ✅ Repeat the process for additional profiles or posts as needed

### Use Cases 🎯

Marketing Campaigns
🎯 **Use** the **Tumblr** lead extraction tool to gather contacts for targeted lead marketing
🎯 Enhance outreach efforts by identifying active **Tumblr** users with relevant interests

Networking Opportunities
🎯 Extract **Tumblr** user leads to build connections with influencers and collaborators
🎯 **Find** contact information of professionals in your industry using the **Tumblr** contact scraper

Research Purposes
🎯 Scrape leads from **Tumblr** profiles to study user demographics and behaviors
🎯 **Collect** data for academic or business research projects using automated **Tumblr** lead scraper

Content Promotion
🎯 **Identify** **Tumblr** users interested in your content and reach out via lead
🎯 **Use** the **Tumblr** lead harvesting software to promote products or services effectively

### Why choose us? 💎

**Tumblr** Lead Scraper stands out as the **best** **Tumblr** scraper for leads due to its efficiency and reliability. Our tool is designed to simplify the process of extracting **Tumblr** user leads while maintaining high accuracy.

With **advanced** filtering options, users can target specific profiles or posts relevant to their needs. The **Tumblr** lead extraction tool provides structured data output, making it easy to integrate with other applications.

Our automated **Tumblr** lead scraper ensures compliance with legal and ethical standards, prioritizing user privacy and data security. Whether you need to scrape leads from **Tumblr** for marketing, networking, or research purposes, our software offers unparalleled performance.

The intuitive interface and customizable settings make it accessible to users of all experience levels. Choose **Tumblr** Lead Scraper for a seamless and effective lead extraction experience tailored to your goals.

### **Tumblr** Lead Scraper Scalability 📈

**Tumblr** Lead Scraper is designed to handle **large-scale** data extraction tasks with ease. Whether you need to scrape hundreds or thousands of **Tumblr** profiles, our tool ensures consistent performance and accuracy.

The software supports bulk lead extraction, allowing users to gather vast amounts of data in a short timeframe. Advanced features like real-time updates and **customizable** settings enable users to adapt the tool to their specific requirements.

Our **Tumblr** lead harvesting software is built to scale, making it suitable for businesses and individuals alike. With high-speed processing and secure data handling, the **Tumblr** lead scraping service is perfect for projects of any size.

### **Tumblr** Lead Scraper Legal Guidelines ⚖️

**Yes**—scraping **Tumblr** is **legal** as long as you follow **ethical** and **compliant** practices. The **Tumblr** Lead Scraper extracts only **publicly available** information from **public** **Tumblr** profiles, making it **safe** and **compliant** for **research**, **marketing**, and **analysis**.

#### Legal & Ethical Guidelines
⚖️ Always obtain consent from users before using their lead addresses for marketing purposes
⚖️ **Ensure** compliance with data protection laws such as GDPR or CCPA when scraping leads
⚖️ **Do not** use the **Tumblr** lead extraction tool to collect sensitive or private information
⚖️ **Avoid** scraping data from profiles or posts that explicitly prohibit data collection
⚖️ **Use** the **Tumblr** lead harvesting software responsibly and ethically at all times
⚖️ Regularly review legal guidelines to ensure your scraping activities remain compliant

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

### Input Table

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

### Output Format 📤

📝 Example Output (JSON)

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

### Output Table

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

### FAQ ❓

#### What is Tumblr **Lead Scraper**?

Tumblr Lead Scraper is a tool designed to extract lead addresses and other contact information from Tumblr profiles and posts.

#### How does the Tumblr lead **extract**ion tool work?

The tool automates the process of scanning Tumblr profiles and posts to identify and extract lead addresses.

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

**Yes**, it is legal to use as long as you comply with data protection laws and obtain user consent where required.

#### Can I scrape leads from multiple Tumblr profiles at once?

**Yes**, the tool supports bulk lead extraction from multiple profiles and posts.

#### What data can I **extract** using the Tumblr contact scraper?

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

#### Is the Tumblr lead harvesting software easy to use?

**Yes**, it features a **user-friendly** interface and customizable settings for **seamless** operation.

#### Does the tool provide real-time data updates?

**Yes**, the Tumblr Lead Scraper ensures real-time updates for accurate and relevant results.

#### Can I **export** the **extract**ed data?

**Yes**, you can export the data in formats like **CSV** or Excel for further use.

#### Is the Tumblr lead scraping service **secure**?

**Yes**, the tool prioritizes data security and user privacy during the extraction process.

#### What are the system requirements for using the tool?

The Tumblr Lead Scraper is compatible with most modern operating systems and requires an internet connection.

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

**Yes**, the tool is ideal for collecting data for academic or business research projects.

#### How accurate is the Tumblr lead finder online?

The tool is highly accurate and uses advanced algorithms to ensure reliable data extraction.

#### What support options are available for users?

We offer comprehensive customer support to assist users with any issues or questions.

# Actor input Schema

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

List of keywords to search for on Tumblr (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Tumblr 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": "Tumblr",
  "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("scrapemesh/tumblr-lead-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemesh/tumblr-lead-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapemesh/tumblr-lead-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tumblr Lead Scraper",
        "description": "🔎 Tumblr Lead Scraper extracts high-intent leads from Tumblr profiles and posts—capturing names, bios, links, and key details. 📈 Perfect for B2B lead gen, marketing research & outreach. 🚀 Fast, reliable, SEO-ready data.",
        "version": "0.1",
        "x-build-id": "vC23nToptKW1vX7uV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemesh~tumblr-lead-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemesh-tumblr-lead-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapemesh~tumblr-lead-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapemesh-tumblr-lead-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapemesh~tumblr-lead-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemesh-tumblr-lead-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "List of keywords to search for on Tumblr (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Tumblr profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Tumblr"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Tumblr"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```