# Eventective Venue & Vendor Scraper (`automation-lab/eventective-venue-vendor-scraper`) Actor

🏢 Scrape public Eventective venue and vendor leads with phones, websites, addresses, capacity, pricing, photos, and profile URLs.

- **URL**: https://apify.com/automation-lab/eventective-venue-vendor-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

Pay per event

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

## Eventective Venue & Vendor Scraper

Collect public Eventective venue and vendor leads from city, category, and profile pages.

The actor extracts names, profile URLs, categories, addresses, phone numbers, websites, capacity, pricing, photos, coordinates, and descriptions from Eventective.

Use it to build local event-service lead lists, compare venues, enrich CRM records, and monitor supplier markets.

### What does Eventective Venue & Vendor Scraper do?

Eventective Venue & Vendor Scraper crawls public Eventective listing pages and optional profile pages.

It reads server-rendered listing cards and profile-page schema data.

It saves each venue or vendor as a structured dataset row.

It supports wedding venues, banquet halls, party venues, corporate event spaces, caterers, DJs, photographers, and other Eventective categories exposed through public listing pages.

### Who is it for?

Event planners can collect venue options for a destination or event type.

Wedding-service sellers can build outreach lists for local partners.

Venue aggregators can compare address, capacity, and pricing signals across markets.

Local lead-generation teams can collect phone and website leads by city.

Market researchers can track Eventective category supply by geography.

### Why use this scraper?

⚡ It uses HTTP-first extraction instead of a browser, so runs are lightweight.

🏢 It collects both listing-card and profile-page information.

📍 It normalizes address and geo fields when Eventective exposes them.

☎️ It extracts phone and website values from public profile schema.

🧾 It keeps source URLs so every record can be audited.

### What data can it extract?

| Field | Description |
| --- | --- |
| `providerId` | Eventective provider identifier |
| `name` | Venue or vendor name |
| `profileUrl` | Eventective profile URL |
| `sourceUrl` | Listing or profile URL that produced the record |
| `category` | Venue/vendor type |
| `location` | Listing location text |
| `address` | Full address when available |
| `streetAddress` | Street address |
| `city` | City |
| `region` | State/region |
| `postalCode` | Postal code |
| `country` | Country |
| `phone` | Public phone number |
| `website` | External website URL |
| `capacity` | Maximum attendee capacity |
| `priceText` | Displayed price text |
| `price` | Numeric price when parsed |
| `priceCurrency` | Currency code when available |
| `latitude` | Latitude |
| `longitude` | Longitude |
| `description` | Public listing/profile description |
| `imageUrl` | Main image URL |
| `imageUrls` | Additional image URLs |
| `isVenue` | Venue flag from listing card |
| `adType` | Eventective listing tier/ad type |
| `rank` | Listing rank on the page |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape Eventective venues?

This actor uses pay-per-event pricing.

There is a small run-start event and a per-record event.

You only pay for records that are saved to the dataset.

Use a small `maxItems` value for first tests.

Increase `maxItems` and `maxPages` when you are ready to collect larger local lists.

### How to use it

1. Open the actor on Apify.

2. Add one or more Eventective listing URLs.

3. Keep `includeDetails` enabled if you need phone, website, address, geo, and pricing details.

4. Set `maxItems` to the maximum number of venues/vendors you need.

5. Run the actor.

6. Export the dataset to CSV, Excel, JSON, or connect it to your workflow.

### Example listing URLs

Use Eventective city/category pages such as:

