# Canva Email Scraper Fast Advanced And Cheapest (`scraperoka/canva-email-scraper-fast-advanced-and-cheapest`) Actor

🚀 Collect verified emails fast with Canva Email Scraper: Fast Advanced And Cheapest! Extract contact data efficiently, streamline lead gen, and boost outreach. 🔍 Perfect for B2B sales, marketing, and recruiting—save time, reduce costs, get results. 📩

- **URL**: https://apify.com/scraperoka/canva-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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

### Canva Email Scraper - Fast, Advanced and Cheapest ⚡
Manually collecting emails from Canva can waste hours you can’t afford. **Canva Email Scraper - Fast, Advanced and Cheapest** extracts email addresses from Canva using the keywords and domain filters you specify. This Canva email scraper tool helps teams quickly build email list building from Canva for outreach, sales, and research. It’s ideal for marketers, recruiters, and growth teams that want thousands of leads-ready records in minutes.

---

### What You Get: Sample Output
Here’s a sample record from a single run:

```json
{
  "network": "Canva.com",
  "keyword": "manager",
  "title": "Senior Project Manager",
  "description": "Project and contact details page text that includes john.smith@gmail.com",
  "url": "https://www.canva.com/some-profile-or-page",
  "email": "john.smith@gmail.com"
}
````

**Output Fields**

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network for the lead (set to `Canva.com`). |
| `keyword` | string | Which keyword entry produced the contact (useful for QA and refining your canva lead scraper strategy). |
| `title` | string | The result title tied to the contact—helps you judge relevance fast. |
| `description` | string | The extracted text snippet/context where the email was found (handy for auditing). |
| `url` | string | The link associated with the finding—useful for verification and manual review. |
| `email` | string | The actual email address collected using your domain filters. |
| `status` | string | (Optional concept) If the run stops early due to limits or constraints, your dataset still contains whatever was successfully pushed incrementally. |
| `error_message` | string | (Optional concept) When an individual record can’t be pushed, the actor logs the issue while continuing overall collection. |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Canva Email Scraper - Fast, Advanced and Cheapest?

There are a lot of ways to pull email leads from public web data — here’s what sets Canva Email Scraper - Fast, Advanced and Cheapest apart.

#### Keyword + email-domain targeting for better lead quality

This actor uses your provided `keywords` and your `customDomains` (for example `@gmail.com`) to keep results focused. You can run a canva contact email finder workflow that’s tuned to the domains your outreach actually targets.

#### Incremental dataset writing as results are found

Data is pushed into the Apify dataset as it’s discovered, so you don’t have to wait for the entire run to finish to review leads. That makes it a practical bulk email extractor from Canva when you need fast feedback.

#### Deduplication of unique emails across the run

The actor tracks already-seen emails and avoids pushing duplicates. That means your email list building from Canva stays cleaner and easier to import.

#### Resumable progress for long or interrupted runs

Progress is saved and the actor can resume from the stored cursor state. If you expand a search or increase the workload, you can continue without starting over from scratch.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "keywords": ["manager", "founder"],
  "location": "Austin, TX",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 20
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | Provide a list of keywords to search for in your lead-finding workflow. |
| `location` | ⬜ | Adds a location filter to narrow down results to a specific region. |
| `customDomains` | ⬜ | Limits collected emails to the domains you choose (for example `@gmail.com`). |
| `maxEmails` | ⬜ | Stops the scraper once the maximum number of emails to collect is reached (useful for cost control and testing). |

***

### Core Capabilities

#### Targeted email extraction from Canva

Canva Email Scraper - Fast, Advanced and Cheapest extracts email addresses from Canva using the keywords and filters you provide. It’s built for automated email extraction when you want leads from canva contact email finder searches without manual copying.

#### Flexible input controls for search scope

You can control how broad your search is by adjusting `keywords`, adding an optional `location`, and selecting `customDomains`. This flexibility is what makes an advanced email scraper approach practical for different campaigns and audiences.

#### Resilience and controlled run duration

The actor supports a large maximum pagination attempt and can stop early when it hits your limits or when it runs out of new results. If you request more, it may take longer—so you can extend timeout via Run Options as needed.

#### Structured, integration-ready dataset output

Each found lead is pushed with consistent fields (`network`, `keyword`, `title`, `description`, `url`, `email`) so analysts and marketers can filter, validate, and import quickly. This is useful when you’re building a web email scraper for leads and want clean, reviewable outputs.

#### Works well for scale and automation

Because results are written to the dataset incrementally, you can monitor progress and react quickly when you like what you see. That makes it a strong fit for fast email scraping software workflows and repetitive prospecting tasks.

Overall: you get a reliable canva email scraper flow that’s easy to tune and built for bulk list building.

***

### Who Gets the Most Out of This

Here’s how different teams put Canva Email Scraper - Fast, Advanced and Cheapest to work:

**Marketing teams building email list building from Canva** use keywords like job titles and leadership roles, then restrict to the email domains that match their outreach strategy. They get leads-ready records with the source URL and snippet context for quick validation.

**Recruiters and talent sourcers** can use a canva lead scraper approach to find contact emails tied to specific roles and locations. The ability to filter by `customDomains` helps them focus on the inbox providers most likely to match candidates they’re targeting.

**Sales teams running email scraper for marketing outreach** benefit from pulling contact emails in bulk using targeted keywords and domain constraints. When building a pipeline, they can quickly export from the Apify dataset and enrich the leads in their CRM.

**Data analysts and researchers** use the dataset fields (`keyword`, `title`, `description`, `url`, `email`) to measure what keywords yield the highest response potential. They can also deduplicate and analyze coverage across different domains.

**Developers and automation specialists** integrate the actor results programmatically (via Apify API workflows) and schedule repeated runs for ongoing discovery. This turns automated email extraction from Canva into a repeatable data source for downstream tooling.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Canva Email Scraper - Fast, Advanced and Cheapest from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open the actor page.
2. **Enter your inputs** — add `keywords` (required), and optionally set `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — enable proxy support in Run Options if you want improved reliability for repeated scraping.
4. **Hit Run and watch the live log** — confirm which keyword/domain combinations are being processed and see progress as emails are found.
5. **View results in the dataset tab** — leads appear as they’re pushed incrementally, so you can review quickly.
6. **Export as JSON, CSV, or Excel** — download from the Apify dataset tab for import into your tools.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Canva Email Scraper - Fast, Advanced and Cheapest plugs directly into your existing workflow.

