# Instagram Following Scraper (`scraperforge/instagram-following-scraper`) Actor

📲 Instagram Following Scraper pulls public following lists — usernames, names, bios, categories, verification, profile links. ⚡ Fast, accurate data for competitor analysis, influencer outreach, audience mapping & growth. 🧩 CSV/JSON export.

- **URL**: https://apify.com/scraperforge/instagram-following-scraper.md
- **Developed by:** [ScraperForge](https://apify.com/scraperforge) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Instagram Following Scraper

Instagram Following Scraper is a focused IG following scraper tool that collects public “following” lists for one or more Instagram profiles and saves results in real time to your Apify dataset. It solves the “export Instagram following list” problem by extracting structured account details (usernames, names, bios-related metadata, verification flags, profile picture info, and more) that you can download as CSV/JSON. Built for marketers, developers, data analysts, and researchers, this Instagram following list scraper enables scalable audience mapping, competitor analysis, and influencer outreach with reliable pagination and proxy fallback.

### What data / output can you get?

Each dataset item corresponds to an account from the target’s following list and includes the following fields (pushed in real time as they’re collected):

- pk — Primary user identifier. Example: "1234567890"
- pk_id — Secondary identifier (falls back to pk if missing). Example: "1234567890"
- id — Identifier (falls back to pk if missing). Example: "1234567890"
- full_name — Display name. Example: "Jane Doe"
- is_private — Whether the profile is private. Example: false
- fbid_v2 — Facebook-backed ID variant. Example: "17841400000000000"
- third_party_downloads_enabled — Third‑party downloads flag. Example: false
- strong_id__ — Strong identifier if present. Example: "1234567890"
- profile_pic_id — Profile picture ID. Example: "3141592653"
- profile_pic_url — Direct URL to the profile picture. Example: "https://instagram.fxyz1-1.fna.fbcdn.net/v/t51.2885-19/..."
- is_verified — Verification status. Example: true
- username — Instagram handle. Example: "janedoe"
- has_anonymous_profile_picture — Whether the user has a default/anonymous avatar. Example: false
- account_badges — Badges array. Example: []
- latest_reel_media — Latest reel/story timestamp if available. Example: 1712448000
- is_favorite — Favorite flag if present. Example: false
- followed_by — The input username whose following list this entry came from. Example: "targetaccount"

Example JSON output item:
```json
{
  "pk": "1234567890",
  "pk_id": "1234567890",
  "id": "1234567890",
  "full_name": "Jane Doe",
  "is_private": false,
  "fbid_v2": "17841400000000000",
  "third_party_downloads_enabled": false,
  "strong_id__": "1234567890",
  "profile_pic_id": "3141592653",
  "profile_pic_url": "https://instagram.fxyz1-1.fna.fbcdn.net/v/t51.2885-19/...",
  "is_verified": true,
  "username": "janedoe",
  "has_anonymous_profile_picture": false,
  "account_badges": [],
  "latest_reel_media": 1712448000,
  "is_favorite": false,
  "followed_by": "targetaccount"
}
````

Notes:

- Results stream to the Apify dataset during the run. You can download as CSV or JSON from the Run’s Dataset tab.
- Some fields can be empty or null if Instagram doesn’t return them for a given account.

### Key features

- ⚡️ Resilient proxy fallback
  Starts direct, then automatically escalates to datacenter proxy, and finally to residential proxy with retries and sticky mode after escalation for maximum reliability on Instagram.

- 📦 Bulk input for scale
  Feed multiple profile URLs or usernames in one run to scrape Instagram following list data at scale for competitor benchmarking and audience mapping.

- 💾 Live dataset writes
  Pushes each item to the dataset as soon as it’s extracted, so you can monitor progress and start analyzing early.

- 🧭 Clear progress logs
  Informative logs like “collecting X/Y following data for @username” keep long runs transparent and easy to track.

- 🧱 Stable session support
  Optional sessionId (Instagram sessionid cookie) improves stability and reduces blocks for smoother data collection.

- 📤 Easy exports
  Download your Instagram following list CSV or JSON directly from the Apify dataset for analysis, enrichment, or import into BI tools.

- 🧰 Developer friendly
  Built as a production-grade Apify Actor with clean, consistent output schema—ideal for pipelines, data ops, and integration with your stack.

### How to use Instagram Following Scraper - step by step

1. Sign in to Apify
   Log in to your Apify account (or create one for free).

2. Open the actor
   Find “Instagram Following Scraper” by ScraperForge on the Apify Store and click Try for free.

3. Add targets
   In the input, paste Instagram profile URLs or usernames under urls. Examples:
   - https://www.instagram.com/mrbeast/
   - virat.kohli

4. Set limits and stability
   - maxItems: Set how many following users to collect per profile (0 = unlimited).
   - sessionId (optional but recommended): Paste the value of your Instagram sessionid cookie from a logged-in browser session to reduce blocks.

5. Configure proxy (optional)
   By default, the actor starts with no proxy. If blocked, it auto‑falls back to datacenter and then residential (sticky). You can also pass proxyConfiguration input if needed.

6. Start the run
   Click Start. Watch logs such as:
   - “Starting Instagram following scraper”
   - “🔎 \[1/N] Scraping @username”
   - “collecting X/Y following data for @username”

7. Export results
   Open the Dataset tab of the run to download your data as CSV or JSON. Use it as an Instagram following exporter for analysis, audience mapping, and outreach.

Pro tip: For large accounts, start with a reasonable maxItems (e.g., 100–1000) and provide a sessionId for fewer blocks. Add multiple profiles to download Instagram following lists in bulk.

### Use cases

- Competitor analysis — Benchmark who your competitors follow to identify partnerships, categories, and content interests.
- Influencer outreach — Build prospect lists from creators’ following to find adjacent influencers and brand collaborators.
- Audience mapping — Map networks for niche communities and uncover accounts to follow or engage with at scale.
- Market research — Enrich datasets with verified usernames and metadata to study categories and trends.
- Data enrichment pipeline — Feed structured following records (CSV/JSON) into CRMs, CDPs, or analytics workflows.
- Academic or social research — Analyze public networks, verification patterns, and account attributes programmatically.

### Why choose Instagram Following Scraper?

- 🎯 Precision output: Consistent, integration‑ready schema that matches the pushed dataset fields exactly.
- 🧱 Built‑in resilience: Direct → datacenter → residential proxy fallback with retries and stickiness for reliability.
- 📈 Scales with you: Bulk input lets you scrape Instagram following lists across many profiles in one run.
- 👨‍💻 Developer‑ready: Clean JSON structure and predictable behavior for easy automation and pipelines.
- 🔐 Responsible by design: Targets publicly available data; optional sessionId strengthens stability without risky automation.
- 💸 Practical value: Use as an Instagram following extractor and Instagram following list export tool with simple CSV/JSON downloads.
- 🧾 Transparent runs: Real‑time dataset writes and rich logs for progress visibility.

### Is it legal / ethical to use Instagram Following Scraper?

Yes—when done responsibly. This actor collects publicly available information only and does not access private profiles or non‑public data. You are responsible for ensuring that your use complies with Instagram’s terms, as well as applicable laws and regulations (e.g., GDPR, CCPA). Avoid scraping private accounts, respect rate limits and platform policies, and consult your legal team for edge cases.

### Input parameters & output format

Example JSON input:

```json
{
  "urls": [
    "https://www.instagram.com/mrbeast/",
    "virat.kohli"
  ],
  "maxItems": 100,
  "sessionId": "YOUR_SESSIONID_COOKIE_VALUE",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

Parameters (from the input schema):

- urls (array, required): One or more Instagram profiles to scrape. Accepts full profile URLs (https://www.instagram.com/username/) or plain usernames (username). Default: none.
- maxItems (integer, optional): Maximum number of following users to collect per input profile. 0 = unlimited (collect until pagination ends). Default: 100.
- sessionId (string, optional): Instagram sessionid cookie value from a logged‑in browser session. Strongly recommended for stability. Default: none.
- proxyConfiguration (object, optional): Proxy settings. Default is no proxy; if blocked, the actor automatically falls back to datacenter → residential (sticky). Default: {"useApifyProxy": false}.

Example JSON output item (dataset):

```json
{
  "pk": "1234567890",
  "pk_id": "1234567890",
  "id": "1234567890",
  "full_name": "Jane Doe",
  "is_private": false,
  "fbid_v2": "17841400000000000",
  "third_party_downloads_enabled": false,
  "strong_id__": "1234567890",
  "profile_pic_id": "3141592653",
  "profile_pic_url": "https://instagram.fxyz1-1.fna.fbcdn.net/v/t51.2885-19/...",
  "is_verified": true,
  "username": "janedoe",
  "has_anonymous_profile_picture": false,
  "account_badges": [],
  "latest_reel_media": 1712448000,
  "is_favorite": false,
  "followed_by": "targetaccount"
}
```

Notes:

- Some fields may be empty if Instagram doesn’t return them (e.g., latest\_reel\_media). The actor preserves the keys for consistent downstream processing.
- Results are available in the run’s default dataset and can be downloaded as CSV or JSON.

### FAQ

#### Is there a free trial or pricing plan?

Yes. The actor offers a monthly plan at $19.99 and includes 120 trial minutes, according to the Apify Store listing. You can start with the trial to evaluate performance before subscribing.

#### Do I need to log in or provide cookies?

No login is strictly required, but providing the sessionId (Instagram sessionid cookie) is strongly recommended for stability and to reduce blocks. You can run without it, but you may encounter more challenges.

#### Can it scrape private accounts or private following lists?

No. The actor targets publicly available data only. If a profile or its following list is not public, the data will not be accessible.

#### Can I export Instagram following lists to CSV or JSON?

Yes. After the run finishes (and even during it), open the Dataset tab of your run to export your

# Actor input Schema

## `urls` (type: `array`):

✅ Full profile links work great
✅ Plain `@handle` or `handle` works too
✅ Add as many as you need for a **bulk** run

💜 *Example:* `https://www.instagram.com/mrbeast/`

## `maxItems` (type: `integer`):

🔢 **Limit** how many accounts to collect **for each** profile in your list.

✨ `0` = **no cap** (keep going until the list ends)
🧪 Not sure? Start with **100–500** and adjust next time

⏱️ Bigger numbers = longer runs — plan accordingly!

## `sessionId` (type: `string`):

📌 **Strongly recommended**

🧭 Copy the `sessionid` value from your Instagram cookies in the browser where you’re already logged in, and paste it here.

🙈 It stays private to your run — never share it publicly.

💤 You *can* leave this empty, but runs may be less reliable.

## `proxyConfiguration` (type: `object`):

🎛️ **Default:** run without a special proxy (simple & direct).

🔧 Need Apify Proxy? Toggle it here and pick the options that match your plan.

✨ The actor adapts automatically when the platform is picky — you’ll see friendly notes in the log.

## Actor input object example

```json
{
  "urls": [
    "https://www.instagram.com/mrbeast/"
  ],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "urls": [
        "https://www.instagram.com/mrbeast/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperforge/instagram-following-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 = {
    "urls": ["https://www.instagram.com/mrbeast/"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scraperforge/instagram-following-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 '{
  "urls": [
    "https://www.instagram.com/mrbeast/"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraperforge/instagram-following-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Following Scraper",
        "description": "📲 Instagram Following Scraper pulls public following lists — usernames, names, bios, categories, verification, profile links. ⚡ Fast, accurate data for competitor analysis, influencer outreach, audience mapping & growth. 🧩 CSV/JSON export.",
        "version": "0.1",
        "x-build-id": "8k0FBNiqJH0sd4wQ5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperforge~instagram-following-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperforge-instagram-following-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/scraperforge~instagram-following-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperforge-instagram-following-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/scraperforge~instagram-following-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperforge-instagram-following-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "🔗 Profiles (URLs or usernames)",
                        "type": "array",
                        "description": "✅ Full profile links work great\n✅ Plain `@handle` or `handle` works too\n✅ Add as many as you need for a **bulk** run\n\n💜 *Example:* `https://www.instagram.com/mrbeast/`",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "📊 Max following count (per profile)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "🔢 **Limit** how many accounts to collect **for each** profile in your list.\n\n✨ `0` = **no cap** (keep going until the list ends)\n🧪 Not sure? Start with **100–500** and adjust next time\n\n⏱️ Bigger numbers = longer runs — plan accordingly!",
                        "default": 10
                    },
                    "sessionId": {
                        "title": "🔑 Instagram session cookie",
                        "type": "string",
                        "description": "📌 **Strongly recommended**\n\n🧭 Copy the `sessionid` value from your Instagram cookies in the browser where you’re already logged in, and paste it here.\n\n🙈 It stays private to your run — never share it publicly.\n\n💤 You *can* leave this empty, but runs may be less reliable."
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy settings",
                        "type": "object",
                        "description": "🎛️ **Default:** run without a special proxy (simple & direct).\n\n🔧 Need Apify Proxy? Toggle it here and pick the options that match your plan.\n\n✨ The actor adapts automatically when the platform is picky — you’ll see friendly notes in the log."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```