# iQiyi Video Scraper (`automation-lab/iqiyi-video-scraper`) Actor

🎬 Extract public iQiyi search/video metadata: titles, thumbnails, channels, uploaders, duration, scores, tags, play counts, and URLs.

- **URL**: https://apify.com/automation-lab/iqiyi-video-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% 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.
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

## iQiyi Video Scraper

Extract public iQiyi video search metadata at scale. This actor turns iQiyi keyword searches and public search URLs into structured records with titles, source URLs, thumbnails, channels, uploaders, durations, scores, tags, popularity signals, and scrape timestamps.

### What does iQiyi Video Scraper do?

The actor searches public iQiyi pages and returns clean dataset rows for video intelligence workflows.

It can collect:

- 🎬 long-form title and album cards
- 📹 short-video search results
- 🖼️ cover and thumbnail URLs
- 🏷️ categories, tags, scores, and year metadata
- 👤 uploader names when iQiyi exposes them
- 🔗 direct iQiyi source URLs
- ⏱️ duration and publish/upload date signals

### Who is it for?

Media analysts use it to monitor Chinese streaming catalog trends.

Localization teams use it to track titles, thumbnails, and content categories before campaign planning.

Entertainment researchers use it to compare iQiyi visibility for movies, dramas, documentaries, anime, and short-video topics.

Social/video monitoring teams use it to export public iQiyi metadata into BI tools, alerts, spreadsheets, or enrichment pipelines.

### Why use this actor?

Manual iQiyi search checks are slow and hard to compare over time. This actor gives you repeatable, exportable results from the same public search surface.

Use it when you need:

- recurring keyword monitoring
- structured title discovery
- competitor/content intelligence
- short-video metadata exports
- dataset-ready URLs for downstream review

### How much does it cost to scrape iQiyi videos?

This actor uses pay-per-event pricing. You pay a small run-start fee and then a per-result fee only for records saved to the dataset.

Current event prices are:

| Event | Price |
|---|---:|
| Run started | $0.005 per run |
| Item extracted, FREE tier | about $0.0000436 per saved record |
| Item extracted, BRONZE tier | about $0.0000379 per saved record |
| Item extracted, SILVER tier | about $0.0000296 per saved record |
| Item extracted, GOLD tier | about $0.0000227 per saved record |
| Item extracted, PLATINUM tier | about $0.0000152 per saved record |
| Item extracted, DIAMOND tier | about $0.0000106 per saved record |

Example FREE-tier costs:

| Run size | Approximate cost |
|---|---:|
| 20 results, default test run | about $0.0059 |
| 100 results | about $0.0094 |
| 150 results | about $0.0115 |
| 1,000 results | about $0.0486 |

If your Apify account includes $5 in free monthly platform credits, that covers roughly 840 default 20-result test runs or about 100,000 results in larger batches before other platform usage is counted.

The default input is intentionally small so a first test run is cheap. Increase `maxItems` only after the sample output matches your workflow.

### Input options

| Field | Type | Description |
|---|---|---|
| `searchTerms` | string array | Keywords to search on iQiyi |
| `startUrls` | URL array | iQiyi search URLs like `/so/q_电影` or direct video URLs |
| `contentTypes` | array | Choose `album`, `shortVideo`, or both |
| `maxItems` | integer | Maximum dataset records across all inputs |
| `pageSize` | integer | Number of results requested per iQiyi API page |

### Output data

| Field | Description |
|---|---|
| `searchTerm` | Keyword used to find the result |
| `sourceUrl` | Search or input URL that produced the result |
| `title` | iQiyi video/title text |
| `url` | Public iQiyi result URL |
| `contentType` | `album`, `shortVideo`, or `videoUrl` |
| `thumbnailUrl` | Cover image URL |
| `description` | Public snippet or brief |
| `channel` | iQiyi channel/category |
| `uploader` | Public uploader name when available |
| `publishDate` | Public publish date when available |
| `uploadTime` | Relative upload time when available |
| `durationSeconds` | Duration normalized to seconds |
| `year` | Year/subtitle signal exposed by iQiyi |
| `score` | Score/rating when visible |
| `tags` | iQiyi tags and category labels |
| `playCount` | Public play/popularity signal when visible |
| `qipuId` | iQiyi internal content ID |
| `isVip` | Whether the card appears to be VIP/paywalled |
| `scrapedAt` | ISO timestamp for the scrape |

