# Canva Scraper (`solidcode/canva-scraper`) Actor

\[💰 $5 / 1K] Extract Canva templates by keyword or URL. Get titles, creators, dominant colors, fonts, dimensions, categories, and preview images from search, category, and creator pages.

- **URL**: https://apify.com/solidcode/canva-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 results

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

## Canva Template Scraper

Pull design templates from Canva at scale — titles, creators, dominant color palettes, fonts, exact pixel dimensions, preview images, and Pro-vs-free flags for any keyword, category, or creator. Discover templates by search term, category page, or an entire creator portfolio, and enrich each one with the design details that live only on its template page. Built for designers, marketing teams, template sellers, and AI dataset builders who need structured Canva template data without clicking through endless gallery pages one at a time.

### Why This Scraper?

- **Four discovery modes in one actor** — keyword search, category/list pages, full creator portfolios via `/p/` profile URLs, and single template pages. Mix keywords and pasted URLs in the same run.
- **Dominant color palette as hex codes** — every detail-enriched template returns its actual color swatches (e.g. `["#F4A261", "#264653", "#E76F51"]`), ready to drop into a brand-matching or trend-analysis pipeline.
- **Font detection per template** — the exact font family names used in each design, so you can map which typefaces trend in a niche.
- **Exact pixel dimensions** — width × height as a clean `"1080 x 1350 px"` string plus separate numeric `width`/`height` fields, so you instantly know each template's format.
- **Pro-vs-free flag on every row** — `isPro: true/false` lets you filter for free-tier templates or isolate premium Canva Pro designs.
- **Creator attribution with profile link** — `creatorName` plus a direct `/p/` profile URL, so you can trace a design back to its author or pull their whole catalog.
- **11 languages and locales** — English, German, French, Spanish, Italian, Portuguese, Brazilian Portuguese, Dutch, Japanese, Korean, and Simplified Chinese, with properly localized template titles.
- **Hundreds of templates enriched in seconds** — full color, font, and dimension detail is fetched for every template in parallel, so deep runs stay fast instead of crawling one page at a time.
- **One clean result cap** — a single `maxResults` knob (0 = unlimited) that never cuts a result page in half, with automatic de-duplication so the same template never appears twice.

### Use Cases

**Design Inspiration & Trend Research**
- Surface the top-ranked templates for a niche (e.g. "wedding invitation", "podcast cover") and study their layouts
- Track which color palettes dominate a category by pulling hex swatches across hundreds of templates
- Identify which fonts are trending in a design space by aggregating font names

**Competitive & Market Research**
- Map how many free vs. Pro templates Canva offers in a category using the `isPro` flag
- Compare template coverage across formats (Instagram posts, presentations, posters, resumes)
- Benchmark a brand or agency's Canva presence by pulling their full creator portfolio

**Template Sellers & Creators**
- Pull a creator's entire `/p/` portfolio in one run to audit their catalog
- Research naming and tagging patterns of top-performing templates in your category
- Build a competitive board of color and font choices before launching a new template pack

**Content & Marketing Teams**
- Bulk-collect on-brand template options for a campaign by keyword and language
- Localize a template search across 11 locales to plan multi-market content
- Feed preview images and template URLs into a creative brief or asset library

**Dataset Building for AI & ML**
- Assemble a labeled design dataset with images, color palettes, fonts, and dimensions for model training
- Build a color-palette corpus tagged by category and language
- Create a structured catalog of design metadata for recommendation or generation models

### Getting Started

#### Simple Keyword Search

The simplest run — one keyword, basic listing fields:

