# ChurchFinder Directory Scraper (`automation-lab/churchfinder-directory-scraper`) Actor

Scrape public ChurchFinder city directories and profiles for church leads, contact details, denominations, addresses, ratings, and source URLs.

- **URL**: https://apify.com/automation-lab/churchfinder-directory-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.04 / 1,000 result extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## ChurchFinder Directory Scraper

Scrape public ChurchFinder city directories and church profile pages into clean church lead records.

ChurchFinder Directory Scraper helps you collect church names, denominations, addresses, profile URLs, phone numbers, service information, descriptions, ratings, and other public details from ChurchFinder.com.

### What does ChurchFinder Directory Scraper do?

ChurchFinder Directory Scraper turns public ChurchFinder pages into structured datasets.

It can start from:

- ⛪ ChurchFinder city directory pages
- 🔗 Individual ChurchFinder church profile URLs
- 🏙️ A `state` + `city` pair that the actor converts into a ChurchFinder city URL

The actor visits directory rows, follows profile pages when enabled, deduplicates church profiles, and saves one dataset row per church.

### Who is it for?

This actor is useful for teams that need church directory data for legitimate business, research, or partnership workflows.

#### Outreach and lead-generation teams

- 📣 Local marketing agencies building city-level church outreach lists
- 🧰 B2B vendors serving churches with software, maintenance, insurance, printing, fundraising tools, or events
- 📍 Local SEO teams comparing public directory coverage across metros

#### Community and partnership teams

- 🤝 Nonprofits finding potential partner congregations for programs, relief work, or local events
- 🧑‍🤝‍🧑 Faith-based coalitions mapping nearby churches and denominations
- 🏛️ Civic organizations identifying public congregation contacts for community announcements

#### Research and publishing teams

- 🗞️ Publishers researching churches by city, denomination, or region
- 🧪 Researchers studying public religious-organization distribution by geography
- 📊 Data teams enriching internal church datasets with source URLs and public profile details

### Why use this actor?

Manual ChurchFinder research is repetitive. A single city can include many paginated results and every profile may contain extra details.

This actor helps you:

- Save public church profiles into a spreadsheet-ready dataset
- Normalize city, state, ZIP, phone, and denomination fields
- Keep source URLs for auditability
- Limit runs with `maxItems` and `maxPagesPerCity`
- Choose between fast directory-only scraping and richer profile scraping

### What ChurchFinder pages can I scrape?

Use public ChurchFinder pages such as:

