# Instagram Followers Scraper (`scrapapi/instagram-followers-scraper`) Actor

📸 Instagram Followers Scraper pulls clean follower lists from public IG profiles — usernames, full names, bios, follower/following counts, verified & profile URLs. ⚡ Export CSV/JSON for influencer outreach, competitor analysis & audience research. ✅ Fast, reliable, compliant.

- **URL**: https://apify.com/scrapapi/instagram-followers-scraper.md
- **Developed by:** [ScrapAPI](https://apify.com/scrapapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 6 total users, 1 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 Followers Scraper

The Instagram Followers Scraper is a production-ready Apify actor that extracts structured follower lists from public Instagram profiles — fast and reliably. It solves the tedious task of copying follower data by automating collection at scale, making it ideal for marketers, developers, data analysts, and researchers. Use this IG followers scraper to build clean datasets for influencer outreach, competitor analysis, and audience research, then export Instagram followers to CSV or JSON for downstream workflows. With robust proxy fallback and live saving, it enables repeatable, large-scale Instagram followers list export with confidence.

### What data / output can you get?

Below are the exact JSON fields the actor saves to the dataset as it runs. Records are pushed in real time with deduplication.

| Data type | Description | Example value |
| --- | --- | --- |
| pk | Primary key (user ID as string) | "73320179592" |
| pk_id | Primary key ID (fallback to pk) | "73320179592" |
| id | User ID (fallback to pk) | "73320179592" |
| username | Instagram handle | "davabukandaffa5" |
| full_name | Display name | "arizki" |
| profile_pic_url | Profile picture URL | "https://instagram.fna.fbcdn.net/..." |
| profile_pic_id | Profile picture ID | "311590022154..." |
| is_verified | Verification badge flag | false |
| is_private | Privacy flag | true |
| has_anonymous_profile_picture | Default/anonymous avatar flag | false |
| account_badges | Array of account badges | [] |
| latest_reel_media | Latest reel timestamp (epoch) or 0 | 0 |
| is_favorite | Favorite flag | false |
| fbid_v2 | Facebook ID v2 (string) | "17841400000000000" |
| strong_id__ | Strong ID (fallback to pk) | "73320179592" |
| third_party_downloads_enabled | Third-party downloads flag | 0 |
| followed_by | The source profile whose network is being collected | "cristiano" |
| success | Collection status flag (present on follower-list entries) | true |

Notes:
- Export formats: Download your dataset as CSV, JSON, or Excel directly from the Apify Console.
- Bonus users from comments: To help you reach your max follower target, the actor may also include additional public user profiles found in comments on the profile’s posts. These entries contain the same fields (without the “success” flag).

### Key features

- ⚡ Live, incremental saving
  Saves each user to the dataset as soon as it’s found — minimizing data loss and giving you immediate access to partial results.

- 🧠 Smart proxy fallback
  Automatically adapts your connection: no proxy → datacenter proxy → residential proxy (with up to 3 retries on residential) when access is limited.

- 📈 Batch scraping & bulk automation
  Process multiple Instagram profiles in a single run and target a specific number of users per profile with maxData.

- 🔄 Robust retry logic
  Built-in HTTP retry with exponential backoff and graceful handling of 429/403 responses for higher success rates.

- 🧹 Deduplication by user ID
  Prevents duplicate records within each run using a seen_ids set.

- 🧾 Clean, structured output
  Produces consistent records with stable identifiers and metadata, ready to export Instagram followers to CSV or JSON.

- 🛠 Developer-friendly
  Works seamlessly with Apify Datasets and the Apify platform — ideal for pipelines, automation, and integrations.

- 📊 Detailed logging
  Clear, real-time progress updates (e.g., every 25 saved followers) to monitor large runs.

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

1. Create or log in to your Apify account.
2. Open the actor “instagram-followers-scraper” in the Apify Console.
3. Add input:
   - Paste Instagram profile URLs or usernames into startUrls (one per line). Both formats are accepted, e.g.:
     - https://www.instagram.com/cristiano/
     - cristiano
4. Configure settings:
   - Set maxData to the number of users you want per profile (default 100).
   - Optionally add your Instagram sessionId cookie to improve access and stability.
   - Optionally enable proxyConfiguration (Apify Proxy). The actor will auto-fallback when blocked.
5. Start the run.
6. Watch logs for milestones and progress (e.g., saved counts every 25 users).
7. Download results from the Dataset:
   - Export to JSON, CSV, or Excel for analysis and enrichment.

Pro Tip: Provide a valid sessionId and enable Apify Proxy for the best success rate when you download Instagram followers list at scale.

### Use cases

| Use case name | Description |
| --- | --- |
| Social media analytics + audience insights | Analyze public follower profiles to understand audience composition and engagement patterns for content planning. |
| Influencer research + outreach targeting | Build structured lists of public followers for influencer vetting and targeted outreach. |
| Competitor analysis + benchmarking | Compare public follower bases across competing brands to inform growth strategies. |
| Market research + segmentation | Enrich surveys and studies with public follower snapshots by niche and geography. |
| CRM enrichment + lead lists | Export Instagram followers to CSV/JSON and merge into your CRM for segmentation and prospecting. |
| Academic research + datasets | Collect public follower data for reproducible studies on network effects and online behavior. |
| Automation pipelines on Apify | Chain runs to schedule recurring collections and feed datasets into processing workflows. |

### Why choose Instagram Followers Scraper?

Built for precision, scale, and reliability on Apify — not a brittle browser extension.

- ✅ Accurate, structured output with stable identifiers and metadata
- ⚡ Bulk processing with live, incremental saving
- 🔄 Smart proxy fallback and retry logic for resilient runs
- 🧹 Deduplication to keep datasets clean
- 🛠 Works seamlessly with Apify Datasets for CSV/JSON exports
- 🛡 Designed for public data collection with clear status logging
- 💰 Cost-effective and automation-ready for recurring workloads

Bottom line: a reliable Instagram followers scraping tool for exports and analytics — without the instability of manual extensions.

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

Yes — when used responsibly. This actor is designed to collect data from publicly accessible Instagram content and does not access private profiles or password-protected content.

Guidelines for compliant use:
- Collect only publicly available data.
- Respect Instagram’s terms and applicable data protection laws (e.g., GDPR, CCPA).
- Avoid spam and unlawful re-identification or misuse of data.
- Consult your legal team for jurisdiction-specific requirements.

The end user is responsible for ensuring their use complies with all laws and platform policies.

### Input parameters & output format

Example JSON input
```json
{
  "startUrls": [
    "https://www.instagram.com/cristiano/",
    "nike",
    "https://www.instagram.com/natgeo/"
  ],
  "maxData": 250,
  "sessionId": "80339464000%3AMwlUEdZkdshtFG%3A5%3AAYiJEi32U_OOJkvXyc232wBhDZz1Q4zQOFhTFSTy3g",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
````

Input parameters

- startUrls (array, required)
  - Description: List of Instagram profile URLs or usernames to scrape followers from.
  - Default: none
- maxData (integer, optional)
  - Description: Maximum number of users to collect per profile. Range: 1–100,000. Default is recommended for faster results.
  - Default: 100
- sessionId (string, optional)
  - Description: Instagram sessionid cookie. Optional but strongly recommended for better success rates.
  - Default: none
- proxyConfiguration (object, optional)
  - Description: Apify Proxy configuration. Smart fallback supported (no proxy → datacenter → residential with retries).
  - Default: {"useApifyProxy": false}

Example JSON output

```json
[
  {
    "pk": "73320179592",
    "pk_id": "73320179592",
    "id": "73320179592",
    "full_name": "arizki",
    "is_private": true,
    "fbid_v2": "17841400000000000",
    "third_party_downloads_enabled": 0,
    "strong_id__": "73320179592",
    "profile_pic_id": "311590022154",
    "profile_pic_url": "https://instagram.fna.fbcdn.net/...",
    "is_verified": false,
    "username": "davabukandaffa5",
    "has_anonymous_profile_picture": false,
    "account_badges": [],
    "latest_reel_media": 0,
    "is_favorite": false,
    "followed_by": "cristiano",
    "success": true
  }
]
```

Notes:

- Records are pushed as soon as they’re found. Fields like full\_name, profile\_pic\_url, or fbid\_v2 may be empty if not publicly available.
- Additional records sourced from post comments to help reach maxData use the same schema but may omit the success field.

### FAQ

#### Do I need a session ID to run this IG followers scraper?

✅ It’s optional but strongly recommended. You can run without a sessionId, but access may be limited and success rates lower. Adding a valid sessionId cookie increases reliability.

#### Can I scrape Instagram followers by username and by URL?

✅ Yes. You can provide either usernames (e.g., “nike”) or full profile URLs (e.g., “https://www.instagram.com/nike/”) in startUrls. The actor normalizes both formats.

#### How many followers can I export per profile?

📈 Controlled by maxData. The input schema supports 1–100,000 users per profile. Performance depends on access conditions and rate limits.

#### Can it export Instagram followers to CSV?

✅ Yes. After the run, open the Dataset in Apify and export Instagram followers to CSV, JSON, or Excel.

#### What happens if Instagram blocks my requests?

🔄 The actor automatically retries and falls back from no proxy to datacenter, then to residential proxy with up to 3 retries on residential connections to improve success rates.

#### Does it collect only followers?

➕ The actor first collects followers via the followers endpoint. If you haven’t reached maxData, it may also collect additional public user profiles found in comments on the profile’s posts to help you reach your target.

#### Can it scrape private accounts?

❌ No. If a profile is private or inaccessible, the actor won’t collect its followers. It’s designed for publicly accessible profiles only.

#### How does the actor avoid duplicates?

🧹 It uses a seen\_ids set during the run to prevent duplicate user records from being saved.

### Closing CTA / Final thoughts

This Instagram followers extractor is built to pull clean, structured follower lists from public IG profiles at scale. With smart proxy fallback, live saving, and deduplication, it’s a dependable Instagram followers export tool for marketers, developers, analysts, and researchers. Run bulk jobs, download Instagram followers list to CSV/JSON, and feed datasets into your workflows on Apify. Start exporting IG followers to CSV with a reliable, automation-ready Instagram followers scraping tool today.

# Actor input Schema

## `startUrls` (type: `array`):

📋 List of Instagram profile URLs or usernames to scrape followers from.

💡 Examples:
• https://www.instagram.com/cristiano/
• https://www.instagram.com/nike/
• cristiano
• nike

✨ You can add multiple profiles to scrape in one run!

## `maxData` (type: `integer`):

🎯 Set the maximum number of followers to collect per profile.

📈 Range: 1-100,000 followers
💡 Default: 100 followers (recommended for faster results)

⚡ Tip: Lower values = faster scraping, Higher values = more comprehensive results

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

🔐 Optional but strongly recommended for better success rates.

📝 How to get your Session ID:

1. Log into Instagram in your browser
2. Open Developer Tools (F12 or Right-click → Inspect)
3. Go to Application/Storage → Cookies → https://www.instagram.com
4. Find and copy the 'sessionid' value

💡 Example format: 80339464000%3AMwlUEdZkdshtFG%3A5%3AAYiJEi32U\_OOJkvXyc232wBhDZz1Q4zQOFhTFSTy3g

⚠️ Note: Without a session ID, the scraper may have limited access and lower success rates.

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

🛡️ Configure proxy settings for enhanced reliability and bypassing restrictions.

🔄 Smart Fallback System:
1️⃣ No proxy (default) - Direct connection
2️⃣ Datacenter proxy - If configured
3️⃣ Residential proxy - Automatic fallback if blocked

✅ The actor automatically switches to residential proxy if requests are blocked (with 3 retries).

💡 Recommended: Enable proxy for better success rates!

## Actor input object example

```json
{
  "startUrls": [
    "https://www.instagram.com/cristiano/"
  ],
  "maxData": 100,
  "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 = {
    "startUrls": [
        "https://www.instagram.com/cristiano/"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Followers Scraper",
        "description": "📸 Instagram Followers Scraper pulls clean follower lists from public IG profiles — usernames, full names, bios, follower/following counts, verified & profile URLs. ⚡ Export CSV/JSON for influencer outreach, competitor analysis & audience research. ✅ Fast, reliable, compliant.",
        "version": "0.1",
        "x-build-id": "aF35zertx8npBKZ3G"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~instagram-followers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-instagram-followers-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/scrapapi~instagram-followers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-instagram-followers-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/scrapapi~instagram-followers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-instagram-followers-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "📋 Instagram Profile URLs or Usernames",
                        "type": "array",
                        "description": "📋 List of Instagram profile URLs or usernames to scrape followers from.\n\n💡 Examples:\n• https://www.instagram.com/cristiano/\n• https://www.instagram.com/nike/\n• cristiano\n• nike\n\n✨ You can add multiple profiles to scrape in one run!",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxData": {
                        "title": "📊 Maximum Followers per Profile",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "🎯 Set the maximum number of followers to collect per profile.\n\n📈 Range: 1-100,000 followers\n💡 Default: 100 followers (recommended for faster results)\n\n⚡ Tip: Lower values = faster scraping, Higher values = more comprehensive results",
                        "default": 100
                    },
                    "sessionId": {
                        "title": "🍪 Instagram sessionid (recommended)",
                        "type": "string",
                        "description": "🔐 Optional but strongly recommended for better success rates.\n\n📝 How to get your Session ID:\n1. Log into Instagram in your browser\n2. Open Developer Tools (F12 or Right-click → Inspect)\n3. Go to Application/Storage → Cookies → https://www.instagram.com\n4. Find and copy the 'sessionid' value\n\n💡 Example format: 80339464000%3AMwlUEdZkdshtFG%3A5%3AAYiJEi32U_OOJkvXyc232wBhDZz1Q4zQOFhTFSTy3g\n\n⚠️ Note: Without a session ID, the scraper may have limited access and lower success rates."
                    },
                    "proxyConfiguration": {
                        "title": "🔒 Proxy Configuration",
                        "type": "object",
                        "description": "🛡️ Configure proxy settings for enhanced reliability and bypassing restrictions.\n\n🔄 Smart Fallback System:\n1️⃣ No proxy (default) - Direct connection\n2️⃣ Datacenter proxy - If configured\n3️⃣ Residential proxy - Automatic fallback if blocked\n\n✅ The actor automatically switches to residential proxy if requests are blocked (with 3 retries).\n\n💡 Recommended: Enable proxy for better success rates!"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```