# Tiktok Profile Scraper (`crawlerbros/tiktok-profile-scraper`) Actor

Scrape TikTok profiles and their video or repost history.

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

## TikTok Profile Scraper

Scrape TikTok profiles and their video or repost history. The actor emits a profile row (rowType=profile) with full account metadata and then individual post rows (rowType=video or rowType=repost) for each piece of content. Without a session cookie the actor returns profile info plus approximately 14 recent videos from search; with a sessionCookie it can retrieve the full video history up to 500 posts. Reposts are available without a cookie.

### What this actor does

- Accepts TikTok usernames (with or without @) and/or full profile URLs
- Emits a dedicated profile row per account with follower/following/like/video counts and account settings
- Emits separate post rows for each video or repost, selectable via `contentTypes`
- Retrieves up to ~14 recent videos without authentication via search fallback
- With a `sessionCookie` or full `cookies` export, retrieves the complete video history (up to 500 posts)
- Reposts (videos the user has shared from other creators) are extracted without a cookie
- Empty fields are omitted

### Output per profile row

- `rowType` — always `"profile"` for profile rows
- `userId` — TikTok user ID
- `secUid` — TikTok secUid
- `username` — @handle
- `displayName` — display name / nickname
- `verified` — verification badge status
- `privateAccount` — whether the account is private
- `bio` — profile bio text
- `bioLink` — clickable link in bio (if set)
- `followerCount` — total followers
- `followingCount` — total accounts followed
- `heartCount` — total likes received across all videos
- `videoCount` — number of public videos
- `avatarLarger` — large avatar image URL
- `avatarMedium` — medium avatar image URL
- `createTime` — account creation Unix timestamp
- `commentSetting` — comment permission setting
- `duetSetting` — duet permission setting
- `stitchSetting` — stitch permission setting
- `profileUrl` — canonical TikTok profile URL
- `scrapedAt` — ISO 8601 scrape timestamp

### Output per video/repost row

- `rowType` — `"video"` or `"repost"`
- `contentKind` — same as rowType for filtering convenience
- `postId` — unique post ID
- `postUrl` — canonical post URL
- `caption` — post caption text
- `createTime` — Unix publication timestamp
- `likeCount` — total likes
- `commentCount` — total comments
- `shareCount` — total shares
- `playCount` — total plays/views
- `author.id` — video author's user ID
- `author.username` — video author's @handle
- `author.displayName` — video author's display name
- `author.verified` — author verification status
- `music.id` — music ID
- `music.title` — music name
- `music.authorName` — music artist
- `video.width` — video width
- `video.height` — video height
- `video.duration` — video duration in seconds
- `hashtags` — array of `{id, name}` hashtag objects
- `profileUsername` — the queried username that produced this row
- `scrapedAt` — ISO 8601 scrape timestamp

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `usernames` | array | — | TikTok usernames to scrape (with or without @) |
| `profileUrls` | array | — | Full TikTok profile URLs as alternative or additional input |
| `contentTypes` | array | `["profile","videos"]` | Which rows to emit: any combination of `"profile"`, `"videos"`, `"reposts"` |
| `maxPostsPerProfile` | integer | `30` | Maximum post rows per profile (0 = skip posts) |
| `includeProfileInfo` | boolean | `true` | Include profile metadata in the profile row |
| `sessionCookie` | string | — | TikTok `sessionid` cookie value — required for full video history |
| `cookies` | array | — | Full browser cookie export as JSON array (Cookie-Editor format) |
| `ttwid` | string | — | TikTok `ttwid` device cookie — enables immediate video listing |

#### Example: Profile info and recent videos (no cookie)

