# Pexels Scraper - Free Stock Photos & Videos (No API Key) (`memo23/pexels-scraper`) Actor

Scrape free stock photos & videos from Pexels — no API key or account needed. Direct download URLs at every size/quality, plus tags, colour palette, dimensions and the photographer's profile & socials. Search, by ID, by collection, or a photographer's whole portfolio

- **URL**: https://apify.com/memo23/pexels-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** AI, Developer tools, Agents
- **Stats:** 20 total users, 17 monthly users, 96.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Pexels Stock Photo & Video Scraper

Pull free stock **photos and videos** from [Pexels](https://www.pexels.com) at scale — **no API key, no account, nothing to sign up for**. Search by keyword, look media up by ID, grab a whole collection, or export a photographer's entire portfolio. Every row comes with direct CDN download URLs at every size and quality, plus rich metadata.

Built for content teams, ML/AI dataset builders, digital-asset workflows, and anyone who needs royalty-free imagery in bulk.

#### ✨ Why use this scraper?

- **Zero setup** — no Pexels API key or login required. Paste a query and run.
- **Photos *and* videos** — direct download links for every image size and every video rendition (with a convenience "highest quality" link).
- **Rich metadata** — tags, dominant colour + full colour palette, dimensions, aspect ratio, orientation, license, and the photographer's profile including **Instagram, location, avatar and donation link**.
- **Four ways in** — keyword search, by photo/video ID, by collection, or a photographer's full portfolio.
- **De-duplicated & pay-per-result** — you're charged per media record, nothing else.

#### How it works

1. Pick a **mode**: `search`, `curated`, `byPhotoId`, `byCollection`, `byUser`, or `similarPhotos`.
2. Fill the matching field (a query, some IDs, a collection URL, or a photographer handle) — or nothing for `curated`.
3. Set your limits and run. Results stream to the dataset — export as JSON, CSV, Excel, or via the API.

#### Modes

| Mode | What you give it | What you get |
|---|---|---|
| **search** | a keyword + media type | matching photos and/or videos |
| **curated** | nothing (just media type) | Pexels' discover feed — no query needed |
| **byPhotoId** | photo/video IDs or URLs | those exact media records |
| **byCollection** | a collection slug or URL | every item in the collection |
| **byUser** | a photographer handle/URL | that photographer's full portfolio |
| **similarPhotos** | photo IDs or URLs | photos related to each one |

**Filters** (search mode): media type, orientation, **number of people** (none / 1 / 2), min width/height, and video duration range.

#### Example input

```json
{
  "mode": "search",
  "searchQuery": "coffee",
  "mediaType": "all",
  "orientation": "landscape",
  "maxItems": 100
}
````

#### Example output (one photo row)

```json
{
  "type": "photo",
  "id": 27860686,
  "url": "https://www.pexels.com/photo/coffee-cup-27860686/",
  "title": "coffee cup",
  "description": "A beautifully crafted cappuccino with intricate latte art…",
  "width": 2763,
  "height": 3683,
  "aspectRatio": 0.75,
  "orientation": "portrait",
  "license": "Pexels",
  "tags": ["barista", "beverage", "cappuccino", "latte art", "..."],
  "mainColor": "#918c79",
  "colors": ["#000000", "#696969", "#8b4513", "#a0522d", "#a9a9a9"],
  "photographer": "FFC Aarman",
  "photographerUrl": "https://www.pexels.com/@ffc-aarman-22995634/",
  "photographerLocation": "Jammu",
  "photographerInstagram": "ffc_aarman",
  "imageOriginal": "https://images.pexels.com/photos/27860686/pexels-photo-27860686.jpeg",
  "imageLarge": "https://images.pexels.com/photos/27860686/pexels-photo-27860686.jpeg?auto=compress&cs=tinysrgb&w=1440",
  "downloadUrl": "https://images.pexels.com/photos/27860686/pexels-photo-27860686.jpeg?cs=srgb&dl=...&fm=jpg"
}
```

Video rows add `duration`, `fps`, `videoSrc`, a `videoFiles` array (every quality with width/height/fps/link), `highestQualityUrl`, and `thumbnails`.

#### Key output fields

| Field | Description |
|---|---|
| `type` | `photo` or `video` |
| `id`, `url`, `slug` | Pexels media id, page URL, slug |
| `title`, `description`, `alt` | Text metadata |
| `width`, `height`, `aspectRatio`, `orientation` | Dimensions |
| `tags` | Content tags |
| `mainColor`, `colors` | Dominant colour + palette (hex) |
| `imageOriginal` / `imageLarge` / `imageMedium` / `imageSmall` | Photo download URLs by size |
| `videoFiles`, `videoSrc`, `highestQualityUrl` | Video renditions + best link |
| `downloadUrl` | Best single download link |
| `photographer`, `photographerUrl`, `photographerLocation`, `photographerInstagram`, `photographerTwitter` | Creator profile & socials |
| `license`, `donateUrl` | License and donation link |

#### FAQ

**Do I need a Pexels API key or account?** No. The actor is self-contained.

**Can I download the actual files?** The actor returns direct CDN URLs for every size/quality — pipe them into your own downloader or asset pipeline.

**How many results per query?** Pexels caps a single search/portfolio at roughly a few hundred results; use narrower queries (or by-collection / by-user modes) to target exactly what you need.

#### ⚠️ Disclaimer

This actor collects publicly available media metadata and links from Pexels. All content is subject to the [Pexels License](https://www.pexels.com/license/) — please credit photographers where appropriate and use the content within Pexels' terms and applicable law. You are responsible for how you use the data.

# Actor input Schema

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

search = keyword search · curated = Pexels' discover feed (no query needed) · byPhotoId = look up exact photos/videos · byCollection = every item in a collection · byUser = a photographer's full portfolio · similarPhotos = photos related to the ones in Photo IDs.

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

Keyword to search (mode=search). Example: `nature`, `city skyline`, `coffee`.

## `mediaType` (type: `string`):

Which kind of media to return. `all` returns both photos and videos (search mode).

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

Maximum number of media records to return (each is one paid `result`). Default 30. Free-tier users are capped at 100. Note: Pexels caps a single search/portfolio query at roughly a few hundred results.

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

Filter by image/video orientation.

## `peopleCount` (type: `string`):

Filter photo search results by how many people appear (mode=search, photos). `all` = no filter.

## `minWidth` (type: `integer`):

Only return media at least this wide. 0 disables.

## `minHeight` (type: `integer`):

Only return media at least this tall. 0 disables.

## `minDuration` (type: `integer`):

Only return videos at least this long (videos only). 0 disables.

## `maxDuration` (type: `integer`):

Only return videos at most this long (videos only). 0 disables.

## `photoIds` (type: `array`):

Pexels media IDs or full page URLs. For mode=byPhotoId these are looked up directly; for mode=similarPhotos each is used as a seed to find related photos. Example: `27860686` or `https://www.pexels.com/photo/.../27860686/`.

## `collectionSlug` (type: `string`):

Pexels collection slug or full collection URL (mode=byCollection). Example: `aquatic-aesthetic-bw7dkse` or a full collection URL.

## `username` (type: `string`):

Photographer handle, id, or profile URL (mode=byUser). Example: `@ffc-aarman-22995634`, `22995634`, or `https://www.pexels.com/@ffc-aarman-22995634/`.

## `dedupe` (type: `boolean`):

Drop duplicate media (same type + id). Default true.

## `secretKey` (type: `string`):

The actor ships with a working built-in key. Only set this if Pexels rotates it and the actor starts returning 0 results — paste a fresh `secret-key` value here.

## `proxy` (type: `object`):

Defaults to Apify Proxy (datacenter) for cheap IP rotation. The Pexels API needs no residential proxy.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "nature",
  "mediaType": "photos",
  "maxItems": 30,
  "orientation": "all",
  "peopleCount": "all",
  "minWidth": 0,
  "minHeight": 0,
  "minDuration": 0,
  "maxDuration": 0,
  "photoIds": [
    "27860686"
  ],
  "dedupe": true,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# 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": "nature",
    "mediaType": "photos",
    "maxItems": 30,
    "orientation": "all",
    "peopleCount": "all",
    "minWidth": 0,
    "minHeight": 0,
    "minDuration": 0,
    "maxDuration": 0,
    "photoIds": [
        "27860686"
    ],
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/pexels-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": "nature",
    "mediaType": "photos",
    "maxItems": 30,
    "orientation": "all",
    "peopleCount": "all",
    "minWidth": 0,
    "minHeight": 0,
    "minDuration": 0,
    "maxDuration": 0,
    "photoIds": ["27860686"],
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/pexels-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": "nature",
  "mediaType": "photos",
  "maxItems": 30,
  "orientation": "all",
  "peopleCount": "all",
  "minWidth": 0,
  "minHeight": 0,
  "minDuration": 0,
  "maxDuration": 0,
  "photoIds": [
    "27860686"
  ],
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call memo23/pexels-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pexels Scraper - Free Stock Photos & Videos (No API Key)",
        "description": "Scrape free stock photos & videos from Pexels — no API key or account needed. Direct download URLs at every size/quality, plus tags, colour palette, dimensions and the photographer's profile & socials. Search, by ID, by collection, or a photographer's whole portfolio",
        "version": "0.1",
        "x-build-id": "m3jhY3fc9dK9H9ByR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~pexels-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-pexels-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/memo23~pexels-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-pexels-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/memo23~pexels-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-pexels-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",
                            "curated",
                            "byPhotoId",
                            "byCollection",
                            "byUser",
                            "similarPhotos"
                        ],
                        "type": "string",
                        "description": "search = keyword search · curated = Pexels' discover feed (no query needed) · byPhotoId = look up exact photos/videos · byCollection = every item in a collection · byUser = a photographer's full portfolio · similarPhotos = photos related to the ones in Photo IDs.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword to search (mode=search). Example: `nature`, `city skyline`, `coffee`."
                    },
                    "mediaType": {
                        "title": "Media type",
                        "enum": [
                            "photos",
                            "videos",
                            "all"
                        ],
                        "type": "string",
                        "description": "Which kind of media to return. `all` returns both photos and videos (search mode).",
                        "default": "photos"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of media records to return (each is one paid `result`). Default 30. Free-tier users are capped at 100. Note: Pexels caps a single search/portfolio query at roughly a few hundred results.",
                        "default": 30
                    },
                    "orientation": {
                        "title": "Orientation",
                        "enum": [
                            "all",
                            "landscape",
                            "portrait",
                            "square"
                        ],
                        "type": "string",
                        "description": "Filter by image/video orientation.",
                        "default": "all"
                    },
                    "peopleCount": {
                        "title": "Number of people",
                        "enum": [
                            "all",
                            "0",
                            "1",
                            "2"
                        ],
                        "type": "string",
                        "description": "Filter photo search results by how many people appear (mode=search, photos). `all` = no filter.",
                        "default": "all"
                    },
                    "minWidth": {
                        "title": "Minimum width (px)",
                        "type": "integer",
                        "description": "Only return media at least this wide. 0 disables.",
                        "default": 0
                    },
                    "minHeight": {
                        "title": "Minimum height (px)",
                        "type": "integer",
                        "description": "Only return media at least this tall. 0 disables.",
                        "default": 0
                    },
                    "minDuration": {
                        "title": "Minimum video duration (s)",
                        "type": "integer",
                        "description": "Only return videos at least this long (videos only). 0 disables.",
                        "default": 0
                    },
                    "maxDuration": {
                        "title": "Maximum video duration (s)",
                        "type": "integer",
                        "description": "Only return videos at most this long (videos only). 0 disables.",
                        "default": 0
                    },
                    "photoIds": {
                        "title": "Photo / video IDs or URLs",
                        "type": "array",
                        "description": "Pexels media IDs or full page URLs. For mode=byPhotoId these are looked up directly; for mode=similarPhotos each is used as a seed to find related photos. Example: `27860686` or `https://www.pexels.com/photo/.../27860686/`.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "collectionSlug": {
                        "title": "Collection slug or URL",
                        "type": "string",
                        "description": "Pexels collection slug or full collection URL (mode=byCollection). Example: `aquatic-aesthetic-bw7dkse` or a full collection URL."
                    },
                    "username": {
                        "title": "Photographer handle / URL",
                        "type": "string",
                        "description": "Photographer handle, id, or profile URL (mode=byUser). Example: `@ffc-aarman-22995634`, `22995634`, or `https://www.pexels.com/@ffc-aarman-22995634/`."
                    },
                    "dedupe": {
                        "title": "De-duplicate",
                        "type": "boolean",
                        "description": "Drop duplicate media (same type + id). Default true.",
                        "default": true
                    },
                    "secretKey": {
                        "title": "Secret-key override (rarely needed)",
                        "type": "string",
                        "description": "The actor ships with a working built-in key. Only set this if Pexels rotates it and the actor starts returning 0 results — paste a fresh `secret-key` value here."
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Defaults to Apify Proxy (datacenter) for cheap IP rotation. The Pexels API needs no residential proxy.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