```text
https://www.churchfinder.com/churches/ca/los-angeles
https://www.churchfinder.com/churches/ny/new-york
https://www.churchfinder.com/churches/tx/houston
````

You can also provide a direct profile URL:

```text
https://www.churchfinder.com/churches/ca/los-angeles/abundant-life-christian-church
```

### Data extracted

The output dataset contains church lead records.

| Field | Description |
| --- | --- |
| `name` | Church name |
| `profileUrl` | ChurchFinder profile URL |
| `denomination` | Denomination or affiliation when visible |
| `address` | Public meeting location or directory address |
| `city` | City parsed from URL, profile, or address |
| `state` | State parsed from URL, profile, or address |
| `zip` | ZIP code when available |
| `phone` | Public phone number when shown on the profile |
| `website` | Public external website link when present |
| `email` | Public email address when present as a mailto link |
| `pastor` | Pastor/contact name when visible in directory rows |
| `serviceTimes` | Service-time text when visible |
| `description` | Public about/description text |
| `rating` | Numeric rating when visible |
| `reviewCount` | Number of user reviews when visible |
| `sourceUrl` | Page URL that produced the record |

### How much does it cost to scrape ChurchFinder church leads?

This actor uses pay-per-event pricing.

- A $0.005 start event is charged once per run.
- A result event is charged for each saved church record.
- BRONZE result price: $0.000063256 per church record, with lower prices on higher Apify tiers.
- You control volume with `maxItems`.

For a low-cost first run, keep the prefilled input at 20 churches and one city page.

### How to use ChurchFinder Directory Scraper

1. Open the actor on Apify.
2. Paste one or more ChurchFinder city URLs into **Start URLs**.
3. Set **Maximum churches** to the number of records you need.
4. Keep **Open profile pages** enabled if you need phone, ZIP, descriptions, and ratings.
5. Click **Start**.
6. Export results from the default dataset as CSV, JSON, Excel, or via API.

### Input example

```json
{
  "startUrls": [
    { "url": "https://www.churchfinder.com/churches/ca/los-angeles" }
  ],
  "maxItems": 25,
  "includeProfiles": true,
  "maxPagesPerCity": 3
}
```

### City input example

If you do not provide `startUrls`, you can use `state` and `city`:

```json
{
  "state": "ca",
  "city": "Los Angeles",
  "maxItems": 25,
  "includeProfiles": true
}
```

### Output example

```json
{
  "name": "Abundant Life Christian Church",
  "profileUrl": "https://www.churchfinder.com/churches/ca/los-angeles/abundant-life-christian-church",
  "denomination": "Disciples of Christ",
  "address": "3500 S Normandie Ave Los Angeles, CA 90007 United States",
  "city": "Los Angeles",
  "state": "CA",
  "zip": "90007",
  "phone": "(323) 733-8082",
  "website": null,
  "email": null,
  "pastor": null,
  "serviceTimes": null,
  "description": "Abundant Life Christian Church is a Christian church in Los Angeles California.",
  "rating": 5,
  "reviewCount": 1,
  "sourceUrl": "https://www.churchfinder.com/churches/ca/los-angeles"
}
```

### Tips for better results

- Start with one city and a low `maxItems` value.
- Enable profile pages when contact details matter.
- Disable profile pages for faster directory-only collection.
- Increase `maxPagesPerCity` for larger cities.
- Use `profileUrl` as your dedupe key in downstream systems.

### Directory-only vs profile mode

Directory-only mode is faster because it saves data visible on city listing pages.

Profile mode is richer because it opens each church profile. Profile pages can include:

- Phone numbers
- ZIP codes
- About text
- Review counts
- Ratings
- More precise denomination data

### Integrations

You can connect the dataset to common lead and research workflows:

- Export CSV to Google Sheets or Excel
- Send JSON records into a CRM
- Use Apify integrations to trigger webhooks after a run
- Combine with enrichment tools for website or email validation
- Schedule recurring city checks for directory monitoring

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/churchfinder-directory-scraper').call({
  startUrls: [{ url: 'https://www.churchfinder.com/churches/ca/los-angeles' }],
  maxItems: 25,
  includeProfiles: true
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('automation-lab/churchfinder-directory-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.churchfinder.com/churches/ca/los-angeles'}],
    'maxItems': 25,
    'includeProfiles': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~churchfinder-directory-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{"url":"https://www.churchfinder.com/churches/ca/los-angeles"}],
    "maxItems": 25,
    "includeProfiles": true
  }'
```

### Use with MCP

You can call this actor from AI tools through Apify MCP. Use the hosted MCP server and expose this actor as a tool:

```text
https://mcp.apify.com/?tools=automation-lab/churchfinder-directory-scraper
```

#### Claude Desktop MCP setup

Add this server to your Claude Desktop MCP configuration file:

```json
{
  "mcpServers": {
    "apify-churchfinder": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.apify.com/?tools=automation-lab/churchfinder-directory-scraper"
      ]
    }
  }
}
```

Restart Claude Desktop, then ask it to run the ChurchFinder Directory Scraper tool with a public ChurchFinder city URL.

#### Cursor MCP setup

Add this to your Cursor MCP configuration:

```json
{
  "mcpServers": {
    "apify-churchfinder": {
      "url": "https://mcp.apify.com/?tools=automation-lab/churchfinder-directory-scraper"
    }
  }
}
```

After saving, reload Cursor and enable the `apify-churchfinder` server in MCP settings.

#### VS Code MCP setup

For VS Code MCP-compatible clients, add a server entry similar to:

```json
{
  "servers": {
    "apify-churchfinder": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=automation-lab/churchfinder-directory-scraper"
    }
  }
}
```

If your VS Code MCP extension expects `mcpServers` instead of `servers`, use the Cursor-style JSON above.

Example prompts:

- "Scrape 25 ChurchFinder churches in Los Angeles and summarize denominations."
- "Find ChurchFinder profiles in Houston and return churches with phone numbers."
- "Create a CSV-ready list of public ChurchFinder church leads from this city URL."

### Legality

This actor collects public data from public ChurchFinder pages. You are responsible for using the data lawfully and respectfully.