```json
{
  "usernames": ["natgeo"],
  "contentTypes": ["profile", "videos"],
  "maxPostsPerProfile": 10
}
````

#### Example: Reposts only

```json
{
  "usernames": ["khaby.lame", "charlidamelio"],
  "contentTypes": ["reposts"],
  "maxPostsPerProfile": 50
}
```

#### Example: Full video history with session cookie

```json
{
  "usernames": ["natgeo"],
  "contentTypes": ["profile", "videos"],
  "maxPostsPerProfile": 200,
  "sessionCookie": "your_sessionid_value_here"
}
```

#### Example: Multiple profiles — profile metadata only

```json
{
  "usernames": ["natgeo", "bbcnews", "cnn"],
  "contentTypes": ["profile"],
  "maxPostsPerProfile": 0
}
```

### Use cases

- **Influencer research** — pull profile stats and recent video performance for creator discovery and vetting
- **Competitive benchmarking** — track a competitor brand account's posting frequency and engagement trends over time
- **Audience and content auditing** — export a creator's complete video history for content strategy or brand safety review
- **Repost tracking** — identify what external content a creator is amplifying through reposts
- **Social media archival** — build structured archives of public TikTok accounts for research or compliance purposes
- **Agency reporting** — collect cross-account profile snapshots for client portfolio dashboards

### FAQ

**Do I need a TikTok account or cookies?**
Not for profile metadata or reposts. For the complete video list you need a `sessionCookie` or full `cookies` export, because TikTok's video listing API blocks unauthenticated datacenter requests.

**How many videos can I get without a cookie?**
Approximately 14 recent videos are available via TikTok's public search fallback. For full history, provide a `sessionCookie`.

**How do I get my sessionCookie?**
Install the Cookie-Editor browser extension, log into TikTok, click the icon, find the cookie named `sessionid`, and copy its value. Paste that value into the `sessionCookie` field.

**What is the difference between `sessionCookie` and `cookies`?**
`sessionCookie` accepts only the `sessionid` value and is sufficient for follower/repost mode. `cookies` accepts the full browser cookie export (Cookie-Editor JSON format) and provides the complete session context including `msToken` and `ttwid` — this gives the most reliable video list retrieval.

**What is `ttwid`?**
A non-personal device tracking cookie from TikTok. Providing your browser's `ttwid` value lets the actor bypass the typical 7-day device-aging period that TikTok applies to new (unknown) devices. Find it in browser DevTools under Application → Cookies → tiktok.com.

**What is a repost?**
A video from another creator that the profile owner has re-shared to their own followers using TikTok's repost feature. The original author and post ID are preserved in the output.

**What does `includeProfileInfo: false` do?**
The profile row is still emitted but without the detailed metadata fields (follower counts, bio, settings). Useful when you only want the post rows.

**Can I scrape private accounts?**
Profile metadata for private accounts is visible, but their video grid is not accessible without being an approved follower.

### Related TikTok Scrapers

Build a complete TikTok data pipeline with our full suite:

| Scraper | URL |
|---|---|
| TikTok Post Scraper | https://apify.com/crawlerbros/tiktok-post-scraper |
| TikTok Comments Scraper | https://apify.com/crawlerbros/tiktok-comments-scraper |
| TikTok Search Scraper | https://apify.com/crawlerbros/tiktok-search-scraper |
| TikTok Hashtag Scraper | https://apify.com/crawlerbros/tiktok-hashtag-scraper |
| TikTok Music Scraper | https://apify.com/crawlerbros/tiktok-music-scraper |
| TikTok Transcript Scraper | https://apify.com/crawlerbros/tiktok-transcript-scraper |
| TikTok Followers Scraper | https://apify.com/crawlerbros/tiktok-followers-scraper |
| TikTok Mention Scraper | https://apify.com/crawlerbros/tiktok-mention-scraper |
| TikTok Profile Mention Scraper | https://apify.com/crawlerbros/tiktok-profile-mention-scraper |
| TikTok Playlist Scraper | https://apify.com/crawlerbros/tiktok-playlist-scraper |
| TikTok Explore Scraper | https://apify.com/crawlerbros/tiktok-explore-scraper |
| TikTok For You Scraper | https://apify.com/crawlerbros/tiktok-for-you-scraper |
| TikTok Downloader | https://apify.com/crawlerbros/tiktok-downloader-api |
| TikTok Ads Library Scraper | https://apify.com/crawlerbros/tiktok-ads-library-scraper-pro |
| TikTok Top Ads Scraper | https://apify.com/crawlerbros/tiktok-top-ads-scraper |
| TikTok Hashtag Trends Scraper | https://apify.com/crawlerbros/tiktok-hashtag-trends-scraper |
| TikTok LIVE Scraper | https://apify.com/crawlerbros/tiktok-live-scraper |

# Actor input Schema

## `usernames` (type: `array`):

List of TikTok usernames to scrape (with or without @ prefix)

## `profileUrls` (type: `array`):

Full TikTok profile URLs (e.g. https://www.tiktok.com/@khaby.lame). Can be used instead of or together with Usernames.

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

What data to collect per profile. 'profile' emits the profile row. 'videos' emits post rows. 'reposts' emits repost rows.

## `maxPostsPerProfile` (type: `integer`):

Maximum number of posts (videos or reposts) to extract per profile. Set to 0 to skip post extraction.

## `includeProfileInfo` (type: `boolean`):

Whether to include detailed profile metadata (follower counts, bio, settings, etc.) in profile rows.

## `sessionCookie` (type: `string`):

Value of the TikTok 'sessionid' cookie. Used for followers mode. For video listing, use the 'cookies' field with your full browser cookie export instead — sessionid alone is not sufficient for video listing.

## `cookies` (type: `array`):

Full browser cookie export for tiktok.com as a JSON array. Export using the 'Cookie-Editor' browser extension → Export → JSON. Provides the full session context including msToken, ttwid, tt\_chain\_token and sessionid — needed for authenticated requests.

## `ttwid` (type: `string`):

Value of your browser's 'ttwid' cookie from tiktok.com. Enables immediate video listing without waiting for device aging (~7 days). Find it in browser DevTools → Application → Cookies → tiktok.com → ttwid. This is a non-personal device tracking cookie, not a login credential — it does not expose your account.

## Actor input object example

```json
{
  "usernames": [
    "natgeo"
  ],
  "contentTypes": [
    "profile",
    "videos",
    "reposts"
  ],
  "maxPostsPerProfile": 10,
  "includeProfileInfo": true
}
```

# Actor output Schema

## `data` (type: `string`):

Dataset rows with rowType discriminator: 'profile' for account metadata, 'video'/'repost' for post records.

# 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 = {
    "usernames": [
        "natgeo"
    ],
    "contentTypes": [
        "profile",
        "videos",
        "reposts"
    ],
    "maxPostsPerProfile": 10,
    "includeProfileInfo": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/tiktok-profile-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 = {
    "usernames": ["natgeo"],
    "contentTypes": [
        "profile",
        "videos",
        "reposts",
    ],
    "maxPostsPerProfile": 10,
    "includeProfileInfo": True,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/tiktok-profile-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 '{
  "usernames": [
    "natgeo"
  ],
  "contentTypes": [
    "profile",
    "videos",
    "reposts"
  ],
  "maxPostsPerProfile": 10,
  "includeProfileInfo": true
}' |
apify call crawlerbros/tiktok-profile-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiktok Profile Scraper",
        "description": "Scrape TikTok profiles and their video or repost history.",
        "version": "1.0",
        "x-build-id": "b38eBnxjyWo0d2pE2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~tiktok-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-tiktok-profile-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~tiktok-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-tiktok-profile-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~tiktok-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-tiktok-profile-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": {
                    "usernames": {
                        "title": "TikTok Usernames",
                        "type": "array",
                        "description": "List of TikTok usernames to scrape (with or without @ prefix)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "profileUrls": {
                        "title": "Profile URLs",
                        "type": "array",
                        "description": "Full TikTok profile URLs (e.g. https://www.tiktok.com/@khaby.lame). Can be used instead of or together with Usernames.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "contentTypes": {
                        "title": "Content Types",
                        "type": "array",
                        "description": "What data to collect per profile. 'profile' emits the profile row. 'videos' emits post rows. 'reposts' emits repost rows.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "profile",
                                "videos",
                                "reposts"
                            ]
                        },
                        "default": [
                            "profile",
                            "videos"
                        ]
                    },
                    "maxPostsPerProfile": {
                        "title": "Max Posts Per Profile",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of posts (videos or reposts) to extract per profile. Set to 0 to skip post extraction.",
                        "default": 30
                    },
                    "includeProfileInfo": {
                        "title": "Include Profile Info",
                        "type": "boolean",
                        "description": "Whether to include detailed profile metadata (follower counts, bio, settings, etc.) in profile rows.",
                        "default": true
                    },
                    "sessionCookie": {
                        "title": "TikTok Session ID (Optional)",
                        "type": "string",
                        "description": "Value of the TikTok 'sessionid' cookie. Used for followers mode. For video listing, use the 'cookies' field with your full browser cookie export instead — sessionid alone is not sufficient for video listing."
                    },
                    "cookies": {
                        "title": "TikTok Cookies (JSON array, Optional)",
                        "type": "array",
                        "description": "Full browser cookie export for tiktok.com as a JSON array. Export using the 'Cookie-Editor' browser extension → Export → JSON. Provides the full session context including msToken, ttwid, tt_chain_token and sessionid — needed for authenticated requests."
                    },
                    "ttwid": {
                        "title": "TikTok Device Cookie (ttwid, Optional)",
                        "type": "string",
                        "description": "Value of your browser's 'ttwid' cookie from tiktok.com. Enables immediate video listing without waiting for device aging (~7 days). Find it in browser DevTools → Application → Cookies → tiktok.com → ttwid. This is a non-personal device tracking cookie, not a login credential — it does not expose your account."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
