# Fansly Model Leads Scraper (`sentry/fansly-model-leads-scraper`) Actor

Generate Fansly model leads at scale — scrape creator profiles with follower counts, subscription pricing, and verified Instagram, Twitter & TikTok contacts. The go-to tool for model agencies, talent managers, and recruiters sourcing Fansly talent.

- **URL**: https://apify.com/sentry/fansly-model-leads-scraper.md
- **Developed by:** [Sentry](https://apify.com/sentry) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 9 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$25.00/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

## Fansly Model Leads Scraper

Generate Fansly model leads at scale. Search by keyword to scrape creator profiles and build targeted outreach lists complete with follower counts, subscription pricing, verified Instagram, Twitter/X, and TikTok contact links — ready to import into your CRM or outreach pipeline.

The go-to tool for model agencies, talent managers, and recruiters who need a consistent, scalable source of Fansly model leads without manual browsing.

---

### What It Does

Enter a search keyword and the scraper generates a clean list of Fansly model leads matching that term. Each lead includes full profile data — audience size, content volume, pricing, and verified social media contacts — so you can qualify and reach out immediately.

#### Broad vs. Specific Keywords

The keyword you choose directly controls your lead volume and targeting:

| Approach | Example Keywords | Best For |
|---|---|---|
| **Broad** | `girl`, `model`, `woman`, `sexy` | Maximum lead volume, large outreach campaigns |
| **Mid** | `latina`, `blonde`, `petite`, `ebony` | Balanced volume with trait targeting |
| **Specific** | `cosplay`, `fitness`, `goth`, `gaming` | Niche agency recruitment, targeted campaigns |

Use broad keywords when you want to **cast a wide net** and generate as many leads as possible. Use specific keywords when you want to **niche down** and find creators in a particular category for targeted outreach.

---

### Key Features

- 🎯 **Model lead generation** — purpose-built for agency recruitment and talent outreach
- 📋 **Ready-to-use lead lists** — export directly to CSV, Google Sheets, Airtable, or your CRM
- 📱 **Verified social contacts** — Instagram, Twitter/X, and TikTok handles and direct links per lead
- 👥 **Audience data** — follower counts, media likes, and engagement signals per model
- 💰 **Pricing intel** — full subscription tier breakdown so you know each model's current rates
- 📊 **Content volume** — image, video, and bundle counts to gauge how active each creator is
- 🎛️ **Lead qualification filters** — min followers, max price, require Instagram/TikTok/Twitter
- 📦 **Bulk generation** — hundreds of leads per run

---

### Who Is This For?

- **Model management agencies** sourcing Fansly talent for representation
- **Talent recruiters** building pipelines of adult content creators
- **Agency owners** who need a repeatable, scalable source of Fansly model leads
- **Solo managers** running DM outreach campaigns to Fansly models on Instagram or TikTok
- **Consultants** providing model lead generation as a service to agencies
- **Marketers** identifying Fansly creators for brand sponsorships and partnerships
- **Developers** building recruitment tools, CRMs, or dashboards on top of Fansly data

---

### Use Cases

#### Fansly Model Recruitment for Agencies
Generate targeted lists of Fansly models to pitch your agency to. Filter by follower count to only surface models with a proven audience, and use `requireInstagram: true` to ensure every lead has a contactable off-platform profile. Export to your outreach CRM and start working leads the same day.

#### Building a Fansly Model Lead Database
Run searches across multiple keywords — `model`, `latina`, `blonde`, `fitness`, `petite` — and combine the results into a comprehensive Fansly model database. Deduplicate by `accountId` for a clean, import-ready list.

#### Qualifying Leads Before Outreach
Use filters to pre-qualify leads before spending time on outreach. Set `minFollowers: 1000` to focus on models with real audiences. Set `maxSubscriptionPrice: 15` to find underpriced creators who might be open to agency management. Layer `requireInstagram: true` to guarantee every lead is reachable.

#### OnlyFans Model Lead Generation via Fansly
Many OnlyFans creators are simultaneously active on Fansly. Their Fansly profiles link to the same Instagram, Twitter, and TikTok accounts — making this scraper an effective source of OnlyFans-adjacent model leads as well.

#### Talent Scouting for Representation
Identify high-potential Fansly models before they're signed. Filter for creators with strong follower counts relative to subscriber counts — a signal of organic audience growth and receptiveness to professional management.

#### Competitor Agency Research
Understand the talent landscape in a given niche. See who's active, what they charge, and what content they produce. Use this intelligence to identify underserved niches and position your agency accordingly.

---

### Input

| Field | Type | Description |
|---|---|---|
| **Search Keywords** | String | Broad or niche keyword to generate leads from *(required)* |
| **Max Leads** | Integer | Maximum number of leads to generate per run. Default: `50` |
| **Minimum Followers** | Integer | Only include models with at least this many followers. Default: `0` |
| **Max Subscription Price (USD)** | Number | Filter to models at or below this monthly price. Leave empty for no limit |
| **Free Profiles Only** | Boolean | Only return models with a free subscription tier |
| **Must Have Instagram** | Boolean | Only return models with a linked Instagram account |
| **Must Have Twitter / X** | Boolean | Only return models with a linked Twitter / X account |
| **Must Have TikTok** | Boolean | Only return models with a linked TikTok account |
| **Proxy Configuration** | Object | Proxy settings — rotating residential proxies recommended |

---

### Output

Each Fansly model lead contains:

| Field | Description |
|---|---|
| `username` | Fansly username |
| `displayName` | Display name |
| `bio` | Full profile bio |
| `profileUrl` | Direct Fansly profile link |
| `avatarUrl` | Profile picture URL |
| `bannerUrl` | Banner image URL |
| `followers` | Total follower count |
| `mediaLikes` | Total media likes |
| `postLikes` | Total post likes |
| `imageCount` | Number of images posted |
| `videoCount` | Number of videos posted |
| `bundleCount` | Number of content bundles |
| `totalContent` | Total content count |
| `lowestMonthlyPrice` | Cheapest monthly subscription in USD |
| `freeSubscription` | Whether a free tier exists |
| `subscriptionTiers` | Full tier breakdown with names, prices, promo prices, benefits |
| `isStreamingEnabled` | Whether live streaming is active |
| `instagramHandle` / `instagramUrl` | Instagram username and direct link |
| `twitterHandle` / `twitterUrl` | Twitter/X username and direct link |
| `tiktokHandle` / `tiktokUrl` | TikTok username and direct link |
| `categories` | Content categories on their profile |
| `location` | Listed location |
| `joinedAt` | Account creation date |
| `lastSeenAt` | Last active timestamp |
| `accountId` | Fansly internal account ID |

---

### Output Views

Three built-in table views in the Apify console:

- **Overview** — Core lead data: avatar, name, followers, pricing, content counts, location
- **Social Links** — All social handles and clickable contact links in one focused view
- **Stats & Pricing** — Full content stats, subscription tiers, engagement, and activity dates

---

### Tips for Generating More Leads

**Use the broadest keyword that fits your target.** `girl` and `model` will return far more leads than `blonde fitness model`. Start broad, then filter down using the options below.

**Stack social filters for contactable leads only.** `requireInstagram: true` + `minFollowers: 500` gives you a clean list of models with real audiences who you can reach on Instagram today.

**Run multiple keyword searches and combine.** `girl`, `latina`, `asian`, `ebony`, `petite` — run each separately and merge datasets for maximum coverage. Deduplicate on `accountId`.

**Lower your follower minimum when targeting newer creators.** If you're an agency that develops talent from scratch, remove the follower filter entirely to surface early-stage models.

**Social filters reduce volume — account for it.** Only ~20–40% of Fansly models have Instagram linked. Set `Max Leads` higher than your target to ensure you hit your numbers after filtering.

---

### Frequently Asked Questions

**What's the difference between broad and specific keywords?**
Broad keywords like `girl` or `model` return the most leads and are best for large outreach campaigns. Specific keywords like `cosplay` or `fitness` return fewer leads but are more targeted — better for niche agency recruitment.

**Can I use this to generate OnlyFans model leads?**
Many creators are active on both platforms and link the same Instagram, Twitter, and TikTok accounts. This scraper is an effective way to source multi-platform adult model leads.

**How do I find Fansly models with Instagram for outreach?**
Enable `Must Have Instagram` — only models with a verified, linked Instagram account will be included. Pair with `minFollowers` to filter for established creators.

**Can I export leads to Google Sheets or a CRM?**
Yes — results export to CSV, JSON, or Excel from the Apify dataset. Fields are flat and import-ready for Google Sheets, Airtable, HubSpot, Notion, or any spreadsheet.

**How many leads can I generate per run?**
As many as the search returns for your keyword. Broad terms like `girl` or `model` typically return hundreds of profiles. Set `Max Leads` to your target number.

**Can I filter leads by subscription price?**
Yes — use `Max Subscription Price` to cap by monthly USD rate. Useful for finding underpriced creators or models in a specific pricing tier.

**Can I run this on a schedule to get fresh leads regularly?**
Yes — use Apify's built-in scheduling to run the scraper daily or weekly and continuously refresh your lead pipeline.

**How do I get the most leads from a single run?**
Use a broad keyword, set `Max Leads` high, and avoid social filters unless contact info is required. This maximizes the raw lead pool before qualification.

---

*fansly model leads · fansly model lead generation · model agency leads · adult model leads · fansly talent recruitment · fansly creator leads · model management leads · onlyfans model leads · adult creator leads · fansly agency tool · model recruitment scraper · fansly instagram leads · fansly outreach list · fansly model database · talent scouting tool · fansly model finder · fansly lead scraper · fansly contact list · model lead generation tool · adult content creator leads · fansly talent acquisition · fansly model list · creator recruitment · model agency sourcing*

# Actor input Schema

## `searchQuery` (type: `string`):

Keywords to find model leads. Use broad terms like 'girl', 'model', or 'latina' to cast a wide net and maximize lead volume. Use specific terms like 'cosplay', 'blonde', or 'fitness' to target a particular niche.
## `maxResults` (type: `integer`):

Maximum number of model leads to generate per run.
## `minFollowers` (type: `integer`):

Only include models with at least this many followers. Useful for targeting established creators with a proven audience.
## `maxSubscriptionPrice` (type: `number`):

Only include models whose cheapest monthly plan costs this amount or less. Leave empty for no limit.
## `requireFree` (type: `boolean`):

Only return models with a free subscription tier.
## `requireInstagram` (type: `boolean`):

Only return models with a linked Instagram account — essential for direct outreach and contact.
## `requireTwitter` (type: `boolean`):

Only return models with a linked Twitter / X account.
## `requireTikTok` (type: `boolean`):

Only return models with a linked TikTok account.
## `proxyConfiguration` (type: `object`):

Proxy settings. Rotating residential proxies are strongly recommended for reliability.

## Actor input object example

```json
{
  "searchQuery": "girl",
  "maxResults": 200,
  "minFollowers": 0,
  "requireFree": false,
  "requireInstagram": false,
  "requireTwitter": false,
  "requireTikTok": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
````

# Actor output Schema

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

No description

## `socialLinks` (type: `string`):

No description

## `statsAndPricing` (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 = {
    "searchQuery": "girl"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sentry/fansly-model-leads-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "searchQuery": "girl" }

# Run the Actor and wait for it to finish
run = client.actor("sentry/fansly-model-leads-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQuery": "girl"
}' |
apify call sentry/fansly-model-leads-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fansly Model Leads Scraper",
        "description": "Generate Fansly model leads at scale — scrape creator profiles with follower counts, subscription pricing, and verified Instagram, Twitter & TikTok contacts. The go-to tool for model agencies, talent managers, and recruiters sourcing Fansly talent.",
        "version": "1.0",
        "x-build-id": "y0FP6D574FYedl2Wq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sentry~fansly-model-leads-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sentry-fansly-model-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/sentry~fansly-model-leads-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sentry-fansly-model-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/sentry~fansly-model-leads-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sentry-fansly-model-leads-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search Keywords",
                        "type": "string",
                        "description": "Keywords to find model leads. Use broad terms like 'girl', 'model', or 'latina' to cast a wide net and maximize lead volume. Use specific terms like 'cosplay', 'blonde', or 'fitness' to target a particular niche."
                    },
                    "maxResults": {
                        "title": "Max Leads",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of model leads to generate per run.",
                        "default": 200
                    },
                    "minFollowers": {
                        "title": "Minimum Followers",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include models with at least this many followers. Useful for targeting established creators with a proven audience.",
                        "default": 0
                    },
                    "maxSubscriptionPrice": {
                        "title": "Max Subscription Price (USD)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only include models whose cheapest monthly plan costs this amount or less. Leave empty for no limit."
                    },
                    "requireFree": {
                        "title": "Free Profiles Only",
                        "type": "boolean",
                        "description": "Only return models with a free subscription tier.",
                        "default": false
                    },
                    "requireInstagram": {
                        "title": "Must Have Instagram",
                        "type": "boolean",
                        "description": "Only return models with a linked Instagram account — essential for direct outreach and contact.",
                        "default": false
                    },
                    "requireTwitter": {
                        "title": "Must Have Twitter / X",
                        "type": "boolean",
                        "description": "Only return models with a linked Twitter / X account.",
                        "default": false
                    },
                    "requireTikTok": {
                        "title": "Must Have TikTok",
                        "type": "boolean",
                        "description": "Only return models with a linked TikTok account.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Rotating residential proxies are strongly recommended for reliability.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
