# All Social Media Email Scraper (`scraperoka/all-social-media-email-scraper`) Actor

📧📲 All Social Media Email Scraper extracts emails from popular social platforms with speed & accuracy. 🚀 Perfect for lead generation, sales outreach, and B2B research. Save time, find prospects fast, and grow your pipeline confidently.

- **URL**: https://apify.com/scraperoka/all-social-media-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (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 $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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### All-in-One Social Media Email Scraper 🎯

Manually tracking down contact emails across social profiles wastes hours you don’t have. **All-in-One Social Media Email Scraper** quickly extracts emails from public social media profiles using your keywords and email-domain filters. It’s an **all in one social media email scraper** built for marketers, recruiters, and growth teams who need **email finder from social profiles** results fast—often thousands of contacts in minutes.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "platform": "Instagram",
  "site": "instagram.com",
  "keyword": "founder",
  "title": "Founder • Marketing",
  "description": "Contact: hello@companymail.com • DMs open",
  "url": "https://www.instagram.com/exampleprofile/",
  "email": "hello@companymail.com",
  "proxyGroups": ["RESIDENTIAL"]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `platform` | string | The selected social media platform you searched (for example, Instagram). |
| `site` | string | The underlying website domain mapped from the chosen `platform`. |
| `keyword` | string | The keyword used to guide which public results were scanned. |
| `title` | string | The title text associated with the public source where the email was found. |
| `description` | string | The snippet text that contained the email (useful for verification context). |
| `url` | string | The public link related to that record so you can trace back the source. |
| `email` | string | The extracted email address that matched your email-domain filters. |
| `proxyGroups` | array | Proxy configuration info used during the run (useful for auditing and debugging). |

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

***

### Why All-in-One Social Media Email Scraper?

There are a lot of ways to pull email data from social platforms — here’s what sets **All-in-One Social Media Email Scraper** apart (including use cases like a social media email extractor or lead generation email scraper).

#### Keyword and domain targeting that stays practical

You provide `keywords` and `customDomains` (email-domain filters), so the results are aligned to what you’re trying to sell, hire, or research—not just random matches. This makes it easier to run a bulk email scraping software workflow without drowning in irrelevant contacts.

#### Output that’s structured for outreach and analysis

Each record includes `platform`, `keyword`, the source `url`, and the extracted `email`, plus the `description` where the email appeared. That combination is ideal for turning results into a contact list or running downstream analysis for b2b prospecting email scraper workflows.

#### Resilient runs with incremental saving

The actor saves progress during execution so you can resume if a run stops early. It also includes logic to control runtime via pagination limits and a maximum email cap—helping you keep your campaign or research pipeline on schedule.

#### Built-in proxy support for reliable scraping

You can use the actor’s proxy configuration to improve scraping reliability for larger searches. This is useful when you’re running an email scraper for social media across many keyword-domain pairs.

***

### Configuring Your Run

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

