# Unsplash Photo Scraper (`crawlerbros/unsplash-scraper`) Actor

Scrape Unsplash - curated free stock photography. Search by keyword, browse curated topics, collections, or a photographer's portfolio. Get photographer credit, image URLs, and dimensions with no API key required.

- **URL**: https://apify.com/crawlerbros/unsplash-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 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.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

## Unsplash Photo Scraper

Scrape **Unsplash** — the web's largest curated library of free-to-use professional photography. Search by keyword, browse an official curated topic, a numeric collection, or a photographer's full portfolio. Get photographer credit, license, direct image URLs, dimensions, and orientation for every photo. No API key, no login, no cookies required.

### What this actor does

- **Four modes:** `search`, `byTopic`, `byCollection`, `byUser`
- **Reliable filters:** orientation (landscape / portrait / squarish), dominant color (search mode), free-only (excludes Unsplash+ locked photos)
- **Photographer credit:** name, username, and profile URL on every photo
- **Optional deep enrichment:** license, shoot location, and publish date via an extra per-photo fetch
- **Empty fields are omitted** — every field present in a record is a real value, never `null` or an empty placeholder

### Output per photo

- `id` — Unsplash's 11-character photo ID
- `slug` — the descriptive URL slug (e.g. `a-lush-green-forest-filled-with-lots-of-trees-fWBZ9r4vO9M`)
- `title`, `description` — the photo's alt-text description
- `imageUrl` — full-resolution image URL
- `thumbnailUrl` — small preview image URL
- `width`, `height` — native pixel dimensions
- `orientation` — `landscape` / `portrait` / `squarish`, computed from the real dimensions
- `isPremium` — `true` if the photo is Unsplash+ (paid, not freely downloadable)
- `photographerUsername`, `photographerName`, `photographerProfileUrl`
- `license` — link to the photo's license terms
- `downloadUrl` — direct download link (free photos only)
- `locationName` — shoot location, if tagged (only with `fetchPhotoDetails: true`)
- `datePublished` — ISO publish date (only with `fetchPhotoDetails: true`)
- `isFamilyFriendly` — Unsplash's own safe-content flag (only with `fetchPhotoDetails: true`)
- `tags` — related keyword tags shown on the photo's page (only with `fetchPhotoDetails: true`)
- `sourceUrl` — the photo's page on unsplash.com
- `recordType: "photo"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byTopic` / `byCollection` / `byUser` |
| `searchQuery` | string | `nature` | Free-text query (mode=`search`) |
| `topicSlug` | string | – | One of Unsplash's official curated topics (mode=`byTopic`) |
| `collectionId` | string | – | Numeric Unsplash collection ID (mode=`byCollection`) |
| `username` | string | – | Photographer username, with or without `@` (mode=`byUser`) |
| `orientation` | string | `any` | `any` / `landscape` / `portrait` / `squarish` — works in every mode |
| `color` | string | `any` | Dominant color filter — only applies in `search` mode |
| `freeOnly` | boolean | `false` | Exclude Unsplash+ (paid) photos |
| `fetchPhotoDetails` | boolean | `false` | Visit each photo's page for license, location, and publish date (slower) |
| `maxItems` | int | `20` | Hard cap on emitted records (1–1000) |

### Example: search with filters

