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

📧 Craigslist Email Scraper extracts verified emails from postings with smart filtering by location/keywords. Save time on lead gen and outreach for real estate, recruitment, and agencies. ⚡ Fast, targeted, and easy to use. ✅

- **URL**: https://apify.com/solid-scraper/craigslist-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Real estate, 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

### Craigslist Email Scraper 📬

**Craigslist Email Scraper** is an Actor that scrapes email addresses from publicly available Craigslist profiles using your chosen keywords and email-domain filters. If you’re looking for a **Craigslist email scraper tool** for **Craigslist leads email scraper** workflows, this automated Craigslist email harvesting setup helps you find relevant contact emails at scale—saving you hours of manual searching and list building.

Whether you’re a marketer, recruiter, researcher, or data analyst, you can use **Craigslist email harvesting** with keyword targeting and custom domains (for example, restricting to `@gmail.com`) so you only collect the emails you care about.

---

### Why choose Craigslist Email Scraper?

| Feature | Benefit |
|---|---|
| ✅ **Keyword-based email discovery** | Uses your keywords to find emails mentioned in Craigslist bios and posts related to your searches |
| ✅ **Custom email-domain targeting** | Collects only emails matching your configured domains to improve lead relevance |
| ✅ **Reliability with fallback logic** | Built to handle blocks and empty-result pages using resilience strategies during pagination |
| ✅ **Structured dataset output** | Pushes consistent records including `network`, `keyword`, `title`, `description`, `url`, `email`, and `proxyGroups` |
| ✅ **Scales with limits you control** | Stops when your `maxEmails` limit is reached to manage runtime and scraping cost |
| ✅ **Proxy configuration support** | Works with Apify proxy configuration (via the `proxyConfiguration` input) to improve scraping stability |

---

### Key features

- 🔍 **Accurate Email Extraction**: Extracts emails from Craigslist bios and related posts based on your selected keywords and custom domains  
- 🎯 **Targeted Lead Quality Controls**: Lets you restrict results to specific email domains (like `@gmail.com`)  
- 🧠 **Keyword Flexibility**: Supports a list of keywords so you can run broader or more specific **Craigslist contact email scraper** campaigns  
- 🛡️ **Resilient Scraping Engine Options**: Choose between `cost-effective` and `legacy` engines for different tradeoffs in speed and reliability  
- 🔄 **Resilience Across Pagination**: Includes logic to handle empty results and blocked pages so scraping can keep going when possible  
- 💾 **Real-Time Data Saving**: Each discovered email is pushed as a separate dataset row immediately  
- 📊 **Transparent Progress Persistence**: Tracks cursor state and already seen emails so progress is saved during the run  
- 🤖 **Automation-ready Output**: Produces dataset rows you can export to JSON/CSV and plug into CRMs, spreadsheets, or analysis pipelines (common for **Craigslist poster email scraper** and **Craigslist business email scraper** style projects)

---

### Input

Provide input via an `input.json` file. Example structure:

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

#### Input Fields

| Key | Required | Description |
|---|---:|---|
| `keywords` | ✅ Yes | A list of keywords to search for. The scraper uses these keywords to find relevant Craigslist bios and posts, then extracts emails from the matching content. |
| `location` | ❌ No | Location to filter search results. Leave it empty for no location filtering. |
| `platform` | ❌ No | Select platform. The only supported value is `Craigslist` (default: `Craigslist`). |
| `customDomains` | ❌ No | List of custom email domains to target. Use values like `@gmail.com` to focus on specific providers and improve lead fit. |
| `maxEmails` | ❌ No | Maximum number of emails to collect. The scraper stops once this limit is reached. Higher values may take longer and do not guarantee hitting the exact number. |
| `engine` | ❌ No | Choose scraping engine: `cost-effective` (Cost Effective (New)) or `legacy` (Legacy). Default is `legacy`. |
| `proxyConfiguration` | ❌ No | Configure proxies for this Actor. Use Apify proxy settings here when you need stronger reliability for large runs. |

***

### Output

The actor pushes a dataset row for every email it finds (with structured fields for keyword, source context, and the extracted email).

