# Tiktok Profile Finder (`scraper-mind/tiktok-profile-finder`) Actor

TikTok profile finder to discover TikTok profiles using keywords, hashtags, and niches 🔎🎵 Perfect for influencer discovery, market research, and targeted creator outreach. Fast and accurate profile search.

- **URL**: https://apify.com/scraper-mind/tiktok-profile-finder.md
- **Developed by:** [Scraper Mind](https://apify.com/scraper-mind) (community)
- **Categories:** Lead generation, Social media, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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 Finder — Fast, Advanced & Login‑Free

Welcome to the most efficient, advanced, and affordable Tiktok Profile Finder built to supercharge profile discovery at scale. Whether you’re a digital marketer, creator scout, social media agency, or brand researcher, this Tiktok Profile Finder is your go‑to Tiktok Profile extraction tool for quickly finding thousands of relevant TikTok accounts by keyword—no login required.

Skip the manual search and embrace automated Tiktok extraction. With powerful keyword targeting, geographic biasing, and speedy bulk Tiktok Profile extraction, you can extract Tiktok Profile lists in minutes and export Tiktok Profile data in clean, structured formats. From influencer discovery to market research, this Tiktok Profile Finder turns Tiktok public data extraction into a streamlined, repeatable workflow.

Built for scale and reliability, the Tiktok Profile Finder supports both solo operators and enterprise teams. Use it as a Tiktok Profile Finder API for programmatic pipelines or integrate with Tiktok Profile Finder Python scripts for end‑to‑end Tiktok data extraction.

---

### 📥 Input Parameters Guide

Below is a comprehensive guide to input parameters for configuring the Tiktok Profile Finder:

| Parameter               | Type                | Description                                                                                     | Default                | Best Practice                                                                 |
|-------------------------|---------------------|-------------------------------------------------------------------------------------------------|------------------------|-------------------------------------------------------------------------------|
| `keywords`              | Array (Required)    | Core search terms (niches, professions, brands, interests).                                     | N/A                    | Use specific, niche keywords to improve targeting and result quality.         |
| `country`               | String (Optional)   | Country bias for search results (e.g., "US", "GB", "DE").                                       | None                   | Set to your target market for more localized profiles.                        |
| `language`              | String (Optional)   | Language code to bias queries (e.g., "en", "es", "de").                                         | None                   | Align with your audience’s language for better relevance.                     |
| `sources`               | Array (Optional)    | Profile discovery channels, e.g., `["search", "suggestions"]`.                                  | ["search"]             | Combine “search” and “suggestions” to broaden discovery.                      |
| `maxProfilesPerKeyword` | Integer (Optional)  | Max number of profiles to collect per keyword.                                                  | 100                    | Start with 100–300 per keyword; increase for broad niches.                    |
| `deduplicate`           | Boolean (Optional)  | Remove duplicate profiles across keywords.                                                       | true                   | Keep enabled for clean datasets.                                              |
| `includeBioSnippet`     | Boolean (Optional)  | Include a short snippet from the public profile bio/description.                                 | true                   | Keep enabled for quick qualitative review.                                    |
| `maxConcurrency`        | Integer (Optional)  | Controls parallel requests to optimize speed vs. stability.                                      | 10                     | Increase gradually; use proxies for higher throughput.                        |
| `proxyConfiguration`    | Object (Optional)   | Proxy settings. Example: `{ "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }`.      | None                   | Use residential proxies for reliable, large‑scale runs.                       |

#### Example Input Configuration
```json
{
  "keywords": ["fitness", "travel blogger"],
  "country": "US",
  "language": "en",
  "sources": ["search", "suggestions"],
  "maxProfilesPerKeyword": 150,
  "deduplicate": true,
  "includeBioSnippet": true,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

***

### 📤 Output Data Structure

The Tiktok Profile Finder outputs clean, structured JSON or CSV optimized for analysis and integrations. Each record focuses on the essentials that matter for Tiktok Profile data extraction.

| Field                 | Description                                                          | Importance |
|----------------------|----------------------------------------------------------------------|------------|
| `keyword`            | The keyword used to find the profile.                                | High       |
| `url`                | Direct link to the TikTok profile (e.g., `https://www.tiktok.com/@...`). | High       |
| `description_snippet`| Short snippet from the public bio/description (if available).        | Medium     |
| `source`             | How the profile was discovered (e.g., `search`, `suggestions`).      | Medium     |

#### Example Output JSON

```json
[
  {
    "keyword": "fitness",
    "url": "https://www.tiktok.com/@fitjane",
    "description_snippet": "NASM CPT | Daily home workouts and meal prep tips",
    "source": "search"
  },
  {
    "keyword": "travel blogger",
    "url": "https://www.tiktok.com/@nomadnate",
    "description_snippet": "Budget travel hacks ✈️ | Hidden gems & itineraries",
    "source": "suggestions"
  }
]
```

***

### 🌟 Why Choose Our Tiktok Profile Finder?

#### 1. ⚡ Speed and Bulk Discovery

Designed for bulk Tiktok Profile extraction, this Tiktok Profile extraction tool discovers hundreds to thousands of profiles per run with optimized parallelization—perfect for automated Tiktok extraction at scale.

#### 2. 🎯 Highly Targeted Results

Refine by keyword, country, and language to extract Tiktok Profile lists that match your audience. Expand reach by combining multiple sources such as search and suggestions.

#### 3. 🔐 No Login Required

All results come from Tiktok public data extraction—no account credentials needed. This reduces friction and improves stability.

#### 4. 🌍 Global and Localized

Bias by country and language to align with global or local campaigns. Ideal for regional market research and creator scouting.

#### 5. 🧩 Easy Integration

Use the Tiktok Profile Finder API in workflows or connect with Tiktok Profile Finder Python scripts to automate Tiktok data extraction and export Tiktok Profile data to your CRM, BI, or spreadsheets.

#### 6. 🛡️ Reliable and Compliant

Built to be robust for continuous runs, with sane defaults for deduplication and clean output focused on Tiktok public data extraction.

***

### 🛠️ How It Works

1. Define your `keywords` and optional targeting parameters (country, language, sources).
2. Configure batch size via `maxProfilesPerKeyword` for bulk Tiktok Profile extraction.
3. Tune `maxConcurrency` and proxies for automated Tiktok extraction at scale.
4. Run the Tiktok Profile Finder and let it find profiles that match your criteria.
5. Export Tiktok Profile data as JSON or CSV for downstream processing.

***

### 💡 Practical Use Cases

- Influencer and Creator Discovery
  - Scout creators by niche or industry to build outreach lists from public profiles.
- Brand and Competitor Research
  - Map competitor-adjacent communities and track category participants.
- Agency and Campaign Planning
  - Rapidly assemble profile shortlists by keyword and region for pitching and collaborations.
- Academic and Market Research
  - Use the Tiktok Profile Finder API for programmatic Tiktok data extraction in research pipelines.

***

### 📈 Best Practices for High‑Quality Results

- Use multi‑word, niche‑specific keywords (e.g., “vegan chef”, “fintech analyst”).
- Combine `sources` = \["search", "suggestions"] to broaden discovery.
- Start with moderate `maxProfilesPerKeyword` (100–300), then scale based on results.
- Enable proxies for stable bulk Tiktok Profile extraction and higher throughput.
- Integrate the Tiktok Profile Finder API with your ETL or use Tiktok Profile Finder Python scripts to automate runs and export Tiktok Profile data seamlessly.
- Periodically refresh runs to capture new profiles and changes in search rankings.

***

### ❓ Frequently Asked Questions (FAQ)

1. Is this tool legal?
   - Yes. The Tiktok Profile Finder collects publicly available information only, focusing on Tiktok public data extraction from profiles found via search and suggestions.

2. Do I need a TikTok account to use this?
   - No. The tool requires no login and relies on Tiktok public data extraction pathways.

3. How fast is the Tiktok Profile Finder?
   - Speed depends on keywords, sources, and concurrency. With proxies enabled, automated Tiktok extraction can process hundreds of profiles per minute.

4. Can I filter by location or language?
   - You can bias results by `country` and `language` to improve local relevance.

5. How do I integrate with my systems?
   - Use dataset exports (JSON/CSV) or connect via the Tiktok Profile Finder API. You can also run it with Tiktok Profile Finder Python scripts for scheduled jobs and pipelines.

6. What fields are provided in the output?
   - `keyword`, `url`, `description_snippet`, and `source`. This covers the essentials for Tiktok Profile data extraction and fast evaluation.

7. Do I need proxies?
   - Proxies are recommended for large jobs and to improve stability for bulk Tiktok Profile extraction.

8. Does this scrape videos or private data?
   - No. It focuses on profile discovery only, using public signals.

9. Can I export Tiktok Profile data to CSV?
   - Yes. You can export Tiktok Profile data in CSV or JSON for use in CRM, analytics, or spreadsheets.

***

### 🔧 Troubleshooting Common Issues

1. No results found
   - Broaden or adjust your keywords, add more niches, or remove overly restrictive filters.

2. Fewer profiles than expected
   - Increase `maxProfilesPerKeyword`, add `sources` like "suggestions", and verify country/language settings.

3. Slow performance
   - Increase `maxConcurrency` in small increments and enable proxies to improve throughput.

4. Temporary blocks or captchas
   - Use residential proxies and avoid aggressive concurrency spikes. Schedule runs during off‑peak hours.

***

### 🔑 Key Features Summary

- ✅ Login‑free Tiktok public data extraction
- ✅ Fast, scalable automated Tiktok extraction
- ✅ Bulk Tiktok Profile extraction with deduplication
- ✅ Country and language biasing for targeted discovery
- ✅ Clean outputs to export Tiktok Profile data (JSON/CSV)
- ✅ Easy integrations via Tiktok Profile Finder API and Tiktok Profile Finder Python scripts
- ✅ Reliable performance for continuous, repeatable workflows

Start discovering creators, competitors, and communities today with the Tiktok Profile Finder and transform how you extract Tiktok Profile lists at scale.

***

### 📥 Input/Output Quick Reference

- Inputs: `keywords` (required), `country`, `language`, `sources`, `maxProfilesPerKeyword`, `deduplicate`, `includeBioSnippet`, `maxConcurrency`, `proxyConfiguration`
- Outputs: `keyword`, `url`, `description_snippet`, `source`

***

### 📞 Support, Feedback & Custom Solutions

Need help with setups, integrations, or a custom Tiktok Profile extraction tool tailored to your needs? We can assist with deploying the Tiktok Profile Finder API, building Tiktok Profile Finder Python automations, and connecting exports to your CRM or data warehouse.

***

### Support

For any help or custom solution, contact via this mail: scrapermindapi@gmail.com

# Actor input Schema

## `keywords` (type: `array`):

List of keywords to search for TikTok profiles (e.g., 'marketing', 'fitness', 'real estate').

## `country` (type: `string`):

Select the target country for leads.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "country": "United States"
}
```

# 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 = {
    "keywords": [
        "marketing"
    ],
    "country": "United States"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-mind/tiktok-profile-finder").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 = {
    "keywords": ["marketing"],
    "country": "United States",
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-mind/tiktok-profile-finder").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 '{
  "keywords": [
    "marketing"
  ],
  "country": "United States"
}' |
apify call scraper-mind/tiktok-profile-finder --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tiktok Profile Finder",
        "description": "TikTok profile finder to discover TikTok profiles using keywords, hashtags, and niches 🔎🎵 Perfect for influencer discovery, market research, and targeted creator outreach. Fast and accurate profile search.",
        "version": "1.0",
        "x-build-id": "SjzhrJ7JL1jGu5hhn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraper-mind~tiktok-profile-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraper-mind-tiktok-profile-finder",
                "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/scraper-mind~tiktok-profile-finder/runs": {
            "post": {
                "operationId": "runs-sync-scraper-mind-tiktok-profile-finder",
                "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/scraper-mind~tiktok-profile-finder/run-sync": {
            "post": {
                "operationId": "run-sync-scraper-mind-tiktok-profile-finder",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "List of keywords to search for TikTok profiles (e.g., 'marketing', 'fitness', 'real estate').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Target Country",
                        "enum": [
                            "United States",
                            "United Kingdom",
                            "Canada",
                            "Australia",
                            "Germany",
                            "France",
                            "Spain",
                            "Italy",
                            "Netherlands",
                            "Belgium",
                            "Switzerland",
                            "Austria",
                            "Sweden",
                            "Norway",
                            "Denmark",
                            "Finland",
                            "Poland",
                            "Czech Republic",
                            "Portugal",
                            "Greece",
                            "Ireland",
                            "New Zealand",
                            "Singapore",
                            "Hong Kong",
                            "Japan",
                            "South Korea",
                            "India",
                            "Brazil",
                            "Mexico",
                            "Argentina",
                            "Chile",
                            "Colombia",
                            "Peru",
                            "South Africa",
                            "Nigeria",
                            "Egypt",
                            "Kenya",
                            "United Arab Emirates",
                            "Saudi Arabia",
                            "Israel",
                            "Turkey",
                            "Russia",
                            "Ukraine",
                            "Romania",
                            "Bulgaria",
                            "Hungary",
                            "Serbia",
                            "Croatia",
                            "Slovenia",
                            "Slovakia",
                            "Lithuania",
                            "Latvia",
                            "Estonia",
                            "Iceland",
                            "Luxembourg",
                            "Malta",
                            "Cyprus",
                            "Albania",
                            "Macedonia",
                            "Bosnia and Herzegovina",
                            "Montenegro"
                        ],
                        "type": "string",
                        "description": "Select the target country for leads.",
                        "default": "United States"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
