# Instagram Profile Scraper – Followers, Bio, Posts, Verified (`scrapepilot/instagram-profile-scraper-followers-bio-posts-verified`) Actor

Scrape Instagram profile data from any username list. Get followers, following, post count, bio, verified status, business flag, profile picture, and external URL. Bulk-ready with checkpoint resume. No login. $7.99/month.

- **URL**: https://apify.com/scrapepilot/instagram-profile-scraper-followers-bio-posts-verified.md
- **Developed by:** [Scrape Pilot](https://apify.com/scrapepilot) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$7.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 Profile Scraper — Followers, Bio & Account Data Extractor

> **The most reliable Instagram Profile Scraper on Apify.** Extract complete Instagram account data from any list of usernames — followers, following, post count, bio, verified status, business account flag, profile picture, and external URL. Bulk-ready with abort-safe checkpoint resume. Residential proxy ready. No login required. Instant structured output.



### 📌 Table of Contents

- [What Is This Actor?](#what-is-this-actor)
- [Why Use This Instagram Profile Scraper?](#why-use-this-instagram-profile-scraper)
- [Use Cases](#use-cases)
- [Input Parameters](#input-parameters)
- [Output Fields](#output-fields)
- [Example Input & Output](#example-input--output)
- [Pricing & Free Trial](#pricing--free-trial)
- [Performance & Limits](#performance--limits)
- [FAQ](#faq)
- [Changelog](#changelog)
- [Legal & Terms of Use](#legal--terms-of-use)

---

### 🔍 What Is This Actor?

**Instagram Profile Scraper** is a production-ready Apify actor that extracts complete public account data from any list of Instagram usernames — followers count, following count, post count, full name, bio, verified status, business account flag, profile picture URL, and external link.

Provide a list of Instagram usernames and receive back a clean, structured record for each account — ready for influencer research, competitor analysis, CRM enrichment, or social media datasets. This **Instagram data scraper** handles bulk username lists of any size with built-in retry logic, rate limit handling, and abort-safe checkpoint recovery — so no progress is lost even if the run is interrupted.

No login. No Instagram API credentials. No browser. Just fast, structured **Instagram followers scraper** output for any public account list.

---

### 🚀 Why Use This Instagram Profile Scraper?

| Feature | This Actor | Manual Research | Instagram API | Other Scrapers |
|---|---|---|---|---|
| **Bulk username scraping** | ✅ Any size | ❌ Slow | ⚠️ Quota limited | ⚠️ |
| **Followers & following count** | ✅ | ✅ Slow | ✅ | ⚠️ |
| **Bio & full name** | ✅ | ✅ | ✅ | ⚠️ |
| **Verified status** | ✅ | ✅ | ✅ | ⚠️ |
| **Business account flag** | ✅ | ✅ | ⚠️ | ❌ |
| **Profile picture URL** | ✅ HD | ✅ | ⚠️ | ⚠️ |
| **External URL** | ✅ | ✅ | ⚠️ | ❌ |
| **Abort-safe checkpoint resume** | ✅ | N/A | N/A | ❌ |
| **Auto rate-limit handling** | ✅ Built-in | N/A | N/A | ❌ |
| **No login or API key** | ✅ | ✅ | ❌ Required | ✅ |

> **Bottom line:** This **Instagram profile scraper** is the only actor that combines bulk username processing, business account detection, abort-safe checkpoint recovery, and automatic rate-limit retry — in a single run with no credentials needed.

---

### 🎯 Use Cases

#### 📊 Influencer Research & Discovery
- Scrape **Instagram followers** counts and engagement data for influencer shortlists at scale
- Filter verified accounts and business accounts from a list of potential influencer partners
- Extract bio and external URL for quick profile qualification without manual browsing

#### 🏢 Competitor & Brand Monitoring
- Monitor follower growth on competitor Instagram accounts by scheduling regular scraper runs
- Track whether key accounts in your industry are verified or running as business profiles
- Collect bio and external URL data to identify brand messaging and website traffic sources

#### 🤖 AI & Social Media Datasets
- Build labeled datasets of Instagram account metadata for machine learning research
- Collect follower/following ratios at scale for bot detection or audience quality analysis
- Extract bio text from thousands of accounts for NLP, topic modeling, or persona research

#### 🛠️ CRM & Sales Enrichment
- Enrich prospect or customer records with Instagram data — followers, bio, and business account status
- Validate Instagram handles in your database by checking whether accounts still exist and are public
- Build targeted outreach lists filtered by follower count range or verified status

#### 📈 Social Media Analytics & Reporting
- Aggregate Instagram account stats for industry benchmark reports
- Track follower counts across a portfolio of brand accounts over time with scheduled runs
- Compare post counts and follower-to-following ratios across accounts in any niche

#### 🎓 Academic & Media Research
- Build structured datasets of public Instagram account metadata for social media studies
- Study verification distribution and business account prevalence across industries
- Collect profile data at scale for research on personal branding and social media presence

---

### ⚙️ Input Parameters

```json
{
  "usernames": [
    "natgeo",
    "nasa",
    "nike",
    "@cristiano"
  ],
  "delayBetweenRequests": 1.5,
  "resumeFromCheckpoint": true,
  "proxyConfiguration": {
    "useApifyProxy":    true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `usernames` | array | `[]` | Instagram usernames to scrape — `@` prefix is optional and handled automatically |
| `delayBetweenRequests` | float | `1.5` | Seconds to wait between each profile request — increase to reduce rate-limit risk |
| `resumeFromCheckpoint` | boolean | `true` | When `true`, a restarted run skips already-processed usernames and resumes from the last saved position |
| `proxyConfiguration` | object | Residential | Apify proxy config — residential proxy strongly recommended for Instagram |

> **Tip:** The `@` prefix in usernames is automatically stripped — `"@natgeo"` and `"natgeo"` are treated identically. Mix both formats freely in the same list.

***

### 📋 Output Fields

Every successful record from this **Instagram data scraper** includes:

| Field | Type | Description | Example |
|---|---|---|---|
| `username` | string | Instagram username | `"natgeo"` |
| `full_name` | string | Account display name | `"National Geographic"` |
| `bio` | string | Profile biography text | `"Experience the world through the eyes of National Geographic photographers."` |
| `followers` | integer | Total follower count | `284000000` |
| `following` | integer | Total accounts followed | `185` |
| `posts` | integer | Total posts published | `29847` |
| `is_verified` | boolean | Blue verified badge status | `true` |
| `is_business` | boolean | Whether account is a business profile | `true` |
| `profile_pic` | string | High-resolution profile picture URL | `"https://instagram.fxxx.cdn/..."` |
| `external_url` | string | Link in bio (external website URL) | `"https://www.nationalgeographic.com"` |
| `status` | string | Extraction status | `"success"` |
| `scraped_at` | string | Extraction timestamp (ISO 8601 UTC) | `"2024-03-15T10:30:00Z"` |

#### ❌ Failed Account Records

When an account cannot be scraped (private, banned, deleted, or rate-limited), the actor still pushes a record so you can identify which usernames failed:

| Field | Description | Example |
|---|---|---|
| `username` | The username that failed | `"deleted_account"` |
| `status` | Always `"failed"` | `"failed"` |
| `error_code` | HTTP status or error type | `404`, `429`, `"NetworkError"` |
| `error_message` | Human-readable failure reason | `"Account may be private, banned, or rate-limited."` |
| `scraped_at` | Timestamp of the failed attempt | `"2024-03-15T10:30:00Z"` |

***

### 📦 Example Input & Output

**Input:**

```json
{
  "usernames": ["natgeo", "nasa"],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

**Output (success record):**

```json
{
  "username":    "natgeo",
  "full_name":   "National Geographic",
  "bio":         "Experience the world through the eyes of National Geographic photographers.",
  "followers":   284000000,
  "following":   185,
  "posts":       29847,
  "is_verified": true,
  "is_business": true,
  "profile_pic": "https://instagram.fxxx.cdn/.../profile_pic_hd.jpg",
  "external_url":"https://www.nationalgeographic.com",
  "status":      "success",
  "scraped_at":  "2024-03-15T10:30:00Z"
}
```

**Output (failed record):**

```json
{
  "username":      "private_account_xyz",
  "status":        "failed",
  "error_code":    401,
  "error_message": "Could not retrieve profile. Account may be private, banned, or rate-limited.",
  "scraped_at":    "2024-03-15T10:30:01Z"
}
```

***

### 💰 Pricing & Free Trial

| Plan | Price | Includes |
|---|---|---|
| **Free Trial** | $0 | 2 hours full access — no credit card required |
| **Monthly** | $7.99 / month | Unlimited runs, any username list size |

#### Everything included in every plan:

- ✅ Complete Instagram profile data — 10 fields per account
- ✅ Followers, following, post count, bio, verified and business flags
- ✅ HD profile picture URL and external link
- ✅ Failed account records — no missing usernames in output
- ✅ Abort-safe checkpoint resume — no data loss on interruption
- ✅ Auto rate-limit retry with backoff
- ✅ Configurable delay between requests
- ✅ JSON + CSV + Excel export from Apify dataset
- ✅ Scheduled runs for follower growth monitoring

> **Start your 2-hour free trial now** — no credit card needed. Click **Try for free** at the top of this page.

***

### ⚡ Performance & Limits

| Usernames | Estimated Time |
|---|---|
| 10 | ~20–40 seconds |
| 100 | ~3–5 minutes |
| 500 | ~15–25 minutes |
| 1,000 | ~30–50 minutes |

- Results pushed to the Apify dataset immediately after each username is processed
- Checkpoint saved after every username — restart resumes from the last saved position
- Up to 3 automatic retries per username on rate-limit or network errors
- Delay between requests is configurable — increase `delayBetweenRequests` for lower rate-limit risk on large batches
- US residential proxy strongly recommended for reliable Instagram access

***

### ❓ FAQ

**Q: Does this actor require an Instagram account or login?**
A: No. This **Instagram profile scraper** only accesses publicly visible profile data — no account, login, session cookie, or Instagram API key is required.

**Q: Can I scrape private Instagram accounts?**
A: No. Only publicly accessible profiles are supported. Private accounts return a `"failed"` record with `error_code: 401`.

**Q: What does the checkpoint/resume feature do?**
A: The actor saves its progress after every username. If the run is aborted or times out, simply restart it with the same input — usernames already successfully scraped are skipped, and the run continues from where it left off. Set `resumeFromCheckpoint: false` to force a fresh start.

**Q: Why does `is_business` matter for my use case?**
A: The `is_business` flag identifies accounts that have registered as Instagram Business profiles — useful for B2B prospecting, influencer qualification (distinguishing creators from personal accounts), and brand research.

**Q: What happens when an account is deleted or private?**
A: A `"failed"` record is pushed to the dataset with the username, error code, and a descriptive error message. This ensures you always know which usernames could not be scraped — with no silent gaps in your output.

**Q: How do I avoid getting rate-limited?**
A: Increase the `delayBetweenRequests` parameter to 2–3 seconds for large batches. Using a residential proxy is also strongly recommended — Instagram is much more aggressive at blocking datacenter IPs.

**Q: Can I monitor follower growth over time?**
A: Yes. Set up an Apify scheduled task with your username list to automatically collect follower counts at any interval — daily or weekly — and compare results across runs.

**Q: Can I export results to Excel or CSV?**
A: Yes. All results are pushed to the Apify dataset, which can be exported to JSON, CSV, Excel, and more directly from the Apify Console after each run.

***

### 📜 Changelog

#### v1.0.0 (Current)

- ✅ Full Instagram profile data: followers, following, posts, bio, full name
- ✅ Verified badge and business account flag per record
- ✅ HD profile picture URL and external link
- ✅ Failed account records — every username accounted for in output
- ✅ Abort-safe checkpoint resume — saves progress after every username
- ✅ Auto rate-limit retry with configurable backoff (up to 3 retries)
- ✅ Configurable delay between requests
- ✅ `@` prefix handling — stripped automatically from all usernames
- ✅ Residential proxy support
- ✅ Real-time dataset push as each username is processed

***

### 🏷️ Tags

`instagram profile scraper` `instagram data scraper` `instagram followers scraper` `instagram scraper` `instagram account data` `social media scraper` `instagram bulk scraper` `influencer data scraper` `instagram bio scraper` `instagram username scraper` `instagram follower count` `social media data`

***

### ⚖️ Legal & Terms of Use

This actor accesses publicly visible Instagram profile data in the same way a regular user views public profiles through a browser.

**Please note:**

- Use extracted **Instagram data** only for **lawful purposes** — influencer research, market analysis, CRM enrichment, and academic study are common legitimate uses
- Only public profile data is accessed — private accounts are not supported
- Do not use this **Instagram profile scraper** to harvest personal data for harassment, spam, or any purpose that violates individual privacy rights
- Comply with applicable data protection laws — including GDPR and CCPA — when storing or using extracted Instagram profile data
- The actor developer is not responsible for how extracted profile data is used

***

### 🤝 Support & Feedback

- **Bug report?** Contact us via the Apify actor page
- **Feature request?** Post in the Apify Community forum
- **Loving it?** Please leave a ⭐ review — it helps other users find this actor!

***

<p align="center">
  <strong>Built with ❤️ on Apify</strong><br/>
  <em>The most reliable Instagram Profile Scraper — followers, bio, verified status, bulk-ready</em><br/><br/>
  <strong>💰 $7.99/month · 🆓 2-hour free trial · No credit card required</strong>
</p>

# Actor input Schema

## `usernames` (type: `array`):

List of Instagram usernames to scrape (e.g. \['cristiano', 'leomessi']).

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

Residential proxies are highly recommended.

## Actor input object example

```json
{
  "usernames": [
    "cristiano"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "usernames": [
        "cristiano"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/instagram-profile-scraper-followers-bio-posts-verified").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 = { "usernames": ["cristiano"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/instagram-profile-scraper-followers-bio-posts-verified").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 '{
  "usernames": [
    "cristiano"
  ]
}' |
apify call scrapepilot/instagram-profile-scraper-followers-bio-posts-verified --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Profile Scraper – Followers, Bio, Posts, Verified",
        "description": "Scrape Instagram profile data from any username list. Get followers, following, post count, bio, verified status, business flag, profile picture, and external URL. Bulk-ready with checkpoint resume. No login. $7.99/month.",
        "version": "0.0",
        "x-build-id": "pj8i48eWbxJdffWWt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~instagram-profile-scraper-followers-bio-posts-verified/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-instagram-profile-scraper-followers-bio-posts-verified",
                "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/scrapepilot~instagram-profile-scraper-followers-bio-posts-verified/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-instagram-profile-scraper-followers-bio-posts-verified",
                "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/scrapepilot~instagram-profile-scraper-followers-bio-posts-verified/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-instagram-profile-scraper-followers-bio-posts-verified",
                "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": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Usernames",
                        "type": "array",
                        "description": "List of Instagram usernames to scrape (e.g. ['cristiano', 'leomessi']).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxies are highly recommended.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