```json
[
  {
    "network": "Craigslist.com",
    "keyword": "founder",
    "title": "No title",
    "description": "No data",
    "url": "https://example.com/listing-or-result-url",
    "email": "john.doe@gmail.com",
    "proxyGroups": ["GOOGLE_SERP"]
  }
]
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `network` | string | The source network name. In this actor it is always set to `Craigslist.com`. |
| `keyword` | string | The keyword currently being searched. |
| `title` | string | The title extracted from the result (fallback can be `No title`). |
| `description` | string | The text description associated with the result where the email was extracted from (fallback can be `No data`). |
| `url` | string | The URL associated with the search result item (may be missing in some cases; fallback is `No URL` in legacy mode). |
| `email` | string | The extracted email address. |
| `proxyGroups` | array | The proxy group(s) used for that extraction batch. |

Export note: Apify automatically lets you export dataset results (commonly to JSON or CSV) from the actor’s OUTPUT tab.

***

### How to use Craigslist Email Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at [console.apify.com](https://console.apify.com) and open the **Actors** page.

2. **Find the actor**\
   Search for **Craigslist Email Scraper** and open its actor page.

3. **Add your input**\
   Go to the **INPUT** section and fill in the fields using the built-in form (or paste an `input.json`).

   Make sure you at least provide `keywords` (required). Optionally add `customDomains` to target providers like `@gmail.com`.

4. **Configure proxy settings (recommended for larger runs)**\
   If you’re running **Craigslist leads email scraper** campaigns at scale, use the **Proxy configuration** input to improve reliability.

5. **Choose engine (if needed)**\
   Use `engine` to switch between `cost-effective` (Cost Effective (New)) and `legacy` (Legacy). Default is `legacy`.

6. **Run the actor**\
   Click **Run**. During execution, you’ll see logs that track progress, retries, and when emails are found and pushed to the dataset.

7. **Review results in the OUTPUT dataset**\
   When the run finishes, open the actor’s **OUTPUT** tab and open the dataset. Each found email appears as one row with fields like `keyword`, `url`, and `email`.

8. **Export to your workflow**\
   Export to JSON or CSV from Apify and bring the results into your CRM, spreadsheet, or data pipeline.

No coding required—get accurate results in minutes with this **Craigslist email list scraper** workflow. ✨

***

### Advanced features & SEO optimization

- ⚙️ **Engine tuning for performance vs reliability**: Switch between `cost-effective` and `legacy` to better match your needs for automated Craigslist email scraper for emails at different batch sizes
- 🧩 **Input normalization via keyword lists**: The actor accepts `keywords` as an array so you can run multi-theme searches for Craigslist email harvesting software use cases
- 🧾 **Detailed, operational logging**: Logs help you understand when pages return results, when retries happen, and when scraping stops because of limits
- 💾 **Progress persistence for long runs**: The actor saves cursor state and already seen emails as it pushes new results, reducing the risk of losing work mid-run
- 🔒 **Domain-filtered scraping for lead relevance**: Using `customDomains` improves targeting for projects like Craigslist business email scraper or Craigslist tenant email scraper campaigns

***

### Best use cases

- 📈 **Marketing teams building outreach lists**: Collect emails tied to relevant Craigslist bios and posts, then filter by domains to keep leads aligned with your brand
- 🧑‍💼 **Recruiters sourcing talent contacts**: Identify email addresses associated with roles and organizations mentioned in Craigslist content
- 🏢 **B2B lead generation for businesses**: Use keyword targeting and domain filters to run an automated Craigslist email harvesting process for business outreach
- 🔎 **Market research & competitive intelligence**: Compile structured email-contact data alongside source titles/descriptions for analysis
- 🧑‍💻 **Developer and automation pipelines**: Feed dataset exports into CRMs, outreach systems, or ETL jobs using the consistent output fields
- 📬 **Agency workflows and bulk prospecting**: Quickly iterate keyword sets to find more relevant Craigslist contact email scraper leads without manual copy-pasting
- 🗂️ **Data analysts enriching datasets**: Join extracted emails with other public attributes you already collect for scoring and segmentation

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array (required)
  - ✅ `customDomains` as an array (optional)
  - ✅ `location` as a string (optional)
  - ✅ `platform` supports `Craigslist` (optional; default `Craigslist`)
  - ✅ `proxyConfiguration` as an object (optional)

- **Proxy Support**
  - ✅ Uses Apify proxy configuration via `proxyConfiguration`
  - ✅ Engine selection supports different reliability/performance tradeoffs (`engine`: `cost-effective` or `legacy`)

- **Retry Mechanism**
  - ✅ Includes resilience behavior for empty-result and blocked-page scenarios during pagination

- **Dataset Structure**
  - ✅ Each found email is pushed as a separate dataset row
  - ✅ Output fields include: `network`, `keyword`, `title`, `description`, `url`, `email`, `proxyGroups`

- **Rate Limits & Performance**
  - ✅ You control runtime via `maxEmails`
  - ✅ Large searches or high email limits may take longer

- **Limitations**
  - ❌ Email availability depends on what’s publicly present in Craigslist bios and posts related to your keywords
  - ❌ Results aren’t guaranteed to reach `maxEmails` exactly, even when set high

***

### FAQ

#### Do I need to log in to use Craigslist Email Scraper on Apify?

You don’t need to log in to run the actor once it’s started from your Apify account, but you do need an Apify account to access Apify Console and run actor executions.

#### What emails does Craigslist Email Scraper extract?

✅ It extracts email addresses from publicly available Craigslist bios and posts related to your keywords. You can improve targeting by providing `customDomains` (for example, `@gmail.com`).

#### How do I get more results if I see low email counts?

❌ If results seem low, try re-running with broader or more related keywords and include additional `customDomains` that match your target audience. Increasing `maxEmails` can also increase the chance of collecting more results, but it won’t guarantee reaching the exact number.

#### Is there a way to control how many emails are collected?

✅ Yes. Use `maxEmails` to set the maximum number of emails to collect. The run stops once the limit is reached.

#### Which engine should I choose: cost-effective or legacy?

✅ Use `legacy` as the default if you prioritize reliability. If you want a more cost-effective run for faster scraping, choose `cost-effective`. The best choice depends on your batch size and the kind of reliability you need.

#### Can I use proxies with Craigslist Email Scraper?

✅ Yes. Configure proxies using the `proxyConfiguration` input. This is helpful for more consistent scraping when running larger keyword sets.

#### What fields will I receive in the dataset?

✅ Each dataset row includes `network`, `keyword`, `title`, `description`, `url`, `email`, and `proxyGroups`, containing the extracted email and its related source context.

#### Is this tool legal to use?

✅ Craigslist Email Scraper **only accesses publicly available sources**. It’s still your responsibility to comply with applicable laws and platform policies (including privacy and anti-spam regulations) in your own use of the collected data.

***

### Support & feature requests

If you’re using Craigslist Email Scraper for Craigslist email harvesting, we’d love your feedback. 💬

- 💡 **Feature Requests**: Want enhancements like additional output fields, more export options, or better targeting controls for Craigslist email extraction script workflows? Tell us what would help.
- 📧 **Contact**: Reach out at <dataforleads@gmail.com>.

Your feedback helps shape future improvements to Craigslist Email Scraper. 🚀

***

*Craft your next **Craigslist Email Scraper** run for automated Craigslist leads email scraper results—SEO-optimized, dataset-ready, and built for real-world outreach workflows.*

***

### Disclaimer

This tool **only accesses publicly accessible sources**. It does not access private profiles, authenticated pages, or password-protected data.

You are responsible for complying with applicable laws and regulations (for example GDPR and CCPA where relevant), as well as platform Terms of Service and any anti-spam/privacy rules, when using the collected email data.

For data removal requests, contact <dataforleads@gmail.com>. Please use this tool responsibly, ethically, and only for legitimate 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("solid-scraper/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("solid-scraper/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 solid-scraper/craigslist-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solid-scraper/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 emails from postings with smart filtering by location/keywords. Save time on lead gen and outreach for real estate, recruitment, and agencies. ⚡ Fast, targeted, and easy to use. ✅",
        "version": "0.0",
        "x-build-id": "ayfmwiKbZVPO9o9Vc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~craigslist-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-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/solid-scraper~craigslist-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-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/solid-scraper~craigslist-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
