# Craigslist Email Scraper (`scraperoka/craigslist-email-scraper`) Actor

📧 Craigslist Email Scraper pulls emails from Craigslist posts fast and efficiently. Great for B2B outreach, lead generation, market research, and recruiting. 🔥 Save time, find targeted contacts, and grow your pipeline!

- **URL**: https://apify.com/scraperoka/craigslist-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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

### Craigslist Email Scraper 🚀

Manually visiting profiles to collect emails wastes hours you don’t have. **Craigslist Email Scraper** is a direct way to automate finding emails from Craigslist bios and posts related to your keywords. This Craigslist Email Scraper (Craigslist email harvester / Craigslist email scraper tool) helps marketers, recruiters, and growth teams build lead lists faster—potentially thousands of records in a single run.

---

### What You Get: Sample Output

Here’s a sample record from a single run:

```json
{
  "network": "Craigslist.com",
  "keyword": "marketing",
  "title": "Marketing Specialist Wanted",
  "description": "Looking for a marketing specialist. Reach out at john.doe@gmail.com for details.",
  "url": "https://example.craigslist.org/some-post-url",
  "email": "john.doe@gmail.com",
  "proxyGroups": [
    "legacy"
  ]
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the data source you scraped (always `Craigslist.com`). |
| `keyword` | string | Which keyword drove this result—useful for filtering and auditing lead quality. |
| `title` | string | The title shown alongside the match, great for context during outreach. |
| `description` | string | The text where the email was found, so you can verify relevance quickly. |
| `url` | string | The original listing URL you can open for manual review. |
| `email` | string | The extracted contact email address you can add to your outreach pipeline. |
| `proxyGroups` | array | The proxy configuration used for the scraping run (helpful for troubleshooting). |
| `status` / `error_message` | not present in output pushed by the actor | The actor pushes data via `Actor.push_data(row, ...)`, and the sample output from code does not include failure-state fields in the pushed row. |

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

***

### Why Craigslist Email Scraper?

There are a lot of ways to pull data from Craigslist — here’s what sets Craigslist Email Scraper apart.

#### Keyword-driven email harvesting

Craigslist Email Scraper uses your `keywords` to find relevant Craigslist bios and posts, then extracts emails from the publicly available text it encounters. If you’re building a Craigslist email list builder or doing automated Craigslist email extraction, keyword choice directly impacts results.

#### Custom domain targeting

You can restrict results with `customDomains` (for example, `@gmail.com`) to focus your Craigslist email mining on the email types you care about. This is especially useful for finding leads from specific providers or excluding irrelevant domains.

#### Output records that are outreach-ready

Each pushed record includes `title`, `description`, `url`, and the extracted `email`, so you can review the context behind each contact. For a Craigslist contact scraper workflow, you get the “why” (description + title) along with the “who” (email).

#### Resilient scraping engine options

Craigslist Email Scraper supports two engines (`cost-effective` and `legacy`) and includes pagination controls like `maxEmails`. If you notice low results, you can re-run with broader terms and more domains—exactly the kind of iteration that works for Craigslist email extraction script use cases.

***

### Configuring Your Run

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

```json
{
  "keywords": ["founder", "marketing"],
  "location": "United States",
  "platform": "Craigslist",
  "customDomains": ["@gmail.com"],
  "maxEmails": 20,
  "engine": "legacy",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for. The scraper uses these keywords to find relevant Craigslist bios and posts. |
| `location` | ⬜ | Location to filter search results (leave empty for broader coverage). |
| `platform` | ⬜ | Choose platform. For this actor, the only option is `Craigslist`. |
| `customDomains` | ⬜ | List of custom email domains to target (for example `@gmail.com`). |
| `maxEmails` | ⬜ | Maximum number of emails to collect. The scraper stops once this limit is reached (higher can take longer and doesn’t guarantee hitting the exact number). |
| `engine` | ⬜ | Choose scraping engine: `cost-effective` (Cost Effective (New)) or `legacy` (Legacy). |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor (you can pass standard Apify proxy settings here). |

***

### Core Capabilities

#### Keyword and location input flexibility

Use `keywords` to drive Craigslist lead generation email discovery based on topics you care about. Add `location` to narrow the results to a specific geographic area when you want more targeted contact lists.

#### Email-domain filtering with customDomains

With `customDomains`, Craigslist Email Scraper keeps only emails that match your selected domains. This is ideal when you want a more predictable dataset for outreach and deliverability checks.

#### Pagination controls via maxEmails

You can cap the run using `maxEmails` to control how long the scraper works and how many emails you collect. This helps you iterate quickly—useful for a Craigslist scraper for emails in test campaigns.

#### Multiple engine options

Craigslist Email Scraper supports `engine` values `cost-effective` and `legacy`, letting you choose between a newer cost-effective approach and a legacy approach. If one setting yields fewer results for your terms, switching engines and broadening keywords is a practical next step.

#### Structured dataset output for analysis

Every extracted lead is pushed with consistent fields: `network`, `keyword`, `title`, `description`, `url`, and `email` (plus `proxyGroups`). That makes Craigslist reseller email scraper workflows and downstream analysis much easier.

Overall, Craigslist Email Scraper turns publicly available Craigslist contact info into a clean dataset you can use immediately.

***

### Who Gets the Most Out of This

Here’s how different teams put Craigslist Email Scraper to work:

**Sales Development Reps** — Use Craigslist email harvesting software to generate prospect lists from relevant Craigslist posts, then prioritize records by matching the keyword and reviewing the `description` context before outreach.

**Marketers & Growth Teams** — Run automated Craigslist email extraction with tightly chosen `keywords` and `customDomains` to build a focused email list for campaigns, partnerships, or reseller outreach.

**Recruiters & Talent Sourcers** — Pull emails from profiles where the bio or post text includes contact details tied to specific roles or industries, then validate relevance using `title` and `url`.

**Freelance Researchers & Data Analysts** — Collect structured records for analysis, such as measuring which keywords and domains yield the most usable contacts, without manually opening each Craigslist listing.

**Automation & Integration Specialists** — Feed output into a pipeline for enrichment and segmentation, since every dataset row includes the original `url` and extracted `email` for traceability.

***

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

No coding needed. Here's how to run Craigslist Email Scraper from start to finish:

1. **Open the actor on Apify** — log in at [console.apify.com](https://console.apify.com) and open Craigslist Email Scraper.
2. **Enter your inputs** — fill in `keywords` (required), then optionally `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — if needed, set up `proxyConfiguration` in your run for more reliable scraping.
4. **Select the engine** — choose `engine` as `legacy` or `cost-effective` based on your preference for reliability vs cost-effective operation.
5. **Hit Run and watch the live log** — monitor progress and any runtime messages while the actor collects emails.
6. **View results in the dataset tab** — each dataset record includes `title`, `description`, `url`, and the extracted `email`.
7. **Export your data** — download as JSON, CSV, or Excel from the Apify dashboard for importing into your CRM.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Craigslist Email Scraper plugs directly into your existing workflow.

You can export results in **JSON, CSV, or Excel** from the Apify dataset tab. This makes it straightforward to use the Craigslist email scraper tool output in spreadsheets, BI tools, and CRM imports.

You can also connect your automation using the Apify platform capabilities, including **API access** (via the Apify API), **webhooks** to trigger downstream actions when a run completes, and no-code automation through **Zapier / Make**. For deep setup details, refer to Apify docs: https://apify.com/docs/api

***

### Pricing & Free Trial

Craigslist Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Free tier includes **$5 platform credits on sign-up**, enough for several test runs, depending on your inputs.

Beyond that, billing is **pay-as-you-go** based on Apify compute units (CU) and Apify subscription plans for heavier usage. You only pay Apify platform compute for the actor run—no per-result markup by the actor itself.

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

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Resilient scraping runs | Uses built-in resilience and fallback behavior during data collection. |
| Proxy support | Includes proxy configuration options for more reliable scraping runs. |
| Result caps | `maxEmails` lets you control how many emails you collect in one run. |
| Structured, traceable records | Each output row includes the `url` and `description` context for validation and QA. |

**Limitations:** This actor collects emails from publicly available data, so it can only return emails that are present in the publicly visible bios/posts it processes. Results depend on your keyword/domain choices—if you see low volume, broaden `keywords` and expand `customDomains` and re-run.

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 with platform credits for trying Craigslist Email Scraper before scaling up.

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

No. The actor is designed to scrape email addresses from publicly available Craigslist bios and posts related to your keywords.

#### How accurate is the data?

Accuracy depends on what’s actually published in the relevant Craigslist bio/post text. Craigslist Email Scraper extracts emails that it finds in the collected text for each result record.

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

You control the cap with `maxEmails`, which stops the run once the maximum number of emails is reached. Keep in mind that setting a higher limit increases potential results but doesn’t guarantee the scraper will reach that number.

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

Data freshness depends on when you run the actor. Each run scrapes the currently available publicly published content and outputs emails into your dataset at run time.

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

You should treat this as a tool for collecting emails from publicly available data. It’s your responsibility to ensure your collection, storage, and outreach comply with GDPR, CCPA, platform Terms of Service, and any applicable local regulations.

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

Yes. You can export your Apify dataset as JSON, CSV, or Excel from the Apify dashboard, and then import into Google Sheets or your spreadsheet workflow.

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

Yes. Apify supports scheduled runs, so you can automate recurring executions of Craigslist email harvesting for ongoing lead generation.

#### Can I access this via API?

Yes. You can pull results programmatically using the Apify API. See: https://apify.com/docs/api

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

If scraping encounters issues, the actor will continue working based on its internal resilience behavior, writing successful results to the dataset as it goes. If you need more consistent output, try adjusting `engine`, expanding `keywords`, or reviewing proxy configuration.

***

### Need Help or Have a Request?

Got a question about Craigslist Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We respond quickly and actively maintain the actor based on user feedback.

If you want ideas like batch CSV upload for keywords or a webhook on completion, tell us what workflow you’re aiming for.

***

### Disclaimer & Responsible Use

*Craigslist Email Scraper is the fastest, most reliable way to build email lead lists from Craigslist bios and posts—start your free run today.*

This actor collects **publicly available data** and does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform Terms of Service, and any applicable local regulations when using the scraped 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.

## `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`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "Craigslist",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy"
}
```

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/craigslist-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"],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/craigslist-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"
  ]
}' |
apify call scraperoka/craigslist-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Craigslist Email Scraper",
        "description": "📧 Craigslist Email Scraper pulls emails from Craigslist posts fast and efficiently. Great for B2B outreach, lead generation, market research, and recruiting. 🔥 Save time, find targeted contacts, and grow your pipeline!",
        "version": "0.0",
        "x-build-id": "TkVk3mSjJOCpjxG5t"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~craigslist-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-craigslist-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~craigslist-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-craigslist-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~craigslist-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-craigslist-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": [
                            "Craigslist"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Craigslist"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.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
                    },
                    "engine": {
                        "title": "Engine",
                        "enum": [
                            "cost-effective",
                            "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": "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
