# Instagram Followers & Following Scraper (CSV/JSON, No Login) (`convertfleetdotonline/instagram-followers-scraper`) Actor

Export Instagram followers or following lists from public profiles to JSON, CSV or Excel. Username, full name, user ID, profile picture, verified & private flags. Multiple accounts per run, auto-pagination, residential-proxy ready.

- **URL**: https://apify.com/convertfleetdotonline/instagram-followers-scraper.md
- **Developed by:** [Hasnain Nisar](https://apify.com/convertfleetdotonline) (community)
- **Categories:** Social media, Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 & Following Scraper 🟣 Export Lists to CSV / JSON

**Export the followers or following list of any public Instagram profile — in seconds, with no app to install and no API key to register.** Paste one or more usernames, choose **Followers** or **Following**, set a limit, and download clean, structured data: username, full name, user ID, profile URL, profile picture, plus verified ✅ and private 🔒 flags.

Built for **lead generation, influencer discovery, competitor audience analysis, and social-media research** — and ready to plug into Google Sheets, Make, Zapier, n8n, or your own code via the Apify API.

---

### ⚡ At a glance

| | |
|---|---|
| **What you get** | Followers **or** Following lists from any public Instagram account |
| **Output fields** | `username`, `full_name`, `id`, `profile_url`, `profile_pic_url`, `is_verified`, `is_private` |
| **Input** | One or many usernames / profile URLs |
| **Export formats** | JSON · CSV · Excel · XML · HTML · API |
| **Multiple accounts** | ✅ Yes — batch as many as you like in one run |
| **Auto-pagination** | ✅ Scrolls automatically until your limit is reached |
| **Login required** | ❌ No login — bring an optional `sessionId` cookie for full lists |
| **Proxy** | Residential-proxy ready (recommended for Instagram) |
| **Best for** | Lead gen · influencer research · audience analysis · CRM enrichment |

---

### 🎯 What this Actor does

- ✅ Scrapes the **followers** of any public Instagram profile.
- ✅ Scrapes the **following** list of any public Instagram profile.
- ✅ Accepts **multiple usernames** (or full profile URLs) in a single run.
- ✅ **Auto-paginates** until it reaches your `resultsLimit` per account.
- ✅ Returns **clean, deduplicated, structured rows** — no HTML, no noise.
- ✅ Flags **verified** and **private** accounts so you can segment instantly.
- ✅ Exports to **CSV, JSON, Excel, XML, or API** with one click.
- ✅ Works through **Apify Residential Proxy** for reliability at scale.

---

### 💡 Who uses it & why

| Use case | How this Actor helps |
|---|---|
| **Lead generation** | Pull the followers of an account your ideal customers already follow, then enrich & outreach. |
| **Influencer discovery** | Find verified creators inside a niche audience; spot micro-influencers your competitors miss. |
| **Competitor audience analysis** | Compare the follower bases of two brands to size overlap and opportunity. |
| **Audience enrichment** | Append usernames + display names to an existing CRM or list. |
| **Growth & market research** | Build datasets of who follows whom across an industry. |
| **Brand & community monitoring** | Track who is following key accounts in your space over time. |
| **Outreach & partnerships** | Build targeted prospect lists of relevant, active profiles. |

---

### 🚀 Quick start

1. Add one or more usernames to **Account** (e.g. `nasa`, `mrbeast`).
2. Choose **Followers** or **Following** under **What to scrape**.
3. Set **Max results per account** (start with `100` to validate the output).
4. *(Recommended)* paste your Instagram **sessionId** so the full list is accessible.
5. Click **Start** and download the dataset as CSV / JSON / Excel.

#### Example input

```json
{
  "Account": ["nasa", "mrbeast"],
  "dataToScrape": "Followers",
  "resultsLimit": 500,
  "sessionId": "PASTE_YOUR_SESSIONID_HERE",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

#### Example output

```json
[
  {
    "username_scrape": "nasa",
    "type": "Followers",
    "id": "4014759590",
    "username": "realcolinfurze",
    "full_name": "colin furze",
    "is_private": false,
    "is_verified": true,
    "profile_pic_url": "https://instagram.fxxx.fna.fbcdn.net/...jpg",
    "profile_url": "https://www.instagram.com/realcolinfurze/"
  },
  {
    "username_scrape": "nasa",
    "type": "Followers",
    "id": "71544071714",
    "username": "drink.love",
    "full_name": "Drink Love",
    "is_private": false,
    "is_verified": false,
    "profile_pic_url": "https://instagram.fxxx.fna.fbcdn.net/...jpg",
    "profile_url": "https://www.instagram.com/drink.love/"
  }
]
```

***

### 📥 Input parameters

| Field | Type | Required | Description |
|---|---|---|---|
| `Account` | array of strings | ✅ | Instagram usernames or profile URLs. One per line. |
| `dataToScrape` | `Followers` | `Following` | ✅ | Which list to export from each account. |
| `resultsLimit` | integer (1–500000) | ✅ | Max profiles to return **per account**. |
| `sessionId` | string (secret) | optional | Your Instagram `sessionid` cookie. Required for full list export. |
| `proxyConfiguration` | object | optional | Apify proxy. Residential strongly recommended. |

### 📤 Output fields

| Field | Description |
|---|---|
| `username_scrape` | The source account you requested |
| `type` | `Followers` or `Following` |
| `id` | Numeric Instagram user ID of the extracted profile |
| `username` | Instagram handle of the extracted profile |
| `full_name` | Display name |
| `is_private` | Whether that profile is private |
| `is_verified` | Whether that profile is verified ✅ |
| `profile_pic_url` | Direct profile-picture URL |
| `profile_url` | Clickable `instagram.com/<username>` link |

***

### 🔑 How to get your Instagram `sessionId` (1 minute)

Instagram blocks follower/following lists for logged-out requests — **every** reliable scraper signs its reads with a logged-in session. Supplying your own `sessionId` keeps you in full control and avoids shared, rate-limited sessions.

1. Open **instagram.com** in Chrome/Edge and log in (use a secondary account if you prefer).
2. Press **F12** → open the **Application** tab (Chrome) or **Storage** tab (Firefox).
3. Expand **Cookies → https://www.instagram.com**.
4. Copy the **value** of the cookie named **`sessionid`**.
5. Paste it into the **Instagram sessionId** input field.

> 🔒 Your cookie is used only to authorize read requests during the run and is **never stored or logged**. Treat it like a password — rotate it if you share runs. Tip: using a residential proxy from the same region as the account reduces rate-limiting.

***

### 🆚 Why choose this Actor

| Feature | 🟣 This Actor | Typical IG follower scrapers |
|---|---|---|
| Followers **and** following | ✅ | ✅ |
| Multiple accounts per run | ✅ | Sometimes |
| Auto-pagination to your limit | ✅ | ✅ |
| Verified / private flags | ✅ | Partial |
| Clean `profile_url` per row | ✅ | ❌ |
| Bring-your-own session (full control) | ✅ | ❌ (shared sessions) |
| Residential-proxy support | ✅ | Varies |
| Transparent about IG's session requirement | ✅ | ❌ (vague "no cookies" claims) |
| One-click CSV / JSON / Excel / API export | ✅ | ✅ |
| Honest limitations & step-by-step setup | ✅ | Rare |

***

### 🔗 Integrations & automation

- **Google Sheets** — schedule a run and push results straight into a sheet.
- **Make / Zapier / n8n** — trigger on new dataset items and fan out to your CRM, Slack, or email.
- **Apify API** — fetch the dataset programmatically in any language:

```bash
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&clean=true&token=<YOUR_TOKEN>"
```

***

### ❓ FAQ

**Is this Instagram follower scraper free?**
There's an accessible tier so you can test with real data before scaling. You only pay for the rows you export — see the Pricing tab.

**Do I need an Instagram login or API key?**
No API key. No app install. To export full follower/following lists you should supply your own `sessionId` cookie (1-minute setup above), because Instagram serves these lists only to authenticated sessions.

**Can it scrape private accounts?**
No. Private accounts only expose their lists to approved followers. This Actor scrapes **public** profiles. If the source account is private, you'll need an authorized session that already follows it.

**How many followers can I export?**
Up to **500,000 per account** per run. For very large accounts, split into multiple runs and use a residential proxy to stay within Instagram's rate limits.

**Why should I use a residential proxy?**
Instagram aggressively blocks datacenter IP ranges. Residential proxies look like real users and dramatically improve success rates and volume.

**What formats can I export?**
JSON, CSV, Excel (XLSX), XML, HTML, or via the Apify API/RSS — one click each.

**Can I scrape followers of multiple accounts at once?**
Yes. Add as many usernames as you like to the **Account** field; each gets its own labeled rows via `username_scrape`.

**Is web scraping Instagram legal?**
Scraping **publicly available** data is generally permitted in many jurisdictions, but you are responsible for complying with Instagram's Terms, the GDPR/CCPA, and applicable laws. Use the data ethically and avoid spam.

**Why did I get fewer results than the follower count?**
Instagram paginates and occasionally rate-limits. Re-run with a residential proxy, a fresh `sessionId`, and a smaller per-account limit for the most complete export.

***

### ⚠️ Limitations (so you know exactly what to expect)

- **Public profiles only.** Private accounts can't be exported without an authorized session that follows them.
- **Full lists need a `sessionId`.** Without one, the Actor resolves the profile and reports counts but cannot page through the audience — this is an Instagram restriction, not an Actor bug.
- **Datacenter IPs get blocked** by Instagram; use a **residential proxy** for reliable, high-volume runs.
- Result counts can vary with Instagram availability, pagination, rate-limiting, and your run budget.

***

### 🛠️ Best practices

- Start with a small `resultsLimit` to validate output, then scale.
- Use a **residential proxy** in the same region as a fresh `sessionId`.
- Split very large accounts across several runs.
- Export as CSV for spreadsheets, JSON for code/automation.

***

### 📨 Support & feedback

Found a bug or want a new field (e.g. follower count, bio, external URL)? Open an issue on the Actor page — requests are reviewed quickly. If it helped you, a short ⭐ review on Apify goes a long way and helps other users find it.

Happy scraping! 🚀

# Actor input Schema

## `Account` (type: `array`):

Instagram usernames or profile URLs to scrape. One per line. Example: mrbeast, https://instagram.com/nasa

## `dataToScrape` (type: `string`):

Choose to export the account's Followers or the accounts it is Following.

## `resultsLimit` (type: `integer`):

Maximum number of follower/following profiles to export per account (25–500000). Start small to validate output.

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

Your Instagram `sessionid` cookie value. Required to export full follower/following lists (Instagram blocks these endpoints for logged-out requests). It is used only to sign read requests during this run and is never stored. See the README → 'How to get your sessionId'.

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

Proxy used for all requests. Residential proxies are strongly recommended for Instagram — datacenter IPs are frequently blocked.

## Actor input object example

```json
{
  "Account": [
    "mrbeast"
  ],
  "dataToScrape": "Followers",
  "resultsLimit": 500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "Account": [
        "mrbeast"
    ],
    "resultsLimit": 500,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("convertfleetdotonline/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 = {
    "Account": ["mrbeast"],
    "resultsLimit": 500,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("convertfleetdotonline/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 '{
  "Account": [
    "mrbeast"
  ],
  "resultsLimit": 500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call convertfleetdotonline/instagram-followers-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Followers & Following Scraper (CSV/JSON, No Login)",
        "description": "Export Instagram followers or following lists from public profiles to JSON, CSV or Excel. Username, full name, user ID, profile picture, verified & private flags. Multiple accounts per run, auto-pagination, residential-proxy ready.",
        "version": "0.1",
        "x-build-id": "SfDtzZe4jVAZUg5t1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/convertfleetdotonline~instagram-followers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-convertfleetdotonline-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/convertfleetdotonline~instagram-followers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-convertfleetdotonline-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/convertfleetdotonline~instagram-followers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-convertfleetdotonline-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": [
                    "Account",
                    "dataToScrape",
                    "resultsLimit"
                ],
                "properties": {
                    "Account": {
                        "title": "Instagram accounts",
                        "type": "array",
                        "description": "Instagram usernames or profile URLs to scrape. One per line. Example: mrbeast, https://instagram.com/nasa",
                        "default": [
                            "mrbeast"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "dataToScrape": {
                        "title": "What to scrape from each account",
                        "enum": [
                            "Followers",
                            "Following"
                        ],
                        "type": "string",
                        "description": "Choose to export the account's Followers or the accounts it is Following.",
                        "default": "Followers"
                    },
                    "resultsLimit": {
                        "title": "Max results per account",
                        "minimum": 1,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Maximum number of follower/following profiles to export per account (25–500000). Start small to validate output.",
                        "default": 500
                    },
                    "sessionId": {
                        "title": "Instagram sessionId (recommended)",
                        "type": "string",
                        "description": "Your Instagram `sessionid` cookie value. Required to export full follower/following lists (Instagram blocks these endpoints for logged-out requests). It is used only to sign read requests during this run and is never stored. See the README → 'How to get your sessionId'."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used for all requests. Residential proxies are strongly recommended for Instagram — datacenter IPs are frequently blocked.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```