```json
{
  "keywords": ["founder", "marketing"],
  "location": "Berlin",
  "platform": "Instagram",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for. These guide which public sources are scanned for contact emails. |
| `location` | ⬜ | Location to filter search results. Leave empty for broader coverage. |
| `platform` | ⬜ | Select the social media platform to scrape (for example, Instagram, LinkedIn, Facebook, Twitter/X). |
| `customDomains` | ⬜ | List of custom email domains to match (for example `@gmail.com`, `@yahoo.com`). |
| `maxEmails` | ⬜ | Maximum number of emails to collect. The scraper stops when this limit is reached (helps control runtime/cost). |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor. |

↳ `proxyConfiguration` supports proxy setup via Apify’s proxy configuration editor.

***

### Core Capabilities

#### Email extraction from publicly available social sources

**All-in-One Social Media Email Scraper** finds emails from social media profiles, bios, and posts related to your provided `keywords`. It’s built for contact email extraction tool use cases like social media contact scraper workflows.

#### Flexible targeting with keywords, platform, and location

You can narrow results using `platform`, `keywords`, and optional `location`. This is especially helpful for scenarios like instagram email scraper runs, linkedin email scraper targeting, or a twitter x email scraper style lead hunt.

#### Email-domain filtering for cleaner lists

Use `customDomains` to restrict results to the email domains you care about. That makes the output more aligned to a lead generation email scraper strategy and reduces cleanup work.

#### Resilient, resume-friendly scraping

The actor tracks progress and saves a cursor so you can resume from where it left off. This supports long-running research jobs and reduces frustration when you’re scraping in bulk.

#### Output records pushed incrementally to your dataset

As results are found, each extracted email record is pushed to the dataset immediately. This means you can inspect partial results early and export when you’re ready.

***

### Who Gets the Most Out of This

**Sales Development Representatives**\
You can use **All-in-One Social Media Email Scraper** to build a targeted email list for outreach by combining keywords with email-domain filters, then export the results for your CRM workflow. The outcome is a contact dataset that’s ready for b2b prospecting email scraper style campaigns.

**Recruiters and Talent Sourcers**\
If candidates mention roles, specialties, or company themes in bios and posts, keyword-based runs can surface contact emails that match your preferred domains. That turns social media email extractor research into faster shortlists.

**Growth and Community Marketers**\
You can use it to find contact emails tied to creators or brands based on what they publish, making an efficient email finder from social profiles for partnerships and collaborations. Run different keyword groups to compare opportunities across platforms.

**Data Analysts and Researchers**\
Because every record includes `platform`, `keyword`, the source `url`, and the email-domain-filtered `email`, you can analyze patterns in where certain types of contacts publish. It’s a practical bulk email scraping software input for structured studies.

**Automation Specialists (Developers and Ops Teams)**\
If you’re building pipelines, the actor’s dataset output makes it straightforward to feed downstream processes. You can treat **All-in-One Social Media Email Scraper** as a repeatable step in scheduled runs and automated contact enrichment.

***

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

No coding needed. Here's how to run **All-in-One Social Media Email Scraper** from start to finish:

1. **Open the actor on Apify** — visit [console.apify.com](https://console.apify.com) and open the actor page.
2. **Enter your inputs** — set `keywords` (required), optionally `platform`, `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — use `proxyConfiguration` if you want proxy support for more reliable scraping.
4. **Hit Run and watch the live log** — review progress as results are collected.
5. **View results in the dataset tab** — extracted records appear in your Apify dataset as they’re pushed.
6. **Export as JSON, CSV, or Excel** — download your dataset in the format that fits your workflow.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **All-in-One Social Media Email Scraper** plugs directly into your existing workflow. You can export your dataset in JSON, CSV, or Excel from the Apify dataset tab.

For operational automation, you can connect the run to your tools using Apify’s native integrations or automation services like Zapier/Make, and you can pull results programmatically using the Apify API. For more details on options, see the Apify documentation: <https://apify.com/docs/api>.

***

### Pricing & Free Trial

**All-in-One Social Media Email Scraper** runs on the Apify platform, which offers a **free tier** — no credit card required to get started. A free tier with platform credits is typically enough for several test runs so you can validate your keyword and email-domain filters.

For production, you generally pay for Apify platform compute (CU) as you run the actor, which is designed to scale based on your workload. For the latest details on credits and billing, check the Apify pricing page.

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

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Runtime control | Uses pagination limits and your `maxEmails` cap to help stop when enough results are collected. |
| Scraping reliability | Proxy support can be configured to improve stability during larger runs. |
| Long job recovery | Progress is saved so you can resume rather than start over. |
| Data freshness | The actor scrapes live publicly available data during the run. |
| Error handling | Failed attempts are handled with run logic to keep going where possible. |
| Scale workflows | Iterates across your `keywords` × `customDomains` combination for broader coverage. |

Limitations: The actor only works with **publicly available data** that appears on the chosen platform during the run. If emails aren’t present in public bios/posts for your keywords and domains, the dataset may include fewer records than expected.

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

***

### Frequently Asked Questions

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