```text
https://www.eventective.com/new-york-ny/wedding-venues/
https://www.eventective.com/los-angeles-ca/party-event-venues/
https://www.eventective.com/chicago-il/caterers/
````

You can also add direct profile URLs in `profileUrls`.

### Input options

#### `startUrls`

Eventective listing/category URLs to crawl.

The actor follows pagination links such as `?p=2` until it reaches your `maxPages` or `maxItems` limit.

#### `profileUrls`

Optional direct Eventective profile URLs.

Use this when you already have profile URLs and only need enrichment.

#### `maxItems`

Maximum venue/vendor records to save.

The default is intentionally small for a cheap first run.

#### `maxPages`

Maximum result pages to crawl per listing URL.

If you set this too low, the actor may stop before reaching `maxItems`.

#### `includeDetails`

When enabled, the actor opens each profile page and parses schema.org data.

Disable it for faster listing-only scouting.

#### `requestDelayMs`

Polite delay between requests.

Increase it if the target responds slowly.

### Output example

```json
{
  "providerId": "788397",
  "name": "Arches",
  "profileUrl": "https://www.eventective.com/brooklyn-ny/arches-788397.html",
  "category": "Banquet/Event Hall",
  "address": "1394 St Johns Pl, Brooklyn, NY, 11213, US",
  "phone": "+13472917100",
  "website": "https://www.thearchesbk.com",
  "capacity": 300,
  "priceText": "CAD 4500",
  "latitude": 40.6704,
  "longitude": -73.9322,
  "scrapedAt": "2026-07-10T00:00:00.000Z"
}
```

### Tips for better results

Start with a specific city and category.

Use `includeDetails: true` for lead-generation workflows.

Use `includeDetails: false` for a fast market-size scan.

Export CSV when uploading to spreadsheets or CRM tools.

Keep `requestDelayMs` above zero for polite crawling.

### Integrations

Send the dataset to Google Sheets for venue comparison.

Push results to Airtable for lead qualification.

Use Make or Zapier to notify sales teams when new venues appear.

Export JSON to enrich your own supplier database.

Connect Apify datasets to webhooks for automated downstream processing.

### 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/eventective-venue-vendor-scraper').call({
  startUrls: [{ url: 'https://www.eventective.com/new-york-ny/wedding-venues/' }],
  maxItems: 25,
  includeDetails: true
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/eventective-venue-vendor-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.eventective.com/new-york-ny/wedding-venues/'}],
    'maxItems': 25,
    'includeDetails': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~eventective-venue-vendor-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.eventective.com/new-york-ny/wedding-venues/"}],"maxItems":25,"includeDetails":true}'
```

### MCP usage

Use the Apify MCP server with Claude Desktop or Claude Code.

MCP URL:

```text
https://mcp.apify.com?tools=automation-lab/eventective-venue-vendor-scraper
```

Claude Code setup:

```bash
claude mcp add apify-eventective --transport http "https://mcp.apify.com?tools=automation-lab/eventective-venue-vendor-scraper"
```

Claude Desktop JSON setup:

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

Example prompts:

- "Scrape 50 Eventective wedding venues in New York and summarize capacity ranges."

- "Find Eventective venues with websites and phone numbers for this category page."

- "Export Eventective party venue leads to a CSV-ready table."

### Common workflows

#### Build a wedding venue list

Add one or more wedding-venue city pages.

Keep details enabled.

Export names, phone numbers, websites, capacity, and pricing.

#### Research category supply

Run multiple category URLs with a moderate `maxItems` value.

Group results by category, city, and capacity.

#### Enrich known Eventective profiles

Paste profile URLs into `profileUrls`.

Set listing `startUrls` to a small default or only use direct profiles.

Save structured address and website fields.

### Limitations

The actor only scrapes public Eventective pages.

It does not log in or bypass access controls.

Email addresses are not guaranteed and are not inferred.

Some fields are optional because Eventective profiles vary.

External websites are returned as URLs, but the actor does not crawl those websites.

### FAQ

#### Can I scrape Eventective without logging in?

Yes. This actor is designed for public Eventective listing and profile pages only.

#### Does it collect emails?

It does not infer hidden emails. It focuses on public phone, website, address, capacity, pricing, image, and profile data.

### Troubleshooting

#### Why did I get fewer records than expected?

Increase `maxPages` or choose a listing URL with more available results.

The actor stops when it reaches `maxItems`, `maxPages`, or no more listing cards are found.

#### Why are phone or website fields missing?

Those fields usually come from profile-page JSON-LD.

Make sure `includeDetails` is enabled.

Some profiles may not publish all contact fields.

#### Why is pricing missing?

Eventective does not publish structured pricing for every venue/vendor.

When available, pricing is saved as text and numeric fields.

### Legality and responsible use

This actor extracts publicly available information from Eventective pages.

You are responsible for using the data legally and respecting applicable privacy, marketing, and data-protection laws.

Do not use scraped data for spam.

Respect Eventective and third-party website terms.

### Related scrapers

Explore other Automation Lab actors for local lead generation and directory scraping:

- https://apify.com/automation-lab/google-maps-business-scraper

- https://apify.com/automation-lab/yelp-business-scraper

- https://apify.com/automation-lab/weddingwire-vendor-scraper

- https://apify.com/automation-lab/the-knot-vendor-scraper

### Support

