# Social Analyzer - Find Profiles Across 900+ Sites (`anshumanatrey/social-analyzer`) Actor

Cloud-hosted social-analyzer by qeeqbox. Find a username across 900+ social media and online platforms — confidence scored, country/category tagged, metadata extracted. One dataset record per detected profile. $0.005 per record.

- **URL**: https://apify.com/anshumanatrey/social-analyzer.md
- **Developed by:** [Anshuman Atrey](https://apify.com/anshumanatrey) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 profile records

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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

## Social Analyzer — Find Profiles Across 900+ Sites

📦 **Open source · MIT:** [github.com/AnshumanAtrey/social-analyzer](https://github.com/AnshumanAtrey/social-analyzer)


Cloud-hosted [qeeqbox/social-analyzer](https://github.com/qeeqbox/social-analyzer) — find a username (a person, brand, or org) across **900+ social media and online platforms** in a single scan. Results stream as structured dataset records (one per detected profile) with confidence scoring, country, category, and extracted metadata.

### Quick start

```json
{
  "username": "elonmusk",
  "mode": "fast",
  "top": 100
}
````

Scans the top 100 most popular sites in ~30-60 seconds. Each detected profile becomes a dataset record.

### Multiple usernames in one run

```json
{
  "username": "elonmusk,jeffbezos,billgates",
  "mode": "fast",
  "top": 50
}
```

### Comprehensive scan (top 500 sites + metadata)

```json
{
  "username": "anshumanatrey",
  "mode": "slow",
  "top": 500,
  "metadata": true,
  "extract": true
}
```

Takes a few minutes, but extracts page metadata (Open Graph, Twitter Card) and any URLs / patterns embedded in detected profile pages.

### Output structure

Each scan produces multiple dataset records with a `recordType` discriminator:

| recordType | Fields | When |
|---|---|---|
| `profile` | `username`, `platform`, `link`, `status`, `rate`, `country`, `language`, `type`, `rank`, `extracted`, `metadata`, `text` | One per detected profile |
| `summary` | `username`, `mode`, `sitesChecked`, `profilesFound`, `duration`, `cmd` | Always last record |

Filter by `recordType=profile` in the Apify Console table view to see only detections.

### Modes

| Mode | What it does | When to use |
|---|---|---|
| `fast` | HTTP probing — check if URL responds with a profile page | 90% of cases |
| `slow` | Page analysis — parse responses for OSINT signal | Deeper investigation |
| `special` | Extra signal extraction (text/image/name analysis) | Most thorough |

### Confidence filter

- `good` (default) — only high-confidence matches (recommended for clean results)
- `good,maybe` — include uncertain matches
- `all` — every probe, including false positives

### Pricing

$0.005 per dataset record. A typical fast scan of top 100 sites returns 5-15 detected profiles = $0.025-$0.075 per scan.

### Use cases

- **Recruiters** — verify a candidate's online presence before an interview
- **Journalists** — investigate subjects for stories
- **Fraud teams** — confirm or deny suspect identities
- **HR background checks** — verify professional accounts
- **Dating safety** — confirm someone is who they say they are
- **OSINT investigators** — case work on individuals or brands

### Authorization

Only search usernames you're authorized to investigate. Some jurisdictions restrict OSINT collection on private individuals — consult local law (GDPR in EU, CCPA in California, etc.).

### FAQ

#### How accurate are the results?

The `good` confidence filter (default) returns only high-signal matches — these are reliable (~95%+ true positives). The `good,maybe` filter trades precision for recall — useful when you want exhaustive coverage and don't mind manually checking some false positives.

#### Why does a scan sometimes take 5+ minutes?

`slow` mode parses each detected page for OSINT signals (emails, links, metadata). `special` mode runs OCR on profile images. If you just need a list of platforms, stick with `fast` mode — usually under 60 seconds for top 100 sites.

#### Can I scan a username only on platforms from certain countries?

Yes — pass a comma-separated list of two-letter country codes (`US,IN,JP`) and the actor will probe only sites registered to those countries. Useful for compliance investigations restricted to specific jurisdictions.

#### Why does it sometimes miss LinkedIn?

LinkedIn aggressively rate-limits anonymous probes — confirmation of a profile often requires a logged-in scrape. For LinkedIn specifically, use a dedicated LinkedIn-scraper actor; social-analyzer's value is in the long tail of 900+ other platforms.

#### How is this different from Sherlock / Maigret?

Sherlock checks ~400 sites with binary "exists / doesn't exist." Social Analyzer adds: 900+ sites, confidence scoring (so you can trust the results), metadata extraction, country/category filtering, and parallel HTTP probing for speed. Maigret is the closest competitor — Social Analyzer covers more sites but Maigret is faster for username-only queries.

### Pairs nicely with

Bundle for full identity-resolution workflows:

- **[Holehe Email OSINT](https://apify.com/anshumanatrey/holehe-email-osint)** — Start with an email, find which sites it's registered on, then probe those usernames with Social Analyzer
- **[theHarvester](https://apify.com/anshumanatrey/theharvester-osint)** — Discover emails/people for a domain, then OSINT the names with Social Analyzer
- **[NetIntel](https://apify.com/anshumanatrey/netintel)** — Add WHOIS / GeoIP context to domains found in discovered profiles
- **[Bug Bounty Finder](https://apify.com/anshumanatrey/bug-bounty-finder)** — Audit your own brand's presence + check for active disclosure programs
- **[nmap](https://apify.com/anshumanatrey/nmap-scanner)** — Network recon for the technical-investigation half of OSINT
- **[Zomato Restaurant Scraper](https://apify.com/anshumanatrey/zomato-restaurant-scraper)** — Restaurant lead lists (separate B2B use case)

### Credits

Built on [qeeqbox/social-analyzer](https://github.com/qeeqbox/social-analyzer) by Qeeqbox. AGPL-3.0 licensed per upstream.

# Actor input Schema

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

Username to investigate. Supports multiple comma-separated: johndoe,janedoe.

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

Fast = quick HTTP probing (~30s for top 100). Slow = page analysis. Special = extra OSINT signal extraction.

## `top` (type: `integer`):

Scan the top N most popular sites. 100 = ~30s, 500 = ~3 min, 900 = full coverage.

## `websites` (type: `array`):

Pick specific sites to scan. Leave empty to use 'How many sites' above.

## `countries` (type: `array`):

Restrict to sites originating from these countries. Leave empty for global.

## `siteType` (type: `string`):

Restrict to one site type. Leave on 'Any' for no filter.

## `method` (type: `string`):

Found-only is cleanest. Use 'All' for debugging or research.

## `filter` (type: `string`):

How sure should the detection be?

## `extract` (type: `boolean`):

Pulls emails, links and other patterns from each detected profile.

## `metadata` (type: `boolean`):

Adds page title, description, image, and language data per profile.

## `trim` (type: `boolean`):

Cleaner output, recommended.

## `timeout` (type: `integer`):

Hard kill the scanner after this many seconds.

## Actor input object example

```json
{
  "username": "elonmusk",
  "mode": "fast",
  "top": 100,
  "siteType": "",
  "method": "find",
  "filter": "good",
  "extract": false,
  "metadata": true,
  "trim": true,
  "timeout": 1800
}
```

# Actor output Schema

## `detectedProfiles` (type: `string`):

One record per discovered profile. Fields: username, platform (site name), link (full profile URL), status (good/maybe/bad), rate (% confidence), country, type (site category), language, rank, extracted (URLs/patterns if --extract), metadata (page metadata if --metadata). Final record has recordType=summary with counts and the executed command.

# 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 = {
    "username": "elonmusk"
};

// Run the Actor and wait for it to finish
const run = await client.actor("anshumanatrey/social-analyzer").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 = { "username": "elonmusk" }

# Run the Actor and wait for it to finish
run = client.actor("anshumanatrey/social-analyzer").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 '{
  "username": "elonmusk"
}' |
apify call anshumanatrey/social-analyzer --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Social Analyzer - Find Profiles Across 900+ Sites",
        "description": "Cloud-hosted social-analyzer by qeeqbox. Find a username across 900+ social media and online platforms — confidence scored, country/category tagged, metadata extracted. One dataset record per detected profile. $0.005 per record.",
        "version": "1.0",
        "x-build-id": "vh1FbNRTdN6jWEXju"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/anshumanatrey~social-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-anshumanatrey-social-analyzer",
                "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/anshumanatrey~social-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-anshumanatrey-social-analyzer",
                "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/anshumanatrey~social-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-anshumanatrey-social-analyzer",
                "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": [
                    "username"
                ],
                "properties": {
                    "username": {
                        "title": "Username(s)",
                        "type": "string",
                        "description": "Username to investigate. Supports multiple comma-separated: johndoe,janedoe."
                    },
                    "mode": {
                        "title": "Detection Mode",
                        "enum": [
                            "fast",
                            "slow",
                            "special"
                        ],
                        "type": "string",
                        "description": "Fast = quick HTTP probing (~30s for top 100). Slow = page analysis. Special = extra OSINT signal extraction.",
                        "default": "fast"
                    },
                    "top": {
                        "title": "How many sites to scan",
                        "minimum": 1,
                        "maximum": 900,
                        "type": "integer",
                        "description": "Scan the top N most popular sites. 100 = ~30s, 500 = ~3 min, 900 = full coverage.",
                        "default": 100
                    },
                    "websites": {
                        "title": "Specific sites (optional, overrides 'How many')",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Pick specific sites to scan. Leave empty to use 'How many sites' above.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "facebook",
                                "instagram",
                                "twitter",
                                "tiktok",
                                "youtube",
                                "github",
                                "gitlab",
                                "linkedin",
                                "reddit",
                                "pinterest",
                                "tumblr",
                                "medium",
                                "discord",
                                "telegram",
                                "snapchat",
                                "twitch",
                                "steam",
                                "spotify",
                                "soundcloud",
                                "behance",
                                "dribbble",
                                "deviantart",
                                "flickr",
                                "vimeo",
                                "vk",
                                "ok",
                                "naver",
                                "weibo",
                                "patreon",
                                "wordpress",
                                "blogger",
                                "fandom",
                                "etsy",
                                "ebay",
                                "amazon",
                                "tradingview",
                                "kaggle",
                                "stackoverflow",
                                "hackernews",
                                "producthunt"
                            ],
                            "enumTitles": [
                                "Facebook",
                                "Instagram",
                                "Twitter / X",
                                "TikTok",
                                "YouTube",
                                "GitHub",
                                "GitLab",
                                "LinkedIn",
                                "Reddit",
                                "Pinterest",
                                "Tumblr",
                                "Medium",
                                "Discord",
                                "Telegram",
                                "Snapchat",
                                "Twitch",
                                "Steam",
                                "Spotify",
                                "SoundCloud",
                                "Behance",
                                "Dribbble",
                                "DeviantArt",
                                "Flickr",
                                "Vimeo",
                                "VK (Russia)",
                                "OK.ru (Russia)",
                                "Naver (Korea)",
                                "Weibo (China)",
                                "Patreon",
                                "WordPress",
                                "Blogger",
                                "Fandom",
                                "Etsy",
                                "eBay",
                                "Amazon",
                                "TradingView",
                                "Kaggle",
                                "StackOverflow",
                                "HackerNews",
                                "ProductHunt"
                            ]
                        }
                    },
                    "countries": {
                        "title": "Filter by country (optional)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Restrict to sites originating from these countries. Leave empty for global.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "us",
                                "in",
                                "br",
                                "ru",
                                "cn",
                                "jp",
                                "kr",
                                "de",
                                "fr",
                                "gb",
                                "es",
                                "it",
                                "mx",
                                "tr",
                                "id",
                                "vn",
                                "th",
                                "ph",
                                "ae",
                                "sa"
                            ],
                            "enumTitles": [
                                "United States",
                                "India",
                                "Brazil",
                                "Russia",
                                "China",
                                "Japan",
                                "Korea",
                                "Germany",
                                "France",
                                "United Kingdom",
                                "Spain",
                                "Italy",
                                "Mexico",
                                "Turkey",
                                "Indonesia",
                                "Vietnam",
                                "Thailand",
                                "Philippines",
                                "UAE",
                                "Saudi Arabia"
                            ]
                        }
                    },
                    "siteType": {
                        "title": "Filter by site category (optional)",
                        "enum": [
                            "",
                            "Social Networks",
                            "Music",
                            "News",
                            "Forum",
                            "Adult",
                            "Gaming",
                            "Photo",
                            "Video",
                            "Blog",
                            "Shopping",
                            "Dating",
                            "Professional"
                        ],
                        "type": "string",
                        "description": "Restrict to one site type. Leave on 'Any' for no filter.",
                        "default": ""
                    },
                    "method": {
                        "title": "What to return",
                        "enum": [
                            "find",
                            "get",
                            "all"
                        ],
                        "type": "string",
                        "description": "Found-only is cleanest. Use 'All' for debugging or research.",
                        "default": "find"
                    },
                    "filter": {
                        "title": "Confidence threshold",
                        "enum": [
                            "good",
                            "good,maybe",
                            "all"
                        ],
                        "type": "string",
                        "description": "How sure should the detection be?",
                        "default": "good"
                    },
                    "extract": {
                        "title": "Extract URLs & patterns from found profiles",
                        "type": "boolean",
                        "description": "Pulls emails, links and other patterns from each detected profile.",
                        "default": false
                    },
                    "metadata": {
                        "title": "Extract page metadata (Open Graph, Twitter Card)",
                        "type": "boolean",
                        "description": "Adds page title, description, image, and language data per profile.",
                        "default": true
                    },
                    "trim": {
                        "title": "Trim long text fields",
                        "type": "boolean",
                        "description": "Cleaner output, recommended.",
                        "default": true
                    },
                    "timeout": {
                        "title": "Subprocess timeout (seconds)",
                        "minimum": 60,
                        "maximum": 3600,
                        "type": "integer",
                        "description": "Hard kill the scanner after this many seconds.",
                        "default": 1800
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
