# Vecteezy Scraper (`crawlerbros/vecteezy-scraper`) Actor

Scrape Vecteezy's free stock marketplace - search or browse vectors, photos, videos, PSDs, SVGs and PNGs by keyword or category. Get titles, thumbnail/preview URLs, license type, contributor info, and asset detail lookups by URL.

- **URL**: https://apify.com/crawlerbros/vecteezy-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, SEO tools
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.
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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Vecteezy Scraper

Scrape [Vecteezy](https://www.vecteezy.com)'s free stock marketplace — vectors, photos, videos, PSD templates, SVGs, PNGs, editable templates, motion graphics, and editorial photos/events. Search or browse by keyword/category, filter by license, orientation, sort order, and color, browse a contributor's full upload catalog, and look up rich asset details (including related keywords) from a direct URL. Every search/browse page on Vecteezy is fully server-rendered, so this actor runs on plain HTTP (no browser automation, no login, no proxy required) — it just needs a browser-realistic TLS handshake to get past Cloudflare's fingerprint check.

### What this actor does

- **Three modes:** `search` (keyword search or category browsing — Vecteezy treats both the same way), `assetDetail` (lookup by direct asset URL, enriched with related keywords), and `byAuthor` (every asset uploaded by a given contributor)
- **Content types:** vectors, photos, videos, PSD templates, SVGs, PNGs, editable templates, motion graphics, editorial photos, editorial event galleries
- **Filters:** license (free / pro / editorial), sort order (best match / newest), orientation (horizontal / vertical / square / panoramic), dominant color (hex)
- **Contributor info:** author name, profile URL, avatar, and (in `assetDetail` mode) total resource count
- **Empty fields are omitted**

### Output per asset

- `assetId` — numeric Vecteezy resource ID
- `title`
- `assetType` — `vector` / `photo` / `video` / `psd` / `png` / `bundle` / `editor_template` / `motion_graphic` / `editorial_image` / `editorial_event` / `editorial` (URL-only detail lookups, where the sub-type can't be told apart)
- `isPro` — `true` for Pro-license assets, `false` for free (`search`/`byAuthor` modes only)
- `sourceUrl` — canonical asset page URL
- `thumbnailUrl`, `previewUrl` — CDN image/video URLs
- `previewWidth`, `previewHeight` — thumbnail pixel dimensions (`search`/`byAuthor` modes only)
- `licenseUrl` — Vecteezy license terms page
- `uploadDate`
- `authorName`, `authorProfileUrl`, `authorAvatarUrl`
- `authorId` — numeric contributor ID (`search`/`byAuthor` modes only)
- `authorResourceCount` — total assets by this contributor (`assetDetail` mode only)
- `keywords` — related search keywords for the asset (`assetDetail` mode only)
- `recordType: "asset"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `assetDetail` / `byAuthor` |
| `searchQuery` | string | `business` | Keyword or category slug (mode=search) |
| `contentType` | string | `vector` | `vector` / `photo` / `video` / `psd` / `svg` / `png` / `editor_template` / `motion_graphic` / `editorial_image` / `editorial_event` |
| `license` | string | `all` | `all` / `free` / `pro` / `editorial` |
| `sortBy` | string | `best` | `best` / `newest` |
| `orientation` | string | `all` | `all` / `horizontal` / `vertical` / `square` / `panoramic` |
| `colorHex` | string | – | Dominant color hex, e.g. `ff0000` |
| `assetUrls` | array | – | Full asset URLs (mode=assetDetail); not supported for `/edit/...` template URLs |
| `authorUsername` | string | `paintingred` | Contributor username or profile URL (mode=byAuthor) |
| `maxItems` | int | `50` | Hard cap (1–1000) |

#### Example: newest free photos, vertical orientation

```json
{
  "mode": "search",
  "searchQuery": "nature",
  "contentType": "photo",
  "license": "free",
  "sortBy": "newest",
  "orientation": "vertical",
  "maxItems": 100
}
````

#### Example: browse a vector category

```json
{
  "mode": "search",
  "searchQuery": "business",
  "contentType": "vector",
  "maxItems": 50
}
```

#### Example: asset detail lookup

```json
{
  "mode": "assetDetail",
  "assetUrls": [
    "https://www.vecteezy.com/vector-art/141739-business-icons"
  ]
}
```

#### Example: browse editable templates

```json
{
  "mode": "search",
  "searchQuery": "business card",
  "contentType": "editor_template",
  "maxItems": 50
}
```

#### Example: browse a contributor's full upload catalog

```json
{
  "mode": "byAuthor",
  "authorUsername": "paintingred",
  "maxItems": 100
}
```

### Use cases

- **Design research** — survey what stock assets exist for a given topic/niche before commissioning custom work
- **Content curation** — build mood boards or reference sets from free/Pro asset metadata
- **Marketplace monitoring** — track new uploads (`sortBy: newest`) in a category over time
- **Licensing audits** — verify license type and terms URL for assets already in use
- **Contributor research** — look up a creator's total resource count and profile via `assetDetail`, or pull their entire portfolio via `byAuthor`
- **Template sourcing** — find editable business-card/resume/flyer templates via `contentType: editor_template`
- **Video production** — source motion graphics overlays/presets via `contentType: motion_graphic`
- **Editorial/news research** — pull editorial (non-commercial-license) photos and event galleries via `contentType: editorial_image` / `editorial_event`
- **Keyword research** — mine an asset's related keywords (`keywords` field, `assetDetail` mode) to see how Vecteezy's own tagging associates a topic

### FAQ

**Does this require a Vecteezy account or API key?**  No. All fields come from Vecteezy's public search/browse pages and asset detail pages, which are visible to anonymous visitors.

**What's the difference between `search` mode with a keyword vs a category name?**  None — Vecteezy's search and category-browse pages share the same URL pattern (`/free-{type}/{term}`), so passing a category slug (e.g. `business`) as `searchQuery` browses that category, while a free-text keyword searches it.

**Why does an SVG search return `assetType: "vector"`?**  SVGs are a vector sub-format on Vecteezy; the site tags them internally as `vector` even though the browse URL (`/free-svg/...`) and download format differ. The `contentType` input still correctly scopes the search to SVG-capable assets.

**Can I get download counts or likes?**  No — Vecteezy doesn't expose these on public pages (they load only for logged-in/Pro accounts), so the actor never fabricates them.

**What does `colorHex` actually filter?**  It biases Vecteezy's own color-similarity ranking toward the given hex value; it's not a strict binary include/exclude filter, since Vecteezy computes it as a similarity threshold server-side.

**Is `isPro` populated in `assetDetail` mode?**  No — the asset detail page doesn't expose a clean free/Pro flag the way grid pages do, so `assetDetail` records omit `isPro` rather than guessing.

**Can I look up an editable template (`contentType: editor_template`) by URL in `assetDetail` mode?**  No. Template asset pages (`/edit/{uuid}`) are a client-rendered editor tool with no server-side asset metadata in the initial HTML — Vecteezy only serves a generic "Vecteezy Editor" placeholder there. Templates are fully covered (title, thumbnails, license, author, dimensions) via `mode: search` with `contentType: editor_template` instead; `assetDetail` simply skips `/edit/...` URLs rather than emit an incomplete/inaccurate record.

**Does `byAuthor` mode respect the `contentType` filter?**  No — a contributor's `/uploads` page mixes every content type they've published (vectors, photos, templates, etc.), which matches Vecteezy's own page behavior. `license` and `maxItems` still apply.

**Why does `assetType: "editorial"` show up instead of `editorial_image`/`editorial_event`?**  Only in `assetDetail` mode. Vecteezy's editorial detail pages report identical JSON-LD (`ImageObject`) for both sub-types, so the URL path alone can't tell them apart. `search`/`byAuthor` mode results are always precisely `editorial_image` or `editorial_event`, since that comes from the grid item's own type attribute, not the URL.

**Is there an "AI-generated" filter?**  Vecteezy's search UI shows an "AI Generated" filter checkbox, but it was verified (live, side-by-side request comparison) to have no effect on the server-rendered result set when requested via plain HTTP — it only works through the site's client-side JavaScript. Since it can't be reliably applied, this actor does not expose it rather than ship a filter that silently does nothing.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `searchQuery` (type: `string`):

Free-text keyword (e.g. `nature`) or a category slug (e.g. `business`). Vecteezy treats both the same way, so this also covers category browsing (mode=search).

## `contentType` (type: `string`):

Asset type to search within (mode=search).

## `license` (type: `string`):

Restrict results by license type (mode=search).

## `sortBy` (type: `string`):

Result ordering (mode=search).

## `orientation` (type: `string`):

Restrict results by thumbnail orientation (mode=search).

## `colorHex` (type: `string`):

Bias results toward a dominant color, e.g. `ff0000` for red. Leave blank to ignore color (mode=search).

## `assetUrls` (type: `array`):

Full Vecteezy asset URLs to fetch details for, e.g. `https://www.vecteezy.com/vector-art/141739-business-icons`. Not supported for editable-template URLs (`/edit/...`) — those are only available via mode=search with contentType=editor\_template.

## `authorUsername` (type: `string`):

A Vecteezy contributor's username or profile URL, e.g. `paintingred` or `https://www.vecteezy.com/members/paintingred`. Returns every asset uploaded by that contributor across all content types.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "business",
  "contentType": "vector",
  "license": "all",
  "sortBy": "best",
  "orientation": "all",
  "assetUrls": [],
  "authorUsername": "paintingred",
  "maxItems": 50
}
```

# Actor output Schema

## `assets` (type: `string`):

Dataset containing all scraped Vecteezy assets.

# 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 = {
    "mode": "search",
    "searchQuery": "business",
    "contentType": "vector",
    "license": "all",
    "sortBy": "best",
    "orientation": "all",
    "assetUrls": [],
    "authorUsername": "paintingred",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/vecteezy-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 = {
    "mode": "search",
    "searchQuery": "business",
    "contentType": "vector",
    "license": "all",
    "sortBy": "best",
    "orientation": "all",
    "assetUrls": [],
    "authorUsername": "paintingred",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/vecteezy-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 '{
  "mode": "search",
  "searchQuery": "business",
  "contentType": "vector",
  "license": "all",
  "sortBy": "best",
  "orientation": "all",
  "assetUrls": [],
  "authorUsername": "paintingred",
  "maxItems": 50
}' |
apify call crawlerbros/vecteezy-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Vecteezy Scraper",
        "description": "Scrape Vecteezy's free stock marketplace - search or browse vectors, photos, videos, PSDs, SVGs and PNGs by keyword or category. Get titles, thumbnail/preview URLs, license type, contributor info, and asset detail lookups by URL.",
        "version": "1.0",
        "x-build-id": "NZZVWBmVWbrVmtWwy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~vecteezy-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-vecteezy-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/crawlerbros~vecteezy-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-vecteezy-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/crawlerbros~vecteezy-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-vecteezy-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "assetDetail",
                            "byAuthor"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query or category",
                        "type": "string",
                        "description": "Free-text keyword (e.g. `nature`) or a category slug (e.g. `business`). Vecteezy treats both the same way, so this also covers category browsing (mode=search).",
                        "default": "business"
                    },
                    "contentType": {
                        "title": "Content type",
                        "enum": [
                            "vector",
                            "photo",
                            "video",
                            "psd",
                            "svg",
                            "png",
                            "editor_template",
                            "motion_graphic",
                            "editorial_image",
                            "editorial_event"
                        ],
                        "type": "string",
                        "description": "Asset type to search within (mode=search).",
                        "default": "vector"
                    },
                    "license": {
                        "title": "License filter",
                        "enum": [
                            "all",
                            "free",
                            "pro",
                            "editorial"
                        ],
                        "type": "string",
                        "description": "Restrict results by license type (mode=search).",
                        "default": "all"
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "best",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Result ordering (mode=search).",
                        "default": "best"
                    },
                    "orientation": {
                        "title": "Orientation filter",
                        "enum": [
                            "all",
                            "horizontal",
                            "vertical",
                            "square",
                            "panoramic"
                        ],
                        "type": "string",
                        "description": "Restrict results by thumbnail orientation (mode=search).",
                        "default": "all"
                    },
                    "colorHex": {
                        "title": "Dominant color (hex, optional)",
                        "type": "string",
                        "description": "Bias results toward a dominant color, e.g. `ff0000` for red. Leave blank to ignore color (mode=search)."
                    },
                    "assetUrls": {
                        "title": "Asset URLs (mode=assetDetail)",
                        "type": "array",
                        "description": "Full Vecteezy asset URLs to fetch details for, e.g. `https://www.vecteezy.com/vector-art/141739-business-icons`. Not supported for editable-template URLs (`/edit/...`) — those are only available via mode=search with contentType=editor_template.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "authorUsername": {
                        "title": "Contributor username (mode=byAuthor)",
                        "type": "string",
                        "description": "A Vecteezy contributor's username or profile URL, e.g. `paintingred` or `https://www.vecteezy.com/members/paintingred`. Returns every asset uploaded by that contributor across all content types."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```