If a public Eventective page stops working, share the run URL and input.

Include an example URL that should produce results.

### Changelog

Initial version extracts listing cards and optional profile JSON-LD enrichment.

### Data quality notes

Eventective may show slightly different public profile URLs between listing cards and JSON-LD canonical URLs.

The actor preserves the best available profile URL and the original source URL.

Image lists are deduplicated.

Phone numbers are normalized when possible.

### Performance notes

HTTP extraction is usually faster than browser automation.

Large runs are still bounded by profile-page requests when `includeDetails` is enabled.

Use listing-only mode for fast previews.

### Privacy notes

The actor does not scrape private accounts.

The actor does not submit contact forms.

The actor does not infer hidden email addresses.

### Export formats

Apify datasets can be exported as JSON, CSV, Excel, XML, RSS, or HTML.

CSV is convenient for lead lists.

JSON is convenient for enrichment pipelines.

Excel is convenient for manual event planning workflows.

### Version

Current actor version: 0.1.

# Actor input Schema

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

Eventective search/listing pages to crawl, for example city/category pages such as wedding venues in New York.

## `profileUrls` (type: `array`):

Optional Eventective venue/vendor profile URLs to scrape directly in addition to listing pages.

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

Maximum number of venue/vendor records to save to the dataset.

## `maxPages` (type: `integer`):

Maximum number of listing result pages to visit per listing start URL.

## `includeDetails` (type: `boolean`):

Open each profile page to extract JSON-LD details such as website, phone, address, geo, and pricing.

## `requestDelayMs` (type: `integer`):

Polite delay between requests. Increase if Eventective responds slowly.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.eventective.com/new-york-ny/wedding-venues/"
    }
  ],
  "profileUrls": [
    {
      "url": "https://www.eventective.com/brooklyn-ny/the-arches-788397.html"
    }
  ],
  "maxItems": 20,
  "maxPages": 5,
  "includeDetails": true,
  "requestDelayMs": 250
}
```

# 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.eventective.com/new-york-ny/wedding-venues/"
        }
    ],
    "profileUrls": [
        {
            "url": "https://www.eventective.com/brooklyn-ny/the-arches-788397.html"
        }
    ],
    "maxItems": 20,
    "maxPages": 5,
    "includeDetails": true,
    "requestDelayMs": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/eventective-venue-vendor-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.eventective.com/new-york-ny/wedding-venues/" }],
    "profileUrls": [{ "url": "https://www.eventective.com/brooklyn-ny/the-arches-788397.html" }],
    "maxItems": 20,
    "maxPages": 5,
    "includeDetails": True,
    "requestDelayMs": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/eventective-venue-vendor-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.eventective.com/new-york-ny/wedding-venues/"
    }
  ],
  "profileUrls": [
    {
      "url": "https://www.eventective.com/brooklyn-ny/the-arches-788397.html"
    }
  ],
  "maxItems": 20,
  "maxPages": 5,
  "includeDetails": true,
  "requestDelayMs": 250
}' |
apify call automation-lab/eventective-venue-vendor-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Eventective Venue & Vendor Scraper",
        "description": "🏢 Scrape public Eventective venue and vendor leads with phones, websites, addresses, capacity, pricing, photos, and profile URLs.",
        "version": "0.1",
        "x-build-id": "g13ZuVj5A565H4G5c"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~eventective-venue-vendor-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-eventective-venue-vendor-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~eventective-venue-vendor-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-eventective-venue-vendor-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~eventective-venue-vendor-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-eventective-venue-vendor-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔎 Eventective listing URLs",
                        "type": "array",
                        "description": "Eventective search/listing pages to crawl, for example city/category pages such as wedding venues in New York.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "profileUrls": {
                        "title": "🏢 Direct profile URLs",
                        "type": "array",
                        "description": "Optional Eventective venue/vendor profile URLs to scrape directly in addition to listing pages.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum venues/vendors",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of venue/vendor records to save to the dataset.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum listing pages",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of listing result pages to visit per listing start URL.",
                        "default": 5
                    },
                    "includeDetails": {
                        "title": "Enrich from profile pages",
                        "type": "boolean",
                        "description": "Open each profile page to extract JSON-LD details such as website, phone, address, geo, and pricing.",
                        "default": true
                    },
                    "requestDelayMs": {
                        "title": "Request delay (milliseconds)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between requests. Increase if Eventective responds slowly.",
                        "default": 250
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