### Example output

```json
{
  "searchTerm": "电影",
  "title": "万米危机",
  "url": "https://www.iqiyi.com/v_2az3amxqym4.html",
  "contentType": "album",
  "thumbnailUrl": "https://pic0.iqiyipic.com/image/...jpg",
  "description": "释小龙PK跨国悍匪",
  "channel": "电影",
  "year": "2026",
  "score": "7.7",
  "tags": ["近1周上新", "动作犯罪", "灾难"],
  "isVip": true,
  "scrapedAt": "2026-07-08T03:52:34.530Z"
}
````

### How to scrape iQiyi search results

1. Add one or more keywords to `searchTerms`.
2. Keep `maxItems` low for the first run.
3. Choose whether you need albums, short videos, or both.
4. Run the actor.
5. Export the dataset as JSON, CSV, Excel, XML, RSS, or HTML.

### Search URL workflow

You can paste an iQiyi search URL into `startUrls`, for example:

```text
https://www.iqiyi.com/so/q_%E7%94%B5%E5%BD%B1
```

The actor extracts the keyword from the URL and uses the same structured search pipeline.

### Direct video URL workflow

You can also submit a direct public iQiyi video URL. Direct URLs are fetched for basic title, description, thumbnail, and source URL metadata.

For richer discovery, use keyword searches because iQiyi exposes more structured fields on search result cards.

### Tips for better results

- Use Chinese keywords for strongest iQiyi coverage.
- Run separate keywords for each category you want to compare.
- Use `contentTypes: ["album"]` when you only need long-form titles.
- Use `contentTypes: ["shortVideo"]` when monitoring social/video clips.
- Keep `pageSize` at 25 unless you need faster large runs.

### Integrations

Common workflows include:

- exporting iQiyi metadata to Google Sheets
- feeding title URLs into media monitoring dashboards
- enriching CRM or research tables with thumbnails and categories
- scheduling keyword monitoring and comparing datasets over time
- sending new records to Slack, Make, Zapier, or webhooks

### API usage: Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/iqiyi-video-scraper').call({
  searchTerms: ['电影', '纪录片'],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

### API usage: Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/iqiyi-video-scraper').call(run_input={
    'searchTerms': ['电影', '纪录片'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage: cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~iqiyi-video-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["电影"],"maxItems":50}'
```

### MCP integration

Use this actor from Claude Desktop or Claude Code through Apify MCP:

```text
https://mcp.apify.com/?tools=automation-lab/iqiyi-video-scraper
```

Claude Code setup:

```bash
claude mcp add --transport http apify https://mcp.apify.com/?tools=automation-lab/iqiyi-video-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/iqiyi-video-scraper"
    }
  }
}
```

Example prompts:

- "Search iQiyi for new documentary titles and summarize the top records."
- "Export iQiyi short videos for this keyword and group them by uploader."
- "Monitor iQiyi search results for these movie terms every week."

### Data quality notes

The actor extracts only public metadata that iQiyi exposes to unauthenticated visitors. Some cards do not include every optional field, so fields like uploader, play count, score, or publish date may be empty for certain result types.

### Limitations

This actor does not log in, bypass paywalls, download video files, or extract private user data. It is designed for public metadata collection, not media downloading.

### Troubleshooting

If you get fewer records than expected, broaden the keyword, enable both content types, or increase `maxItems`.

If a direct video URL returns sparse metadata, try the matching keyword search URL instead because iQiyi search cards often expose richer public fields.

### Legality

This actor collects publicly available metadata. You are responsible for ensuring your use case complies with applicable laws, iQiyi terms, and privacy requirements. Do not use the actor to collect private data, bypass access controls, or redistribute copyrighted media.

### Related scrapers

Explore other Automation Lab media and video actors:

- https://apify.com/automation-lab/bilibili-scraper
- https://apify.com/automation-lab/rumble-channel-video-intelligence-scraper
- https://apify.com/automation-lab/vimeo-user-videos-scraper
- https://apify.com/automation-lab/youtube-trending-videos-scraper

### FAQ

#### Can it download iQiyi videos?

No. It extracts public metadata and source URLs only.

#### Does it require an iQiyi account?

No. The actor uses public unauthenticated search surfaces.

#### Can I schedule recurring monitoring?

Yes. Create an Apify task with your search terms and schedule it hourly, daily, weekly, or monthly.

#### What languages are supported?

Any keyword can be submitted, but Chinese search terms usually produce the strongest iQiyi coverage.

### Changelog

- 0.1.0: Initial public metadata extractor for iQiyi search and video URLs.

### Support

Open an Apify issue if a public iQiyi page stops returning expected metadata or if you need an additional output field from visible search cards.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search on iQiyi, such as movie genres, show titles, creators, or monitoring terms.

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

Optional iQiyi search result URLs (for example /so/q\_电影) or direct video URLs to scrape.

## `contentTypes` (type: `array`):

Choose whether to collect long-form album/title cards, short videos, or both.

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

Maximum dataset records to emit across all searches and URLs.

## `pageSize` (type: `integer`):

How many results to request from iQiyi per API page. Larger values are faster but less conservative.

## Actor input object example

```json
{
  "searchTerms": [
    "电影",
    "纪录片"
  ],
  "startUrls": [
    {
      "url": "https://www.iqiyi.com/so/q_%E7%94%B5%E5%BD%B1"
    }
  ],
  "contentTypes": [
    "album",
    "shortVideo"
  ],
  "maxItems": 20,
  "pageSize": 25
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchTerms": [
        "电影",
        "纪录片"
    ],
    "startUrls": [
        {
            "url": "https://www.iqiyi.com/so/q_%E7%94%B5%E5%BD%B1"
        }
    ],
    "contentTypes": [
        "album",
        "shortVideo"
    ],
    "maxItems": 20,
    "pageSize": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/iqiyi-video-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 = {
    "searchTerms": [
        "电影",
        "纪录片",
    ],
    "startUrls": [{ "url": "https://www.iqiyi.com/so/q_%E7%94%B5%E5%BD%B1" }],
    "contentTypes": [
        "album",
        "shortVideo",
    ],
    "maxItems": 20,
    "pageSize": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/iqiyi-video-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 '{
  "searchTerms": [
    "电影",
    "纪录片"
  ],
  "startUrls": [
    {
      "url": "https://www.iqiyi.com/so/q_%E7%94%B5%E5%BD%B1"
    }
  ],
  "contentTypes": [
    "album",
    "shortVideo"
  ],
  "maxItems": 20,
  "pageSize": 25
}' |
apify call automation-lab/iqiyi-video-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "iQiyi Video Scraper",
        "description": "🎬 Extract public iQiyi search/video metadata: titles, thumbnails, channels, uploaders, duration, scores, tags, play counts, and URLs.",
        "version": "0.1",
        "x-build-id": "XGinRucnJyhXJJJ0X"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~iqiyi-video-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-iqiyi-video-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/automation-lab~iqiyi-video-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-iqiyi-video-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/automation-lab~iqiyi-video-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-iqiyi-video-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search on iQiyi, such as movie genres, show titles, creators, or monitoring terms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "iQiyi search or video URLs",
                        "type": "array",
                        "description": "Optional iQiyi search result URLs (for example /so/q_电影) or direct video URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "contentTypes": {
                        "title": "Content types",
                        "type": "array",
                        "description": "Choose whether to collect long-form album/title cards, short videos, or both.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "album",
                                "shortVideo"
                            ],
                            "enumTitles": [
                                "Albums / titles",
                                "Short videos"
                            ]
                        },
                        "default": [
                            "album",
                            "shortVideo"
                        ]
                    },
                    "maxItems": {
                        "title": "Maximum items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum dataset records to emit across all searches and URLs.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "API page size",
                        "minimum": 5,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many results to request from iQiyi per API page. Larger values are faster but less conservative.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```