# Charity Email Scraper (`solid-scraper/charity-email-scraper`) Actor

📧 Charity Email Scraper finds verified donor/volunteer organization contacts fast using keywords and locations. Ideal for nonprofits, outreach, and fundraising teams—save time, boost reach, and grow your mission with targeted emails. 🚀

- **URL**: https://apify.com/solid-scraper/charity-email-scraper.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (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 $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.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

### Charity Email Scraper 📬
**Charity Email Scraper** is an actor that helps you **find charity email addresses** by scraping **publicly available data** and then extracting contact information from the charities’ websites. It’s designed to solve a common outreach bottleneck: turning a list of relevant charities into usable leads—quickly and at scale—without manually opening every website one by one.

Whether you’re using a **charity email scraper**, a **nonprofit email scraper**, or a **prospecting email scraper for nonprofits**, this tool streamlines discovery and enrichment so you can build a **bulk email list for fundraising** and outreach campaigns faster.

### Section 01 **What is Charity Email Scraper?**
**Charity Email Scraper** searches for charities using your **search term** and one or more **locations**, then collects business listings and scrapes contact details from their websites. In practice, it’s a charity contact email extractor that helps you **scrape nonprofit contact emails** and enrich your dataset with supporting fields like phone numbers and social links.

Whether you’re a marketer running **email lead generation tool for charities**, a researcher building a dataset for **data enrichment for nonprofit email leads**, or a data analyst automating outreach list prep, this actor helps you gather the contacts you need—saving you hours of manual work.

### Section 02 **Why choose Charity Email Scraper?**
| Feature | Benefit |
| --- | --- |
| ✅ **All-in-one lead collection** | Combines discovery and website scraping to build a usable nonprofit outreach dataset |
| ✅ **Built-in proxy support** | Helps scraping stay reliable at scale and reduces the chance of rate-limit disruptions |
| ✅ **Resilient scraping behavior** | Includes retries and fallbacks for resilience when pages don’t behave as expected |
| ✅ **Structured output for leads** | Produces consistent dataset rows with email, phones, and social media fields |
| ✅ **Scalable limits** | Lets you control how many businesses you want via `maxBusinesses` and per-location handling |
| ✅ **Automation-ready dataset** | Outputs clean records that you can export and feed into CRM or analytics workflows |

### Section 03 **Key features**
- 🔍 **Charity-focused business discovery**: Uses your `googleMapsSearchTerm` and `googleMapsLocation` values to target relevant charity/business listings.
- 🌐 **Website contact extraction**: Scrapes the websites it finds to populate `scraped_emails`, `scraped_phones`, and `scraped_social_media`.
- 🧾 **Structured lead records**: Saves results with clear fields like `name`, `website`, `full_address`, `emails_found`, and `scrape_status`.
- 🛡️ **Reliability with proxy configuration**: Supports proxy settings for more dependable scraping runs when you scale up.
- 🔄 **Resilience for messy sites**: Designed with retries and fallbacks so you get more usable results across real-world websites.
- 💾 **Real-time dataset saving**: Pushes results to the Apify dataset as the run progresses (including flat one-row-per-email output).
- 📊 **Useful quality metrics**: Includes `avg_rating` and `total_reviews` from the discovered listing data.
- 🧠 **Email-only behavior option**: Supports saving only businesses that produce emails (via email-only mode logic).

### Section 04 **Input**
Provide input via an `input.json` file. Example structure:

