# \[NEW] Instagram Users Scraper Lowcost (0.20$/1K 🤑) (`sones/instagram-user-scraper-lowcost`) Actor

Cost-optimized Instagram profile scraper. Extract user info, follower counts, verification status, and bios without authentication. HTTP-only (no browser), 10x cheaper than alternatives. Supports batch scraping with residential proxies and smart rate limiting.

- **URL**: https://apify.com/sones/instagram-user-scraper-lowcost.md
- **Developed by:** [Samy](https://apify.com/sones) (community)
- **Categories:** Social media, Lead generation, Other
- **Stats:** 10 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.20 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 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 User Scraper (Low-Cost)

Fast and affordable Instagram scraper for extracting user profile information from public profiles. **No Instagram account required** - accesses public data only.

### What does Instagram User Scraper do?

Instagram User Scraper extracts profile information from public Instagram accounts using Instagram's public APIs. It retrieves username, biography, follower count, media count, verification status, and profile pictures without requiring any Instagram authentication.

**Key features:**

- **Scrape public profiles** - Extract user information with all metadata
- **No session needed** - Works without Instagram login or cookies
- **Cost-optimized** - Significantly more affordable than browser-based scrapers
- **Smart rate limiting** - Built-in delays and retry logic to avoid blocks
- **Residential proxies** - Integrated Apify Proxy support

### Why scrape Instagram user profiles?

Instagram profile data extraction enables powerful business insights and automation:

- **Influencer research** - Discover creators with high engagement for partnerships
- **Competitor analysis** - Track follower growth and account verification status
- **Lead generation** - Build lists of potential customers or partners
- **Market research** - Analyze account types and categories in your industry
- **Brand monitoring** - Track verification status and profile changes
- **Audience building** - Find relevant accounts to engage with

### How to scrape Instagram profiles

1. **[Create a free Apify account](https://console.apify.com/sign-up)**
2. **Open the Actor** in [Apify Console](https://console.apify.com/actors)
3. **Add Instagram usernames** - Enter one or more usernames (without @)
4. **Click "Start"** and wait for the scraper to finish
5. **Download your data** - Export as JSON, CSV, Excel, or HTML

### How much does it cost to scrape Instagram?

This scraper is designed to be highly cost-efficient by using HTTP requests instead of browser automation. The actual cost depends on:

- **Number of profiles** you scrape
- **Proxy type** (residential vs datacenter)
- **Apify plan** you're subscribed to

**Key cost advantages:**

- **No browser overhead** - HTTP-only requests use minimal compute units
- **Efficient memory usage** - 512MB footprint (vs 4-8GB for browser scrapers)
- **Single request per profile** - No pagination overhead
- **Smart proxy usage** - Session pooling reduces proxy costs

With the **Apify Free plan**, you can scrape a significant number of Instagram profiles every month at no cost. For high-volume extraction, paid plans offer better value.

### Input

```json
{
    "usernames": ["natgeo", "nike", "cristiano"],
    "maxConcurrentProfiles": 3,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    },
    "delayBetweenProfiles": 1000,
    "maxRetries": 5
}
````

#### Input parameters

| Field                   | Type    | Required | Description                                                              |
| ----------------------- | ------- | -------- | ------------------------------------------------------------------------ |
| `usernames`             | Array   | **Yes**  | Instagram usernames to scrape (without @). Example: `["natgeo", "nike"]` |
| `maxConcurrentProfiles` | Integer | No       | How many profiles to scrape in parallel (1-50). Default: `3`             |
| `proxy`                 | Object  | No       | Apify Proxy configuration. Default: Residential proxies enabled          |
| `delayBetweenProfiles`  | Integer | No       | Delay in milliseconds between profile batches. Default: `1000`           |
| `maxRetries`            | Integer | No       | Maximum retry attempts for failed requests. Default: `5`                 |

**Note:** Check the [Input tab](https://console.apify.com/actors/~/input-schema) for the complete list of input fields with descriptions.

### Output

The scraper saves all extracted data to the **Apify dataset** in structured JSON format. Each profile includes:

#### Profile data

- **Identifiers**: `pk`, `username`
- **Profile info**: `full_name`, `biography`, `profile_pic_url`
- **Verification**: `is_verified`, `is_private`, `account_type`
- **Statistics**: `follower_count`, `following_count`, `media_count`
- **Additional**: `external_url`, `category_name`

#### Output example

```json
{
    "pk": "25025320",
    "username": "natgeo",
    "full_name": "National Geographic",
    "biography": "Experience the world through the eyes of National Geographic photographers.",
    "profile_pic_url": "https://scontent.cdninstagram.com/...",
    "is_verified": true,
    "is_private": false,
    "account_type": 1,
    "follower_count": 283000000,
    "following_count": 214,
    "media_count": 28543,
    "external_url": "https://www.nationalgeographic.com",
    "category_name": "Media/News Company",
    "scraped_username": "natgeo",
    "scraped_at": 1704067200,
    "profile_url": "https://www.instagram.com/natgeo/",
    "success": true
}
```

#### Export formats

Download your data in multiple formats:

- **JSON** - Structured data for APIs and databases
- **CSV** - For Excel and data analysis tools
- **Excel** - Ready-to-use spreadsheets
- **HTML** - Human-readable tables
- **XML** - Legacy system integration

### Is it legal to scrape Instagram?

**Yes, when done ethically.** This scraper only accesses **publicly available data** that Instagram exposes for SEO, link previews, and website embeds. It does not:

- ❌ Extract private user data (emails, phone numbers, private posts)
- ❌ Bypass login walls or authentication
- ❌ Access content from private accounts
- ❌ Store personal data unnecessarily

**However, you should:**

- ✅ Review Instagram's Terms of Service
- ✅ Respect rate limits and implement delays
- ✅ Comply with GDPR if scraping EU users
- ✅ Have a legitimate purpose for data collection
- ✅ Not use data for spam, harassment, or unauthorized contact

Our scrapers are ethical and only extract what users have chosen to share publicly. If you're unsure about your use case, consult legal counsel.

**Learn more:** [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/) (Apify Blog)

### Using Instagram User Scraper with the Apify API

The Apify API gives you programmatic access to the Apify platform. Run any Actor, manage runs, access datasets, and more from your applications.

**Run the Actor via API:**

```bash
curl -X POST https://api.apify.com/v2/acts/YOUR_USERNAME~instagram-user-scraper-lowcost/runs \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "usernames": ["natgeo", "nike"]
  }'
```

**Fetch results:**

```bash
curl https://api.apify.com/v2/datasets/YOUR_DATASET_ID/items \
  -H "Authorization: Bearer YOUR_API_TOKEN"
```

#### Client libraries

- **Node.js**: [`apify-client`](https://www.npmjs.com/package/apify-client) NPM package
- **Python**: [`apify-client`](https://pypi.org/project/apify-client/) PyPI package

**Example (Node.js):**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('YOUR_USERNAME/instagram-user-scraper-lowcost').call({
    usernames: ['natgeo', 'nike'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Resources:**

- [Apify API Reference](https://docs.apify.com/api/v2)
- [API Client Documentation](https://docs.apify.com/api/client)

### Integrations

Connect Instagram User Scraper to your favorite tools:

- **[Make (Integromat)](https://www.make.com/en/integrations/apify)** - No-code automation workflows
- **[Zapier](https://zapier.com/apps/apify/integrations)** - Connect to 5,000+ apps
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** - Get notified when runs finish
- **[Slack](https://apify.com/apify/slack-integration)** - Send scraped data to Slack channels
- **[Google Sheets](https://apify.com/lukaskrivka/google-sheets)** - Export directly to spreadsheets
- **[Airbyte](https://airbyte.com/connectors/apify)** - Data pipeline integration
- **[Keboola](https://www.keboola.com/integrations/apify)** - ETL and data warehousing

**Learn more:** [Apify Integrations Documentation](https://docs.apify.com/platform/integrations)

### Advanced configuration

#### Proxy settings

For best results, use **residential proxies** (default):

```json
{
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

**Datacenter proxies** (cheaper but higher block rate):

```json
{
    "proxy": {
        "apifyProxyGroups": ["SHADER"]
    }
}
```

**Custom proxies:**

```json
{
    "proxy": {
        "useApifyProxy": false,
        "proxyUrls": ["http://proxy1.com:8080", "http://proxy2.com:8080"]
    }
}
```

#### Rate limiting

Adjust delays to balance speed vs reliability:

```json
{
    "delayBetweenProfiles": 2000,
    "maxRetries": 5
}
```

- **Lower delays** = Faster scraping, higher block risk
- **Higher delays** = Slower but more reliable

#### Concurrency

Control parallel processing:

```json
{
    "maxConcurrentProfiles": 5
}
```

- **1-3**: Conservative (recommended for stability)
- **4-7**: Moderate (good balance)
- **8-10**: Aggressive (faster but may trigger rate limits)

### FAQ

#### Does this scraper require an Instagram account?

**No.** This scraper accesses Instagram's public APIs that don't require authentication. It works without any Instagram login or session cookies.

#### Can I scrape private accounts?

**No.** Private Instagram profiles are not accessible without authentication. The scraper will return an error for private accounts.

#### What if I get rate limited?

Increase the `delayBetweenProfiles` parameter. Use **residential proxies** (not datacenter) for better reliability.

#### Can I scrape posts from these profiles?

**No.** This Actor focuses on **profile information only**. For post scraping, check out the companion Actor: **Instagram Posts Scraper**.

#### What data format is supported?

Data is saved to Apify **datasets** and can be exported as:

- JSON (for APIs)
- CSV (for Excel/analysis)
- Excel (.xlsx)
- HTML (readable tables)
- XML (legacy systems)

#### Can I schedule recurring scraping?

**Yes!** Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run the scraper automatically (hourly, daily, weekly, etc.).

#### The scraper failed. What do I do?

1. Check the **log** for error messages
2. Verify usernames are correct and profiles are **public**
3. Increase delays if you see rate limit errors
4. Try using **residential proxies** instead of datacenter
5. If the issue persists, contact support

### You might also like

- **[Instagram Posts Scraper](https://apify.com/apify/instagram-scraper)** - Scrape posts from profiles
- **[Instagram Profile Scraper](https://apify.com/apify/instagram-profile-scraper)** - Official Apify Instagram scraper
- **[Instagram Hashtag Scraper](https://apify.com/apify/instagram-hashtag-scraper)** - Scrape posts by hashtag
- **[Twitter Scraper](https://apify.com/apify/twitter-scraper)** - Extract tweets and profiles
- **[TikTok Scraper](https://apify.com/clockworks/tiktok-scraper)** - Scrape TikTok videos and profiles

***

**Need help?** Contact [Apify Support](https://apify.com/contact) or check the [Apify Documentation](https://docs.apify.com).

# Actor input Schema

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

List of Instagram usernames to scrape (without @). Example: natgeo, nike, instagram

## `proxy` (type: `object`):

Apify proxy configuration to avoid blocking

## `delayBetweenProfiles` (type: `integer`):

Delay between each batch of parallel profiles

## `maxRetries` (type: `integer`):

Number of retry attempts on request failure

## Actor input object example

```json
{
  "usernames": [
    "natgeo",
    "nike",
    "cristiano"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "delayBetweenProfiles": 300,
  "maxRetries": 3
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "usernames": [
        "instagram"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("sones/instagram-user-scraper-lowcost").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": ["instagram"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("sones/instagram-user-scraper-lowcost").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": [
    "instagram"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call sones/instagram-user-scraper-lowcost --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "[NEW] Instagram Users Scraper Lowcost (0.20$/1K 🤑)",
        "description": "Cost-optimized Instagram profile scraper. Extract user info, follower counts, verification status, and bios without authentication. HTTP-only (no browser), 10x cheaper than alternatives. Supports batch scraping with residential proxies and smart rate limiting.",
        "version": "1.1",
        "x-build-id": "q4dTeMYJudSiGtQC0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sones~instagram-user-scraper-lowcost/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sones-instagram-user-scraper-lowcost",
                "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/sones~instagram-user-scraper-lowcost/runs": {
            "post": {
                "operationId": "runs-sync-sones-instagram-user-scraper-lowcost",
                "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/sones~instagram-user-scraper-lowcost/run-sync": {
            "post": {
                "operationId": "run-sync-sones-instagram-user-scraper-lowcost",
                "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": "Instagram Usernames",
                        "type": "array",
                        "description": "List of Instagram usernames to scrape (without @). Example: natgeo, nike, instagram",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy configuration to avoid blocking"
                    },
                    "delayBetweenProfiles": {
                        "title": "Delay between profile batches (ms)",
                        "minimum": 200,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Delay between each batch of parallel profiles",
                        "default": 300
                    },
                    "maxRetries": {
                        "title": "Max retry attempts",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts on request failure",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