Do not use scraped contact data for spam, harassment, or unlawful discrimination. Follow applicable privacy, marketing, and data-protection rules in your jurisdiction.

### FAQ and troubleshooting

#### Why are some fields empty?

ChurchFinder profiles vary. Some churches do not list a phone number, website, email, service time, or reviews. Empty fields are returned as `null`.

#### Why did I get fewer results than requested?

The city may have fewer public listings than your `maxItems`, or your `maxPagesPerCity` limit may stop pagination early. Increase `maxPagesPerCity` if you need more from a large city.

#### Should I disable profile pages?

Disable `includeProfiles` when you only need name, profile URL, denomination, and rough address. Keep it enabled for richer lead records.

### Related scrapers

Other automation-lab actors that may support lead-generation workflows:

- https://apify.com/automation-lab/google-maps-scraper
- https://apify.com/automation-lab/yelp-scraper
- https://apify.com/automation-lab/business-directory-scraper
- https://apify.com/automation-lab/website-contact-finder

### Changelog

#### 0.1

Initial version for public ChurchFinder city and profile pages.

### Support

If a page does not parse correctly, include the ChurchFinder URL, your run input, and a sample of the missing fields when reporting the issue.

# Actor input Schema

## `startUrls` (type: `array`):

ChurchFinder city directory URLs or individual church profile URLs. Example city format: https://www.churchfinder.com/churches/ca/los-angeles

## `state` (type: `string`):

Optional two-letter state code used with City when Start URLs are empty.

## `city` (type: `string`):

Optional city name used with State code when Start URLs are empty.

## `maxItems` (type: `integer`):

Maximum number of church records to save.

## `includeProfiles` (type: `boolean`):

Follow each listing to its ChurchFinder profile page to collect phone, ZIP, description, ratings, and richer denomination details.

## `maxPagesPerCity` (type: `integer`):

Pagination safety limit for each city directory URL.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.churchfinder.com/churches/ca/los-angeles"
    }
  ],
  "state": "ca",
  "city": "Los Angeles",
  "maxItems": 20,
  "includeProfiles": true,
  "maxPagesPerCity": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.churchfinder.com/churches/ca/los-angeles"
        }
    ],
    "state": "ca",
    "city": "Los Angeles",
    "maxItems": 20,
    "includeProfiles": true,
    "maxPagesPerCity": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/churchfinder-directory-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 = {
    "startUrls": [{ "url": "https://www.churchfinder.com/churches/ca/los-angeles" }],
    "state": "ca",
    "city": "Los Angeles",
    "maxItems": 20,
    "includeProfiles": True,
    "maxPagesPerCity": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/churchfinder-directory-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 '{
  "startUrls": [
    {
      "url": "https://www.churchfinder.com/churches/ca/los-angeles"
    }
  ],
  "state": "ca",
  "city": "Los Angeles",
  "maxItems": 20,
  "includeProfiles": true,
  "maxPagesPerCity": 3
}' |
apify call automation-lab/churchfinder-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ChurchFinder Directory Scraper",
        "description": "Scrape public ChurchFinder city directories and profiles for church leads, contact details, denominations, addresses, ratings, and source URLs.",
        "version": "0.1",
        "x-build-id": "Mu4NulMHD9PHF2Okk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~churchfinder-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-churchfinder-directory-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/automation-lab~churchfinder-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-churchfinder-directory-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/automation-lab~churchfinder-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-churchfinder-directory-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",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "ChurchFinder city directory URLs or individual church profile URLs. Example city format: https://www.churchfinder.com/churches/ca/los-angeles",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "state": {
                        "title": "State code",
                        "type": "string",
                        "description": "Optional two-letter state code used with City when Start URLs are empty."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Optional city name used with State code when Start URLs are empty."
                    },
                    "maxItems": {
                        "title": "Maximum churches",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of church records to save.",
                        "default": 20
                    },
                    "includeProfiles": {
                        "title": "Open profile pages",
                        "type": "boolean",
                        "description": "Follow each listing to its ChurchFinder profile page to collect phone, ZIP, description, ratings, and richer denomination details.",
                        "default": true
                    },
                    "maxPagesPerCity": {
                        "title": "Maximum directory pages per city",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Pagination safety limit for each city directory URL.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