```json
{
  "googleMapsSearchTerm": "Charity",
  "googleMapsLocation": ["New York"],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `googleMapsSearchTerm` | Yes | The business type or niche you want the scraper to target (for example, `Charity` or `dentists`). |
| `googleMapsLocation` | Yes | One or more target locations for your lead search (for example, `["Miami, Florida"]` style values—use what you need for your outreach geography). |
| `maxBusinesses` | No | The target number of businesses to find **with emails**. Valid range is `1-1000`. The run stops when this target is reached. |
| `scrapeMaxBusinessesPerLocation` | No | Controls how the `maxBusinesses` limit is applied. If enabled, the scraper aims for up to `maxBusinesses` results per location; if disabled, it combines results across locations up to a single total limit. |
| `proxyConfiguration` | No | Proxy settings for web scraping. Recommended for larger-scale runs to help avoid blocks and rate-limit issues. |
| `proxyConfiguration.proxy support` | No (within object) | When set to `true`, enables Apify Proxy (recommended). |

### Section 05 **Output**

The actor saves results to the **Apify dataset** as individual JSON objects (with flattened lead rows where an email is found).

Example output row (one lead email row):

```json
{
  "name": "Example Charity Name",
  "website": "https://example.org",
  "phone": "+1 555 123 4567",
  "full_address": "123 Main St New York NY 10001 US",
  "city": "New York",
  "state": "NY",
  "zip": "10001",
  "country_code": "US",
  "avg_rating": 4.6,
  "total_reviews": 120,
  "lat": 40.7128,
  "long": -74.006,
  "place_id": "PLACE_ID_VALUE",
  "scraped_emails": [],
  "scraped_phones": [],
  "scraped_social_media": [],
  "emails_found": 3,
  "pages_scraped": 8,
  "scrape_status": "success",
  "email_found": "contact@example.org"
}
```

> Note: When emails are found, the actor pushes **flat rows**—one dataset row per extracted email—using `email_found`. The flattened output removes the list field `scraped_emails` and the internal `_detailed_emails` (if present).

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `name` | string | Business/charity name as found in the discovery step. |
| `website` | string | Website URL extracted from the listing. |
| `phone` | string | Phone number from the listing data (not necessarily the scraped website contacts). |
| `full_address` | string | Full constructed address string. |
| `city` | string | City name from listing data. |
| `state` | string | State/region from listing data. |
| `zip` | string | ZIP/postal code from listing data. |
| `country_code` | string | Country code from listing data. |
| `scraped_emails` | array | Extracted emails from the charity website (present in non-flattened business rows; removed in flattened email rows). |
| `scraped_phones` | array | Extracted phone numbers from the charity website. |
| `scraped_social_media` | array | Extracted social media links from the charity website. |
| `emails_found` | number | Total number of emails found on the website scraping step. |
| `pages_scraped` | number | How many pages were processed for the website scraping. |
| `avg_rating` | number | Rating associated with the discovered listing. |
| `total_reviews` | number | Total number of reviews associated with the discovered listing. |
| `lat` | number | Latitude from the discovery data. |
| `long` | number | Longitude from the discovery data. |
| `place_id` | string | Listing place identifier from the discovery data. |
| `scrape_status` | string | Scraping status (e.g., `success`, `failed`, `no_website`, `error`). |
| `email_found` | string | The specific email value for that dataset row (used in the flat one-row-per-email output). |

After the run, you can export the dataset to JSON or CSV directly from the Apify UI (depending on your workflow).

### Section 06 **How to use Charity Email Scraper (via Apify Console)**

1. **Open Apify Console**
   Go to the Apify Console: [console.apify.com](https://console.apify.com) and log in.

2. **Find the actor**
   Search for **Charity Email Scraper** in the Actors marketplace and open the actor page.

3. **Add your inputs**
   In the **INPUT** section, provide:
   - `googleMapsSearchTerm` (required)
   - `googleMapsLocation` (required; can be multiple)

4. **Set your limits**
   Adjust:
   - `maxBusinesses` (target number of businesses with emails)
   - `scrapeMaxBusinessesPerLocation` (whether the limit applies per location or globally)

5. **Configure proxy (recommended)**
   In **Proxy configuration**, set `proxyConfiguration.proxy support` to `true` for Apify Proxy-backed runs.

6. **Run the actor**
   Click **Run**. During execution, you’ll see logs for the discovery and website scraping stages, including progress updates and success/failure outcomes.

7. **Review results**
   After completion, open the **dataset output** to see extracted contacts. If emails are found, you’ll see one row per extracted email via `email_found`.

8. **Export**
   Export your results as JSON/CSV and load into your CRM, spreadsheet, or analysis pipeline.

No coding required—get accurate charity email leads in minutes with **Charity Email Scraper**. 💪

### Section 07 **Advanced features & SEO optimization**

- 💡 **Engineered for nonprofit email lead generation**: Built specifically for the “find charity email addresses + enrich contact details” workflow—ideal for **email lead generation tool for charities** use cases.
- 🧠 **Email-only mode logic**: Supports a mode where only businesses with emails are saved, which helps keep your outreach list clean.
- 🌐 **Website-first contact enrichment**: Extracts emails plus supporting `scraped_phones` and `scraped_social_media` fields to support **charity contact email extractor** workflows.
- 🛡️ **GDPR-minded workflow support (practical)**: You control the geography, niche, and volume via inputs like `googleMapsLocation` and `maxBusinesses` to help you target only what you need for compliant outreach.
- 📊 **Consistent dataset schema**: Output is structured with fields such as `scrape_status`, `pages_scraped`, and `emails_found`, which makes **scrape emails from charity websites** easier to operationalize.

### Section 08 **Best use cases**

- 📈 **Fundraising teams building donor email lists**: Generate a **bulk email list for fundraising** with charity emails plus supporting contact context.
- 🧭 **Nonprofit marketers running outreach sequences**: Prepare targeted lists from charity website contacts to improve campaign speed.
- 🔬 **Researchers collecting nonprofit contact datasets**: Build structured samples for analysis using fields like rating, reviews, and location metadata.
- 🏢 **Partnership managers sourcing charity collaborators**: Quickly compile charities and their contact channels for co-marketing or sponsorship outreach.
- 🧾 **Data analysts enriching lead spreadsheets**: Feed clean rows into BI pipelines, using `emails_found`, `pages_scraped`, and `scrape_status`.
- 💻 **CRM operators automating prospecting email scraper for nonprofits**: Automate list updates and reduce manual copy-paste from websites.
- ⚙️ **Email ops teams improving list coverage**: Compare website-derived contacts across multiple charities and track scraping success rates.

### Section 09 **Technical specifications**

- **Supported Input Formats**
  - ✅ `googleMapsSearchTerm` (string)
  - ✅ `googleMapsLocation` (array of strings)
  - ✅ `proxyConfiguration` (object with `proxy support`)

- **Proxy Support**
  - ✅ `proxyConfiguration.proxy support` supported via the Apify proxy configuration object.

- **Retry Mechanism / Resilience**
  - ✅ Includes retries and fallbacks for resilience during scraping (behavior designed to improve real-world success).

- **Dataset Structure**
  - ✅ Uses the Apify dataset named by the actor storage configuration: **Business Contact Data**
  - ✅ Includes fields such as `scraped_emails`, `scraped_phones`, `scraped_social_media`, `emails_found`, `pages_scraped`, and `scrape_status`.
  - ✅ When emails are extracted, outputs **flattened lead rows** with `email_found` (one row per email).

- **Limit Controls**
  - ✅ `maxBusinesses` stops discovery once the target is reached.
  - ✅ `scrapeMaxBusinessesPerLocation` controls whether limits apply per location or globally.

- **Limitations**
  - ❌ If a listing has no website, website scraping cannot occur and the result will reflect `scrape_status` such as `no_website`.
  - ❌ Not every charity listing will produce emails; you control volume using `maxBusinesses` and can use email-only behavior to keep results focused.

### Section 10 **FAQ**

#### Does Charity Email Scraper work with multiple locations?

✅ Yes. You can pass `googleMapsLocation` as an array of locations. If you enable `scrapeMaxBusinessesPerLocation`, it targets up to `maxBusinesses` per location; otherwise it combines results across locations up to a single overall limit.

#### What kind of data does Charity Email Scraper extract?

✅ It scrapes charity/business websites to extract contact details, including `scraped_emails`, `scraped_phones`, and `scraped_social_media`. It also saves discovery fields like `name`, `website`, `full_address`, `avg_rating`, and `total_reviews`.

#### How is the output stored in the dataset?

✅ The actor pushes results to the Apify dataset as JSON objects. When emails are found, it also pushes **flat rows** so you get one dataset row per email via `email_found`.

#### Can I limit how many charities with emails I get?

✅ Yes. Use `maxBusinesses` to set the target number of businesses with emails. The run stops once the target is reached, including in email-only behavior logic.

#### Do I need proxies to run the actor?

❌ Not required for correctness, but proxy support is available and recommended for larger runs through `proxyConfiguration` (notably `proxyConfiguration.proxy support`).

#### Can it validate emails?

✅ There is support for email validation via the `validate_emails` setting passed into the website scraping configuration. In the current input schema, this validation toggle is not exposed directly, but validation is controlled in the scraping config flow.

#### Can I integrate the output into my CRM or analysis workflow?

💻 Yes. The dataset is structured with consistent fields like `email_found`, `emails_found`, `pages_scraped`, and `scrape_status`, which makes it straightforward to export to JSON/CSV and import into common tools.

#### Is Charity Email Scraper compliant for legal use?

✅ The actor extracts from **publicly accessible sources**, but legal compliance (including GDPR, CCPA, and anti-spam regulations) is your responsibility. Use the data ethically and only for legitimate outreach.

### Section 11 **Support & feature requests**

Want to improve Charity Email Scraper or request enhancements for charity email scraper workflows? We’d love to hear from you. 💬

- 💡 **Feature Requests:** For example, adding a dedicated CSV export option, expanding output fields, or improving email filtering for charity mailing list scraper use cases.
- 📧 **Contact:** Reach out at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for the **Charity Email Scraper** actor.

### Section 12 **Closing CTA / Final thoughts**

*If you’re looking for an SEO-optimized charity email scraper that turns public charity info into structured outreach leads, Charity Email Scraper delivers a practical, scalable workflow from discovery to dataset output.*\
*Run it once, export the dataset, and spend your time on outreach—not manual searching.*

### Section 13 **Disclaimer**

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

You are responsible for ensuring your use complies with applicable laws and regulations (including GDPR/CCPA where relevant), spam regulations, and each source website’s terms of service. For any data removal requests, contact <dataforleads@gmail.com>.

Please use **Charity Email Scraper** responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `googleMapsSearchTerm` (type: `string`):

Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').

## `googleMapsLocation` (type: `array`):

Target geographic location for the email scraper (e.g., 'Miami, Florida').

## `maxBusinesses` (type: `integer`):

Target number of businesses to find (1-1000). The scraper will stop when this target is reached.

## `scrapeMaxBusinessesPerLocation` (type: `boolean`):

If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.

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

Proxy settings for scraping. Recommended for large-scale scraping.

## Actor input object example

```json
{
  "googleMapsSearchTerm": "Charity",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "scrapeMaxBusinessesPerLocation": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "googleMapsSearchTerm": "Charity",
    "googleMapsLocation": [
        "New York"
    ],
    "maxBusinesses": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/charity-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 = {
    "googleMapsSearchTerm": "Charity",
    "googleMapsLocation": ["New York"],
    "maxBusinesses": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/charity-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 '{
  "googleMapsSearchTerm": "Charity",
  "googleMapsLocation": [
    "New York"
  ],
  "maxBusinesses": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call solid-scraper/charity-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Charity Email Scraper",
        "description": "📧 Charity Email Scraper finds verified donor/volunteer organization contacts fast using keywords and locations. Ideal for nonprofits, outreach, and fundraising teams—save time, boost reach, and grow your mission with targeted emails. 🚀",
        "version": "1.0",
        "x-build-id": "hdGhVbfEQ1eNSCOGD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solid-scraper~charity-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solid-scraper-charity-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~charity-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solid-scraper-charity-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~charity-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solid-scraper-charity-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": [
                    "googleMapsLocation",
                    "googleMapsSearchTerm"
                ],
                "properties": {
                    "googleMapsSearchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Enter the business type or niche for email scraper (e.g., 'coffee shops', 'dentists').",
                        "default": "Charity"
                    },
                    "googleMapsLocation": {
                        "title": "Location",
                        "type": "array",
                        "description": "Target geographic location for the email scraper (e.g., 'Miami, Florida').",
                        "default": [
                            "New York"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxBusinesses": {
                        "title": "Maximum Businesses With Emails",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Target number of businesses to find (1-1000). The scraper will stop when this target is reached.",
                        "default": 5
                    },
                    "scrapeMaxBusinessesPerLocation": {
                        "title": "Scrape Max Businesses Per Location",
                        "type": "boolean",
                        "description": "If enabled, the scraper will collect up to `maxBusinesses` results per location. If disabled, it combines all locations up to a single total limit.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Recommended for large-scale scraping."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