You can export results from the Apify dataset in JSON, CSV, or Excel from the dataset tab. For broader automation, you can connect the actor to your stack using Apify’s API and webhook-based patterns for downstream actions.

For “email scraper tool for canva” use cases like ongoing outreach list building, you can also schedule runs to refresh leads automatically, and use no-code automation tools such as Zapier or Make to push results into CRMs and spreadsheets.

For deeper details on API usage and automations, use Apify developer documentation: https://apify.com/docs/api

***

### Pricing & Free Trial

Canva Email Scraper - Fast, Advanced and Cheapest runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can run quick tests to validate your keywords, domain filters, and `maxEmails` settings.

For larger production runs, you’ll typically pay via Apify platform compute (billed per Actor compute unit / CU). Start for free at [apify.com](https://apify.com) and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Result limits for testing | Stops when `maxEmails` is reached (and free users may have an enforced cap). |
| Deduplication | Avoids pushing duplicate emails across the run. |
| Long-running jobs | Saves progress so you can resume if needed. |
| Empty/sparse outputs | Stops when it detects sustained lack of new emails. |
| Data availability | Writes leads incrementally to the Apify dataset as they’re found. |

**Limitations:** This actor extracts emails from publicly available sources and relies on what’s present on those pages. If your keywords or `customDomains` are too narrow, you may collect fewer results than expected.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes—Apify offers a free tier so you can test Canva email scraper performance before scaling up. If you run with the free tier, there is a maximum of 100 emails enforced by the actor logic.

#### Do I need to log in to Canva to use this?

No. The actor extracts email addresses from publicly available data based on your inputs, without requiring login.

#### How accurate is the data?

Accuracy depends on what emails are publicly available in the source content. The actor collects emails that match your `customDomains`, and it avoids duplicates it has already seen.

#### How many results can I get per run?

You control this with `maxEmails`. The actor will stop once it reaches the number you set (up to the allowed maximum), and free tier runs are capped at 100 emails.

#### How often is the data updated / how fresh is it?

The actor runs on demand and writes results to the dataset during the run. Freshness depends on when you execute the actor and what information is currently visible in the underlying public sources.

#### Is this legal? Does it comply with GDPR / CCPA?

You should use the actor only to collect **publicly available data** and ensure your processing complies with GDPR, CCPA, and applicable platform rules. The actor does not provide legal advice—your use and storage policies are your responsibility.

#### Can I export results to Google Sheets or Excel?

Yes. You can export from the Apify dataset tab as JSON, CSV, or Excel, then import into Google Sheets or other tools. You can also automate the flow using Apify integrations and API/webhooks.

#### Can I run this on a schedule automatically?

Yes. Since it runs as an Apify actor, you can schedule automated runs (for example, to refresh email list building from Canva periodically).

#### Can I access this via API?

Yes. You can trigger the actor and retrieve results programmatically using Apify’s API. Refer to https://apify.com/docs/api for details.

#### What happens if the actor hits an error?

If individual data pushes fail, the actor logs the issue and continues its overall workflow. If the run is interrupted, saved progress enables resuming so you can avoid starting from zero.

***

### Need Help or Have a Request?

Got a question about Canva Email Scraper - Fast, Advanced and Cheapest or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to support your use case and also consider improvements like webhook on completion and batch CSV upload for easier workflows.

***

### Disclaimer & Responsible Use

*Canva Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to build leads-ready email lists from Canva — start your free run today.*

We use **publicly available data** only. The actor does not access private accounts, login-gated content, or password-protected pages. You’re responsible for complying with GDPR, CCPA, platform Terms of Service, and any applicable laws. If you need data removal, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

A list of keywords or queries to search for.

## `location` (type: `string`):

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/canva-email-scraper-fast-advanced-and-cheapest").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/canva-email-scraper-fast-advanced-and-cheapest").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call scraperoka/canva-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Canva Email Scraper Fast Advanced And Cheapest",
        "description": "🚀 Collect verified emails fast with Canva Email Scraper: Fast Advanced And Cheapest! Extract contact data efficiently, streamline lead gen, and boost outreach. 🔍 Perfect for B2B sales, marketing, and recruiting—save time, reduce costs, get results. 📩",
        "version": "1.0",
        "x-build-id": "LA32VRNX1EwgYW23J"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~canva-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-canva-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~canva-email-scraper-fast-advanced-and-cheapest/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-canva-email-scraper-fast-advanced-and-cheapest",
                "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/scraperoka~canva-email-scraper-fast-advanced-and-cheapest/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-canva-email-scraper-fast-advanced-and-cheapest",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords or Queries",
                        "type": "array",
                        "description": "A list of keywords or queries to search for.",
                        "default": [
                            "manager",
                            "founder"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "customDomains": {
                        "title": "Enter Custom Email Domains (e.g. @gmail.com, @yahoo.com)",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com",
                            "@yahoo.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxEmails": {
                        "title": "Enter Max Emails",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
