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

📧 Craigslist Email Scraper extracts verified email addresses from Craigslist listings fast and accurately. 🚀 Perfect for lead gen, research, and outreach—save time, reduce manual work, and stay organized. 🔎 Get started today!

- **URL**: https://apify.com/scrapepilotapi/craigslist-email-scraper.md
- **Developed by:** [ScrapePilot](https://apify.com/scrapepilotapi) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 1 total users, 0 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

### **Craigslist** Email Scraper 📱

**Craigslist** Email Scraper enables users to **extract** critical **contact** information from **Craigslist** ads. This includes email addresses, phone numbers, and other relevant details.

The tool is designed to provide accurate and organized **data** for lead generation and outreach purposes. Users can **extract** **data** from multiple categories, such as housing, services, and job postings.

By automating the **data** **extract**ion process, the scraper ensures efficiency and scalability. It is suitable for businesses, marketers, and researchers looking to gather **contact** information quickly and effectively.

Craigslist Email Scraper is a powerful tool designed to extract contact information from Craigslist ads efficiently. It simplifies the process of gathering leads for businesses and individuals.

With Craigslist Email Scraper, users can automate the extraction of email addresses from various categories on Craigslist. This saves time and ensures accurate data collection.

Craigslist data extraction tools like this scraper are essential for lead generation and market research. They help users access valuable contact details without manual effort.

### Support and feedback

- **Bug reports**: Open a ticket in the repository Issues section
- **Custom features**: Contact our enterprise support team
  *Email: scrapier.io@gmail.com *
### Extractable Data Table 📊
| Data Type | Description |
| --- | --- |
| Email addresses | Extract email addresses from Craigslist ads for direct communication. |
| Phone numbers | Retrieve phone numbers listed in ads for outreach purposes. |
| Ad titles | Capture the titles of Craigslist ads for context and categorization. |
| Ad descriptions | Extract detailed descriptions from ads for better understanding of the content. |
| Category information | Identify the category of each ad for organized data segmentation. |
| Location details | Gather location-specific information from ads to target specific areas. |
| Posting dates | Extract the dates when ads were posted for timeline analysis. |
| URLs of ads | Retrieve direct links to Craigslist ads for easy access and reference. |

### Key Features of **Craigslist** Email Scraper

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

- ⭐ **Automated** extraction of email addresses from **Craigslist** ads
- ⭐ Ability to scrape multiple categories such as housing jobs and services
- ⭐ User-friendly interface for seamless operation and data management
- ⭐ **Customizable** filters to target specific keywords or locations
- ⭐ **High** accuracy in extracting contact details and ad information
- ⭐ Scalable functionality for handling large volumes of data efficiently
- ⭐ **Secure** data extraction process to ensure privacy and compliance
- ⭐ **Integration** options with CRM systems for streamlined lead management
- ⭐ Real-time data scraping for up-to-date information
- ⭐ Detailed reporting and export options in various formats
- ⭐ Support for multiple languages and regions on **Craigslist**
- ⭐ **Regular** updates to ensure compatibility with **Craigslist**s platform

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

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

1. ✅ **Sign up** for the **Craigslist** Email Scraper service and **log in** to your account
2. ✅ Choose the category or categories you want to scrape on **Craigslist**
3. ✅ Set filters for keywords locations or other criteria to narrow your search
4. ✅ **Start** the scraping process by clicking the Run button in the dashboard
5. ✅ Monitor the progress of the scraper in real-time through the interface
6. ✅ Once the scraping is complete review the extracted data in the results section
7. ✅ **Export** the data to your preferred format such as CSV or Excel files
8. ✅ **Integrate** the extracted data into your CRM or marketing tools for further use
9. ✅ Repeat the process for additional categories or updated data as needed
10. ✅ Adjust settings or filters to refine the scraping process for better results
11. ✅ Contact support if you encounter any issues or require customization
12. ✅ Use the scraper responsibly adhering to **Craigslist**s terms of service

### Use Cases 🎯

Lead Generation
🎯 Extract contact information from **Craigslist** ads to build a customer database
🎯 Target specific categories like housing or services for relevant leads

Market Research
🎯 **Analyze** ad descriptions and posting trends for market insights
🎯 Gather data from various locations to understand regional demand

Business Outreach
🎯 **Use** extracted emails to contact potential clients or partners
🎯 **Automate** outreach campaigns with accurate contact details

Recruitment
🎯 **Find** candidates by scraping job postings for contact information
🎯 Streamline hiring processes with organized data from **Craigslist** ads

Real Estate Analysis
🎯 Extract housing ad details to track property availability and pricing
🎯 **Identify** trends in specific locations for investment opportunities

Service Promotion
🎯 Reach out to service providers listed on **Craigslist** for collaborations
🎯 Promote your services to targeted audiences using extracted data

### Why choose us? 💎

**Craigslist** Email Scraper stands out as the **best** **Craigslist** scraper software for its exceptional features and reliability. It offers a seamless user experience, allowing users to extract emails and other contact details with ease.

Our tool is designed for scalability, making it suitable for small businesses and large enterprises alike. We prioritize accuracy and efficiency, ensuring that users get the most relevant data without manual effort.

With customizable filters and real-time scraping capabilities, our software adapts to diverse needs and preferences. We also provide excellent customer support to assist users in maximizing their results.

By choosing our **Craigslist** email harvesting tool, you gain access to a secure and compliant data extraction service. Our **regular** updates ensure compatibility with **Craigslist**'s platform, keeping your operations uninterrupted.

Whether you're looking for lead generation, market research, or outreach solutions, our tool delivers unmatched performance. Trust us to provide the **best** **Craigslist** email extraction service tailored to your goals.

### **Craigslist** Email Scraper Scalability 📈

**Craigslist** Email Scraper is designed to handle data extraction tasks of any scale. Whether you're a small business or a large enterprise, our tool adapts to your needs **seamless**ly.

It supports scraping across multiple categories and locations, making it versatile for diverse applications. The software ensures high-speed data extraction, even when processing large volumes of ads.

With robust infrastructure, users can rely on consistent performance regardless of workload. Our tool also offers **customizable** options to refine data collection for specific requirements.

As your business grows, **Craigslist** scraping automation can scale alongside your operations. This makes it an ideal solution for expanding lead generation and market research efforts.

By leveraging our **Craigslist** data extraction tool, you can achieve scalability without compromising accuracy or efficiency.

### **Craigslist** Email Scraper Legal Guidelines ⚖️

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

#### Legal & Ethical Guidelines
⚖️ **Ensure** compliance with **Craigslist**s terms of service when using the scraper
⚖️ **Do not** use the tool for unauthorized or unethical purposes
⚖️ **Avoid** scraping personal information that is not publicly available
⚖️ Respect user privacy and adhere to data protection regulations
⚖️ **Use** the extracted data responsibly for legitimate business purposes
⚖️ Refrain from sharing or selling extracted data without proper authorization
⚖️ Monitor changes in **Craigslist**s policies to maintain compliance
⚖️ Consult legal professionals if unsure about the ethical use of the scraper

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

### Input Table

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

### Output Format 📤

📝 Example Output (JSON)

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

### Output Table

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

### FAQ ❓

#### What is Craigslist **Email Scraper**?

Craigslist Email Scraper is a tool designed to extract email addresses and other contact information from Craigslist ads efficiently.

#### How does the scraper work?

The scraper automates the process of scanning Craigslist ads to extract relevant data based on user-defined filters.

#### Is the tool easy to use?

**Yes**, Craigslist Email Scraper features a **user-friendly** interface for **seamless** operation.

#### Can I scrape multiple categories?

**Yes**, the tool allows users to scrape data from various categories such as housing, jobs, and services.

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

The scraper is designed to provide high accuracy in extracting contact details and ad information.

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

**Yes**, users can export the extracted data in formats like **CSV** or Excel files.

#### Is the tool scalable?

Craigslist Email Scraper is built to handle data extraction tasks of any scale, making it suitable for **businesses** of all sizes.

#### Does the scraper comply with Craigslist's policies?

Users are advised to ensure **compliance** with Craigslist's terms of service when using the tool.

#### Can I customize the scraping process?

**Yes**, the tool offers customizable filters for targeted data collection.

#### Is **customer support** available?

**Yes**, we provide excellent customer support to assist users with any issues or questions.

#### What are the use cases for this tool?

Craigslist Email Scraper is ideal for lead generation, market research, business outreach, recruitment, and more.

#### Does the tool support multiple languages?

**Yes**, the scraper supports multiple languages and regions on Craigslist.

#### How often is the tool updated?

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

#### Is the data **extract**ion process **secure**?

**Yes**, the scraper ensures a **secure** data extraction process to protect user privacy.

#### Can I integrate the tool with my **CRM**?

**Yes**, the tool offers integration options with CRM systems for streamlined lead management.

# Actor input Schema

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

List of keywords to search for on Craigslist (e.g., \['marketing', 'founder', 'business']). The actor will search Google for Craigslist 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": "Craigslist",
  "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("scrapepilotapi/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": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilotapi/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": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapepilotapi/craigslist-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapepilotapi/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 extracts verified email addresses from Craigslist listings fast and accurately. 🚀 Perfect for lead gen, research, and outreach—save time, reduce manual work, and stay organized. 🔎 Get started today!",
        "version": "0.1",
        "x-build-id": "OwNuO0a9uDG2JNtff"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilotapi~craigslist-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilotapi-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/scrapepilotapi~craigslist-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilotapi-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/scrapepilotapi~craigslist-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilotapi-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": "List of keywords to search for on Craigslist (e.g., ['marketing', 'founder', 'business']). The actor will search Google for Craigslist profiles/posts containing these keywords and extract email addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "Craigslist"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "Craigslist"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```