# Maigret Username OSINT Search (`datacach/maigret-username-osint`) Actor

Search for a username across 3000+ social networks and websites, extracting profile data.

- **URL**: https://apify.com/datacach/maigret-username-osint.md
- **Developed by:** [DataCach](https://apify.com/datacach) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.69 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Maigret Username OSINT Search

**Find every account tied to a username across 3000+ social networks and websites** — and pull the profile data behind each one. This Actor wraps the popular open-source [Maigret](https://github.com/soxoj/maigret) OSINT engine and returns clean, structured **JSON** you can export to **CSV** or **Excel**, or pull straight from the **Apify API**. Built for OSINT investigators, security researchers, journalists, and authorized due-diligence work.

<!-- TODO: add a demo GIF or YouTube URL on its own line here to boost ranking, e.g. a short screen recording of a run -->

### What is Maigret Username OSINT Search?

Maigret Username OSINT Search is a **reverse username lookup** tool that takes a single **username** and checks whether it exists across **3000+ sites** — social media, forums, coding platforms, marketplaces, and more. For every site where the account is **claimed**, it returns the **direct profile URL**, the site, the account status, and any **profile data** the site exposes (full name, bio, avatar, location, and platform-specific IDs). The result is a complete **online footprint** for that username in one structured dataset.

### What can this username OSINT scraper do?

- 🔎 **Search one username across 3000+ websites** — GitHub, Instagram, Reddit, X/Twitter, TikTok, LinkedIn, and thousands more.
- 🧩 **Extract profile data**, not just links — full name, bio, avatar image, location, and site-specific identifiers.
- 🏷️ **Filter by site tags** (e.g. `social`, `coding`, `video`) or restrict the search to **specific sites**.
- 🔁 **Recursive discovery** — automatically follows usernames and IDs found on discovered profiles for a deeper search.
- 🆔 **Multiple identifier types** — search by username or by platform IDs (Yandex, Steam, VK, and more).
- 📤 **Export to JSON, CSV, or Excel**, or fetch results through the **Apify API**.
- ⏰ **Schedule runs**, set up **monitoring**, and connect to **Zapier, Make, and 5000+ integrations** on the Apify platform.
- 🌐 **Proxy rotation** via Apify Proxy to avoid rate-limits and IP blocks.

### What data does Maigret extract?

Each dataset item represents one site where the username was found:

| Field | Description |
|---|---|
| `username` | The username that was searched |
| `siteName` | Name of the site where the account exists |
| `profileUrl` | Direct URL to the discovered profile |
| `siteMainUrl` | Home URL of the site |
| `status` | `Claimed`, `Available`, or `Unknown` |
| `httpStatus` | HTTP response code from the check |
| `isSimilar` | Whether the match is a soft/similar match |
| `alexaRank` | Popularity rank of the site |
| `tags` | Site category tags (e.g. `coding`, `social`) |
| `fullName` | Full name extracted from the profile (if available) |
| `bio` | Profile biography/description (if available) |
| `image` | Avatar/profile image URL (if available) |
| `location` | Location extracted from the profile (if available) |
| `gender` | Gender extracted from the profile (if available) |
| `extractedIds` | Object with all platform-specific IDs and metadata |
| `queryTime` | Time taken to check the site |
| `idType` | Type of identifier searched |
| `scrapedAt` | ISO timestamp of the check |

### How to search a username across 3000+ sites

1. Enter the **username** you want to investigate (e.g. `johndoe`).
2. *(Optional)* Set **Number of sites to check** — start small for a fast run, or set `0` to check all 3000+ sites.
3. *(Optional)* Narrow the search with **site tags** or a list of **specific sites**.
4. Click **Start** and watch results stream into the dataset.
5. **Export** the results as JSON, CSV, or Excel, or pull them via the **Apify API**.

![Maigret Username OSINT Search input](https://raw.githubusercontent.com/BenjaminFloresV/public-datacach-apify-actors-media/main/maigret-osnit-username/maigret-input-page-example.png "Maigret username OSINT search input form")

### Input

The only required input is a **username**. Everything else is optional:

- **Username** — the username to look up (one per run).
- **Number of sites to check** — how many sites to scan, ranked by popularity (`0` = all 3000+).
- **Site filters** — include/exclude by tag, or restrict to specific sites.
- **Identifier type** — username or a platform-specific ID.
- **Limits & performance** — per-site timeout and max concurrent requests.
- **Advanced** — toggle recursive discovery and whether to store not-found sites.
- **Proxy** — route requests through Apify Proxy (recommended).

### Output example

Every result is a structured JSON object like this:

```json
{
  "username": "johndoe",
  "siteName": "GitHub",
  "profileUrl": "https://github.com/johndoe",
  "siteMainUrl": "https://www.github.com/",
  "status": "Claimed",
  "httpStatus": 200,
  "isSimilar": false,
  "alexaRank": 10,
  "tags": ["coding"],
  "fullName": null,
  "bio": null,
  "image": "https://avatars.githubusercontent.com/u/29063?v=4",
  "location": null,
  "gender": null,
  "extractedIds": {
    "uid": "29063",
    "image": "https://avatars.githubusercontent.com/u/29063?v=4",
    "created_at": "2008-10-15T13:10:53Z",
    "follower_count": "85",
    "following_count": "0",
    "public_gists_count": "0",
    "public_repos_count": "1",
    "_extractor": "GitHub API"
  },
  "queryTime": null,
  "idType": "username",
  "scrapedAt": "2026-07-06T05:50:54.325Z"
}
````

### Use cases

- 🕵️ **OSINT reconnaissance** — map a target's full online footprint from a single username.
- 🛡️ **Fraud & impersonation detection** — find fake or duplicate accounts reusing a handle.
- 🔍 **Background checks & due diligence** — surface accounts for authorized investigations.
- 📰 **Journalism & research** — verify sources and trace public profiles.
- 🧑‍💻 **Security research** — enumerate a username's exposure across platforms.
- 👀 **Brand & identity monitoring** — track where a username or handle appears online.

### Other Actors you might like

Combine username OSINT with email and phone lookups for a complete investigation:

| Actor | What it does |
|---|---|
| [Holehe Email OSINT Scraper](https://apify.com/datacach/holehe-email-osint-scraper) | Find which sites and services an **email address** is registered on |
| [PhoneInfoga Phone Number OSINT Scanner](https://apify.com/datacach/phoneinfoga-phone-number-osint-scanner) | Gather OSINT on a **phone number** — carrier, location, and linked footprint |
| [UserRecon](https://apify.com/datacach/userrecon) | Fast **username reconnaissance** across social networks |

### FAQ

#### Is it legal to search usernames with this Actor?

Searching **publicly available** profile information is generally legal in most jurisdictions, and this Actor only checks public pages. However, **you are responsible** for how you use the data. Use it only for lawful, authorized purposes and in compliance with each site's terms of service and applicable privacy laws (such as GDPR and CCPA). Do not use it for harassment, stalking, or unauthorized surveillance.

#### How do I find all accounts linked to a username?

Enter the username, click **Start**, and the Actor checks it against 3000+ sites, returning one result per site where the account exists — with the direct profile URL and any extracted profile data.

#### Which sites and social networks does it check?

It checks 3000+ sites via the Maigret database, including GitHub, Instagram, Reddit, X/Twitter, TikTok, LinkedIn, and thousands of forums, blogs, and niche platforms. You can filter by tag or restrict to specific sites.

#### Can I export the results to CSV, Excel, or JSON?

Yes. Results are stored in a dataset you can export as **JSON, CSV, or Excel**, or retrieve programmatically through the **Apify API**.

#### Does this Actor have an API?

Yes. Every Actor on Apify comes with a full **REST API**, so you can trigger runs, pass a username, and fetch results from your own code, or schedule and monitor runs on the platform.

#### How accurate are the results?

Accuracy depends on each site's detection method. Some checks are exact; others are marked `isSimilar` when the match is a soft one. Using **Apify Proxy** improves reliability by avoiding rate-limits and blocks.

#### Why are some profile fields empty?

Fields like `fullName`, `bio`, `image`, and `location` are only filled when the target site publicly exposes them. When a site returns nothing, those fields are `null` while the account match is still reported.

### Support

Found a bug or need a custom OSINT workflow? Open an issue on the **Issues** tab of this Actor, or contact the author through the Apify Store. Feature requests and questions are welcome.

# Actor input Schema

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

The username to look up across social networks and websites. One username is searched per run. Example: johndoe

## `topSites` (type: `integer`):

How many sites to check, ordered by popularity (Alexa rank). More sites means a more thorough search but a slower run and more results (which cost more). Set to 0 to check all 3000+ sites (slow). Free plan is capped at 100 sites and 25 results per run.

## `sites` (type: `string`):

Check only these specific sites, as a comma-separated list of site names. Leave empty to check by popularity instead. Example: GitHub,Twitter,Instagram

## `tags` (type: `string`):

Check only sites that carry one of these tags, as a comma-separated list. Useful to focus the search on a category. Example: social,coding,video

## `excludeTags` (type: `string`):

Skip any site that carries one of these tags, as a comma-separated list. Example: adult,dating

## `idType` (type: `string`):

What kind of identifier you are searching for. Leave as "Username" unless you are looking up a platform-specific ID such as a Yandex or Steam ID.

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

How long to wait for each site to respond before giving up, in seconds. Lower values finish faster but may miss slow sites.

## `maxConnections` (type: `integer`):

How many sites to check at the same time. Higher values make the run faster but hit the network harder; lower values are gentler and more reliable on slow connections.

## `noRecursion` (type: `boolean`):

When enabled, the search does not follow extra usernames or IDs found on discovered profiles. When disabled (the default), Maigret recursively searches those discovered identities for a more thorough result. Always disabled on the free plan.

## `printNotFound` (type: `boolean`):

When enabled, the dataset also includes sites where the username was NOT found. When disabled (the default), only sites where the account exists are stored. Ignored on the free plan (found accounts only).

## `proxy` (type: `object`):

Route site checks through a proxy to avoid rate-limits and IP blocks. Apify Proxy is recommended for the best success rate.

## Actor input object example

```json
{
  "username": "johndoe",
  "topSites": 500,
  "idType": "username",
  "timeout": 30,
  "maxConnections": 100,
  "noRecursion": false,
  "printNotFound": false,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "username": "johndoe"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datacach/maigret-username-osint").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": "johndoe" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Maigret Username OSINT Search",
        "description": "Search for a username across 3000+ social networks and websites, extracting profile data.",
        "version": "0.1",
        "x-build-id": "hewxtGUcgLmu557bd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datacach~maigret-username-osint/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datacach-maigret-username-osint",
                "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/datacach~maigret-username-osint/runs": {
            "post": {
                "operationId": "runs-sync-datacach-maigret-username-osint",
                "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/datacach~maigret-username-osint/run-sync": {
            "post": {
                "operationId": "run-sync-datacach-maigret-username-osint",
                "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",
                        "type": "string",
                        "description": "The username to look up across social networks and websites. One username is searched per run. Example: johndoe"
                    },
                    "topSites": {
                        "title": "Number of sites to check",
                        "minimum": 0,
                        "maximum": 3000,
                        "type": "integer",
                        "description": "How many sites to check, ordered by popularity (Alexa rank). More sites means a more thorough search but a slower run and more results (which cost more). Set to 0 to check all 3000+ sites (slow). Free plan is capped at 100 sites and 25 results per run.",
                        "default": 500
                    },
                    "sites": {
                        "title": "Only these sites",
                        "type": "string",
                        "description": "Check only these specific sites, as a comma-separated list of site names. Leave empty to check by popularity instead. Example: GitHub,Twitter,Instagram"
                    },
                    "tags": {
                        "title": "Include site tags",
                        "type": "string",
                        "description": "Check only sites that carry one of these tags, as a comma-separated list. Useful to focus the search on a category. Example: social,coding,video"
                    },
                    "excludeTags": {
                        "title": "Exclude site tags",
                        "type": "string",
                        "description": "Skip any site that carries one of these tags, as a comma-separated list. Example: adult,dating"
                    },
                    "idType": {
                        "title": "Identifier type",
                        "enum": [
                            "username",
                            "yandex_public_id",
                            "gaia_id",
                            "vk_id",
                            "ok_id",
                            "wikimapia_uid",
                            "steam_id"
                        ],
                        "type": "string",
                        "description": "What kind of identifier you are searching for. Leave as \"Username\" unless you are looking up a platform-specific ID such as a Yandex or Steam ID.",
                        "default": "username"
                    },
                    "timeout": {
                        "title": "Per-site timeout",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait for each site to respond before giving up, in seconds. Lower values finish faster but may miss slow sites.",
                        "default": 30
                    },
                    "maxConnections": {
                        "title": "Max concurrent requests",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "How many sites to check at the same time. Higher values make the run faster but hit the network harder; lower values are gentler and more reliable on slow connections.",
                        "default": 100
                    },
                    "noRecursion": {
                        "title": "Disable recursive search",
                        "type": "boolean",
                        "description": "When enabled, the search does not follow extra usernames or IDs found on discovered profiles. When disabled (the default), Maigret recursively searches those discovered identities for a more thorough result. Always disabled on the free plan.",
                        "default": false
                    },
                    "printNotFound": {
                        "title": "Include not-found sites",
                        "type": "boolean",
                        "description": "When enabled, the dataset also includes sites where the username was NOT found. When disabled (the default), only sites where the account exists are stored. Ignored on the free plan (found accounts only).",
                        "default": false
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Route site checks through a proxy to avoid rate-limits and IP blocks. Apify Proxy is recommended for the best success rate.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