Yes. Apify offers a free tier that you can use to test **All-in-One Social Media Email Scraper** before running larger jobs. The exact allowance is defined by Apify, so check the current Apify plan details on their pricing page.

#### Do I need to log in to use this on social media platforms?

No. This actor is designed to work with publicly available content. You don’t need to provide credentials or log in for the run.

#### How accurate is the data?

Accuracy depends on what the account owner has published publicly. The actor extracts emails that match your `customDomains` filters, and each record includes the source `url` and `description` snippet to help you verify results.

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

You control the maximum number of emails using `maxEmails`. The actor will stop once the limit is reached, but it may collect fewer emails if public sources don’t contain matching emails.

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

Data freshness matches the time you run the actor. Each execution scrapes publicly available sources during that run, so repeated runs produce updated results.

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

The actor only accesses **publicly available data**. You are responsible for complying with applicable laws and the platform terms when collecting, storing, and using contact information (including GDPR/CCPA and relevant anti-spam rules).

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

Yes. You can export the dataset as JSON, CSV, or Excel from the Apify dashboard. If you want to move data into Google Sheets or other tools, you can use Apify exports/integrations and the API for automation.

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

Yes. You can schedule actor runs on Apify using their platform scheduling features, which is ideal for ongoing lead generation email scraper workflows.

#### Can I access this via API?

Yes. Apify supports API-based workflows so you can trigger runs and fetch results programmatically. Refer to the Apify API documentation for the most up-to-date details: <https://apify.com/docs/api>.

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

The actor saves progress during execution, which helps with partial recovery and resuming. If a run fails, you can review logs and re-run with the same inputs to continue without losing already-pushed dataset records.

***

### Need Help or Have a Request?

Got a question about **All-in-One Social Media Email Scraper** or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like webhook notifications on completion or bulk export enhancements. The actor is actively maintained based on user feedback.

***

### Disclaimer & Responsible Use

*All-in-One Social Media Email Scraper is the fastest, most reliable way to extract email contacts from public social profiles — start your free run today.*

The actor accesses **publicly available data**. It does not access private accounts, login-gated content, or password-protected pages. You’re responsible for complying with GDPR, CCPA, platform ToS, and any applicable laws when collecting and using the data. 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 to search for.

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

Location to filter search results.

## `platform` (type: `string`):

Select platform.

## `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.

## `proxyConfiguration` (type: `object`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "Instagram",
  "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": [
        "founder",
        "marketing"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/all-social-media-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": [
        "founder",
        "marketing",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "All Social Media Email Scraper",
        "description": "📧📲 All Social Media Email Scraper extracts emails from popular social platforms with speed & accuracy. 🚀 Perfect for lead generation, sales outreach, and B2B research. Save time, find prospects fast, and grow your pipeline confidently.",
        "version": "0.2",
        "x-build-id": "d9pAWqqNiBUdnzIYy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~all-social-media-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-all-social-media-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/scraperoka~all-social-media-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-all-social-media-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/scraperoka~all-social-media-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-all-social-media-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": "A list of keywords to search for.",
                        "default": [
                            "founder",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Facebook",
                            "YouTube",
                            "Instagram",
                            "TikTok",
                            "Telegram",
                            "Snapchat",
                            "LinkedIn",
                            "Twitter/X",
                            "Pinterest",
                            "Reddit",
                            "Spotify",
                            "Douyin",
                            "Amazon",
                            "Alibaba",
                            "Twitch",
                            "Quora",
                            "Medium",
                            "Tripadvisor",
                            "Yelp",
                            "AliExpress",
                            "eBay",
                            "Etsy",
                            "Vimeo",
                            "Github",
                            "SoundCloud",
                            "Goodreads",
                            "Tumblr",
                            "Eventbrite",
                            "Meetup",
                            "Stack Overflow",
                            "Flickr",
                            "DeviantArt",
                            "Patreon",
                            "Kickstarter",
                            "Threads",
                            "Behance",
                            "Dribbble",
                            "Bluesky",
                            "Mastodon",
                            "Last.fm"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Instagram"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "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
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