```json
{
    "search": ["instagram post"],
    "maxResults": 50
}
````

#### Multi-Keyword Search with Language and Details

Search several terms at once, localized, with full color/font/dimension detail:

```json
{
    "search": ["resume", "business card", "flyer"],
    "language": "de",
    "includeDetails": true,
    "maxResults": 300
}
```

#### Creator Portfolio + Category URLs

Paste Canva URLs directly — a creator profile and a category page in one run, fully enriched:

```json
{
    "startUrls": [
        "https://www.canva.com/p/yourfavoritecreator/",
        "https://www.canva.com/posters/templates/"
    ],
    "includeDetails": true,
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `search` | string\[] | `["instagram post"]` | One or more keywords to search Canva templates. Each keyword is searched separately. Leave empty if you are pasting Start URLs. |
| `startUrls` | string\[] | `[]` | Paste Canva URLs directly — search-results pages, category/list pages, creator-profile (`/p/`) pages, or a single template page. The type is detected automatically from each URL. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum templates to return across all keywords and URLs combined. Set to `0` for unlimited. The scraper stops requesting new pages once the limit is reached but keeps the full final page, so the total may slightly overshoot — it never cuts a page in half. |
| `includeDetails` | boolean | `true` | Fetch full detail for each template (dominant colors, fonts, exact dimensions, category, creator name and profile). Slower but much richer. When off, only basic listing fields are returned. |
| `language` | select | `English` | Language and locale for template results. 11 options: English, German, French, Spanish, Italian, Portuguese, Portuguese (Brazil), Dutch, Japanese, Korean, and Chinese (Simplified). |

### Output

Each row is one Canva template. With `includeDetails` on, color, font, dimension, category, and creator fields are added. Here's a representative detail-enriched result:

```json
{
    "id": "EAFwK2pT9xY",
    "url": "https://www.canva.com/templates/EAFwK2pT9xY-blue-modern-business-instagram-post/",
    "title": "Blue Modern Business Instagram Post",
    "image": "https://marketplace.canva.com/EAFwK2pT9xY/1/0/1080w/preview.jpg",
    "category": "Instagram Post",
    "breadcrumbs": ["Instagram Post"],
    "creatorName": "Studio Aurora",
    "creatorUrl": "https://www.canva.com/p/studioaurora/",
    "colors": ["#264653", "#2A9D8F", "#E9C46A", "#F4A261"],
    "fonts": ["Poppins", "Playfair Display"],
    "dimensions": "1080 x 1350 px",
    "width": 1080,
    "height": 1350,
    "isPro": false,
    "searchTerm": "instagram post"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Canva template ID |
| `url` | string | Canonical template URL on canva.com |
| `title` | string | Template title |
| `image` | string | Preview / thumbnail image URL (widest available) |
| `category` | string | Primary category / design type (e.g. "Instagram Post", "Presentation") |
| `isPro` | boolean | `true` for a Canva Pro (premium) template, `false` for a free one |
| `searchTerm` | string | The keyword or source URL this template came from |

#### Detail Fields

Populated when `includeDetails` is on (always populated for a single pasted template URL).

| Field | Type | Description |
|-------|------|-------------|
| `colors` | string\[] | Dominant color hex codes used in the template |
| `fonts` | string\[] | Font family names used in the template |
| `dimensions` | string | Template size in pixels (e.g. "1080 x 1350 px") |
| `width` | integer | Width in pixels |
| `height` | integer | Height in pixels |
| `breadcrumbs` | string\[] | Category breadcrumb trail |
| `creatorName` | string | Template creator / author name |
| `creatorUrl` | string | Direct link to the creator's Canva profile |

### Tips for Best Results

- **Start small to test** — set `maxResults` to 10–50 on your first run to confirm the data matches your needs, then scale up.
- **Broad single words maximize volume; specific phrases narrow it** — "poster" returns far more templates than "minimalist autumn book club poster". Very specific multi-word phrases fall back to fuzzy matches, so use broad terms when you want the largest possible set.
- **Paste a creator's `/p/` profile URL to pull their entire portfolio** — drop a `https://www.canva.com/p/handle/` link into `startUrls` and the scraper walks the creator's whole catalog, no keyword needed.
- **Turn off `includeDetails` for speed and depth control** — leave it off for fast keyword sweeps when you only need titles, images, and URLs; turn it on when you need color palettes, fonts, and exact dimensions.
- **Mix keywords and URLs in one run** — combine a few search terms with category pages and creator profiles in a single invocation; results are de-duplicated automatically.
- **Set the language to localize titles** — pick one of the 11 locales to get template titles in that language for multi-market planning.
- **Filter on `isPro` after the run** — pull a broad category, then split free vs. premium templates downstream using the `isPro` flag.

### Pricing

**From $5 per 1,000 results** — flat, predictable pay-per-result pricing instead of unpredictable usage billing. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.60 | $0.57 | $0.53 | $0.50 |
| 1,000 | $6.00 | $5.65 | $5.30 | $5.00 |
| 10,000 | $60.00 | $56.50 | $53.00 | $50.00 |
| 100,000 | $600.00 | $565.00 | $530.00 | $500.00 |

A "result" is any template row in the output dataset. Apify platform fees are additional and depend on your plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate design research, market analysis, and dataset building. Users are responsible for complying with applicable laws and Canva's Terms of Service, including respecting intellectual property and content usage rights for any templates and images referenced. Do not use extracted data for spam, harassment, or any illegal purpose.

# Actor input Schema

## `search` (type: `array`):

One or more keywords to search Canva templates (e.g. 'instagram post', 'resume', 'birthday poster'). Each keyword is searched separately. Leave empty if you are pasting Start URLs below.

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

Paste Canva URLs directly — search-results pages, category/list pages (e.g. https://www.canva.com/posters/templates/), creator-profile pages (e.g. https://www.canva.com/p/yourcreator/), or a single template page. The type is detected automatically from each URL.

## `maxResults` (type: `integer`):

Maximum number of templates to return across all keywords and URLs combined. Set to 0 for unlimited. Tip: start with 10-50 to test, then increase. The scraper stops requesting new pages once this limit is reached but keeps the full final page, so the total may slightly overshoot — it never cuts a page in half.

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

Fetch the full detail for each template (dominant colors, fonts, exact dimensions, creator name and profile). Slower but much richer. When off, only basic listing fields (title, image, URL, category) are returned.

## `language` (type: `string`):

Language and locale for template results.

## Actor input object example

```json
{
  "search": [
    "instagram post"
  ],
  "startUrls": [],
  "maxResults": 100,
  "includeDetails": true,
  "language": "en"
}
```

# Actor output Schema

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

Table of scraped results with key fields.

# 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 = {
    "search": [
        "instagram post"
    ],
    "startUrls": [],
    "maxResults": 100,
    "includeDetails": true,
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/canva-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 = {
    "search": ["instagram post"],
    "startUrls": [],
    "maxResults": 100,
    "includeDetails": True,
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/canva-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 '{
  "search": [
    "instagram post"
  ],
  "startUrls": [],
  "maxResults": 100,
  "includeDetails": true,
  "language": "en"
}' |
apify call solidcode/canva-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Canva Scraper",
        "description": "[💰 $5 / 1K] Extract Canva templates by keyword or URL. Get titles, creators, dominant colors, fonts, dimensions, categories, and preview images from search, category, and creator pages.",
        "version": "1.0",
        "x-build-id": "6G0FvvvUGJlngPcFr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~canva-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-canva-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/solidcode~canva-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-canva-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/solidcode~canva-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-canva-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": {
                    "search": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "One or more keywords to search Canva templates (e.g. 'instagram post', 'resume', 'birthday poster'). Each keyword is searched separately. Leave empty if you are pasting Start URLs below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste Canva URLs directly — search-results pages, category/list pages (e.g. https://www.canva.com/posters/templates/), creator-profile pages (e.g. https://www.canva.com/p/yourcreator/), or a single template page. The type is detected automatically from each URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of templates to return across all keywords and URLs combined. Set to 0 for unlimited. Tip: start with 10-50 to test, then increase. The scraper stops requesting new pages once this limit is reached but keeps the full final page, so the total may slightly overshoot — it never cuts a page in half.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Include Full Template Details",
                        "type": "boolean",
                        "description": "Fetch the full detail for each template (dominant colors, fonts, exact dimensions, creator name and profile). Slower but much richer. When off, only basic listing fields (title, image, URL, category) are returned.",
                        "default": true
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "nl",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "pt",
                            "pt-BR",
                            "ja",
                            "ko",
                            "zh-CN"
                        ],
                        "type": "string",
                        "description": "Language and locale for template results.",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