```json
{
  "mode": "search",
  "searchQuery": "mountains",
  "orientation": "landscape",
  "color": "blue",
  "freeOnly": true,
  "maxItems": 40
}
````

### Example: browse a curated topic

```json
{
  "mode": "byTopic",
  "topicSlug": "wallpapers",
  "orientation": "portrait",
  "maxItems": 30
}
```

### Example: a photographer's portfolio with full details

```json
{
  "mode": "byUser",
  "username": "v2osk",
  "fetchPhotoDetails": true,
  "maxItems": 25
}
```

### Example: a specific collection

```json
{
  "mode": "byCollection",
  "collectionId": "1065396",
  "maxItems": 50
}
```

### Use cases

- **Design & content teams** — source royalty-free photography for blog posts, presentations, and marketing assets
- **Website builders / no-code tools** — populate placeholder galleries with real, licensed imagery
- **Mood-boarding & creative research** — pull a curated topic or a favorite photographer's full portfolio in one run
- **Dataset builders** — compile labeled image sets (description, orientation, dominant subject) for ML pipelines
- **Digital asset management** — track a specific collection's contents and photographer credits over time

### Data Source / Limitations

This actor scrapes Unsplash's public search and browse pages — it does **not** use Unsplash's official registered API (which requires an API key and a rate-limited developer application). Because of that:

- Unauthenticated (no-login) search results are capped at roughly 60 photos per query before Unsplash's "Load more" control disappears. `byTopic`, `byCollection`, and `byUser` are not capped the same way and can return several hundred photos when that many genuinely exist. The actor paginates until either `maxItems` is satisfied or the source is genuinely exhausted, and stops cleanly either way (no error, no hang).
- When a filter (`orientation`, `color`, `freeOnly`) is active, the actor keeps paginating past the raw `maxItems` candidate count as needed to find enough *matching* photos — it does not stop early just because enough unfiltered candidates were seen.
- Like counts, view counts, and download counts are not shown on unsplash.com's public pages (Unsplash removed them from public view) and are therefore not in the output.
- Unsplash+ (paid, licensed-only) photos appear in results with `isPremium: true` and lack a `downloadUrl`; use `freeOnly: true` to exclude them entirely.
- `fetchPhotoDetails` adds one extra page load per photo, so runs are noticeably slower with it enabled — only turn it on when you need location/license/tags/publish-date data.

### FAQ

**Is this affiliated with Unsplash?**
No. This is an independent, third-party actor that reads Unsplash's public web pages. It is not endorsed by or affiliated with Unsplash.

**Do I need an Unsplash account, API key, or cookies?**
No. Every mode works without logging in, without an API key, and without supplying cookies.

**What's the difference between `byTopic` and `byCollection`?**
Topics are Unsplash's own official, curated categories (like "Nature" or "Wallpapers") with a fixed, small set of slugs. Collections are numbered galleries that anyone (including Unsplash's editorial team) can create — you supply the numeric ID from the collection's URL.

**Why do some photos have no `photographerProfileUrl` or `downloadUrl`?**
Every field is omitted rather than sent as empty — if a photographer's profile link isn't available for a given card, or a photo is Unsplash+ (which doesn't offer a free direct download), those fields simply won't appear on that record.

**Can I get more than ~60 results for a single search query?**
`search` mode is capped at roughly 60 photos per query for anonymous visitors — that's an Unsplash platform limit, not an actor limit. `byTopic`, `byCollection`, and `byUser` don't share that cap and can return several hundred photos (a whole collection or portfolio) in one run. For more than ~60 search results, run multiple queries (synonyms, related keywords).

**How fresh is the data?**
Every run scrapes unsplash.com live — there's no caching layer. Photo counts, ordering, and photographer details reflect what's on the site at run time.

**Does this work for orientation filtering even in `byTopic`/`byCollection`/`byUser` modes?**
Yes. Unlike the `color` filter (which only works through Unsplash's own search), `orientation` is computed directly from each photo's real pixel dimensions, so it works reliably in every mode.

# Actor input Schema

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

What to fetch.

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

Free-text query (mode=search).

## `topicSlug` (type: `string`):

One of Unsplash's official curated topics.

## `collectionId` (type: `string`):

Numeric Unsplash collection ID, e.g. `1065396` (from a collection URL `unsplash.com/collections/1065396/...`).

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

Unsplash photographer username, with or without the leading `@`, e.g. `v2osk`.

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

Only emit photos of this orientation. Computed from the photo's actual dimensions, so it applies reliably in every mode.

## `color` (type: `string`):

Dominant color filter, passed to Unsplash's own search. Ignored in other modes (the site does not support it there).

## `freeOnly` (type: `boolean`):

Exclude Unsplash+ (paid/locked) photos from results.

## `fetchPhotoDetails` (type: `boolean`):

Visit each photo's detail page to add license, location, and publish date. Slower (one extra page load per photo).

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

Hard cap on emitted records.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy override. Unsplash's Anubis proof-of-work challenge is solved client-side by the headless browser and does not require a proxy to clear; datacenter proxy IPs have been observed to make the challenge hang instead. Leave this off (default) unless you hit blocking — the actor automatically retries once with Apify Proxy if the direct connection returns zero results.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "nature",
  "orientation": "any",
  "color": "any",
  "freeOnly": false,
  "fetchPhotoDetails": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `photos` (type: `string`):

Dataset containing all scraped Unsplash photos.

# 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",
    "orientation": "any",
    "color": "any",
    "freeOnly": false,
    "fetchPhotoDetails": false,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/unsplash-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",
    "orientation": "any",
    "color": "any",
    "freeOnly": False,
    "fetchPhotoDetails": False,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/unsplash-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",
  "orientation": "any",
  "color": "any",
  "freeOnly": false,
  "fetchPhotoDetails": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call crawlerbros/unsplash-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Unsplash Photo Scraper",
        "description": "Scrape Unsplash - curated free stock photography. Search by keyword, browse curated topics, collections, or a photographer's portfolio. Get photographer credit, image URLs, and dimensions with no API key required.",
        "version": "1.0",
        "x-build-id": "0o6tSYnEAOSbrjbiU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~unsplash-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-unsplash-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~unsplash-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-unsplash-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~unsplash-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-unsplash-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",
                            "byTopic",
                            "byCollection",
                            "byUser"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query (mode=search).",
                        "default": "nature"
                    },
                    "topicSlug": {
                        "title": "Topic (mode=byTopic)",
                        "enum": [
                            "wallpapers",
                            "nature",
                            "travel",
                            "film",
                            "people",
                            "architecture-interior",
                            "street-photography",
                            "experimental",
                            "textures-patterns",
                            "3d-renders",
                            "nostalgia",
                            "summer"
                        ],
                        "type": "string",
                        "description": "One of Unsplash's official curated topics."
                    },
                    "collectionId": {
                        "title": "Collection ID (mode=byCollection)",
                        "type": "string",
                        "description": "Numeric Unsplash collection ID, e.g. `1065396` (from a collection URL `unsplash.com/collections/1065396/...`)."
                    },
                    "username": {
                        "title": "Username (mode=byUser)",
                        "type": "string",
                        "description": "Unsplash photographer username, with or without the leading `@`, e.g. `v2osk`."
                    },
                    "orientation": {
                        "title": "Orientation filter",
                        "enum": [
                            "any",
                            "landscape",
                            "portrait",
                            "squarish"
                        ],
                        "type": "string",
                        "description": "Only emit photos of this orientation. Computed from the photo's actual dimensions, so it applies reliably in every mode.",
                        "default": "any"
                    },
                    "color": {
                        "title": "Color filter (mode=search only)",
                        "enum": [
                            "any",
                            "black_and_white",
                            "black",
                            "white",
                            "yellow",
                            "orange",
                            "red",
                            "purple",
                            "magenta",
                            "green",
                            "teal",
                            "blue"
                        ],
                        "type": "string",
                        "description": "Dominant color filter, passed to Unsplash's own search. Ignored in other modes (the site does not support it there).",
                        "default": "any"
                    },
                    "freeOnly": {
                        "title": "Free photos only",
                        "type": "boolean",
                        "description": "Exclude Unsplash+ (paid/locked) photos from results.",
                        "default": false
                    },
                    "fetchPhotoDetails": {
                        "title": "Fetch extra photo details",
                        "type": "boolean",
                        "description": "Visit each photo's detail page to add license, location, and publish date. Slower (one extra page load per photo).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify proxy override. Unsplash's Anubis proof-of-work challenge is solved client-side by the headless browser and does not require a proxy to clear; datacenter proxy IPs have been observed to make the challenge hang instead. Leave this off (default) unless you hit blocking — the actor automatically retries once with Apify Proxy if the direct connection returns zero results.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```