# Instagram Tagged Posts Scraper (`scrapesmith/instagram-tagged-posts-scraper`) Actor

Scrape Instagram tagged posts, profile posts, and Reels. Get captions, likes, comments, play counts, video duration, music info, location, tagged users, carousel media. Session rotation with auto-failover. 40+ fields. JSON/CSV/Excel. API ready.

- **URL**: https://apify.com/scrapesmith/instagram-tagged-posts-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (community)
- **Categories:** Social media, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 85.7% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.45 / 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Tagged Posts Scraper

Scrape every post where a specific Instagram account has been photo-tagged. Enter one or more usernames and get structured data for every tagged post — captions, hashtags, likes, comments, play counts, media URLs, tagged users, location, music info, and more.

No login required from your side. Just add usernames and run.

### 🔍 What does Instagram Tagged Posts Scraper do?

When someone tags an Instagram account in a photo or video, that post appears in the tagged section of the profile. This scraper collects all those tagged posts for any public account and returns clean, structured data ready for analysis.

**Use it to:**

- 📢 **Track brand mentions** — see every post where your brand, product, or logo was tagged by customers, influencers, or partners
- 🤝 **Monitor influencer collaborations** — verify tagged posts from paid partnerships and sponsorships
- 🔎 **Competitive intelligence** — discover which creators are tagging competitor brands and how often
- 📸 **UGC collection** — find user-generated content featuring your brand for marketing campaigns
- 📰 **PR and media monitoring** — track when media outlets, journalists, or event accounts tag your company
- ⭐ **Athlete and celebrity tracking** — collect every fan post, press photo, or event where a public figure was tagged
- 📊 **Campaign measurement** — count and analyze tagged posts from a hashtag campaign or product launch

### ⚡ Why use this scraper?

- 💰 **Cheapest on the platform** — under $0.01 per 1,000 results. No residential proxy cost.
- 📋 **30+ fields per post** — more data points than any alternative, all flat and ready to use
- 🚀 **Fast parallel processing** — all profiles scraped simultaneously, 10 profiles in under 20 seconds
- 🔄 **Flexible input** — accepts usernames, @handles, and full Instagram URLs in the same run
- ✅ **Zero setup** — no cookies, no credentials, no API keys needed from you
- 🛡️ **Reliable** — 99% resolution rate across 100 verified celebrity accounts in stress testing
- 🔁 **Automatic failover** — multi-session rotation with dead session detection and reporting

### 💰 How much does it cost?

The scraper runs on Apify's pay-per-result model. You pay only for the results you get — no wasted compute on failed requests.

| Volume | Approximate cost |
|--------|-----------------|
| 25 results | 🆓 **Free** (every run) |
| 1,000 results | ~$0.01 |
| 10,000 results | ~$0.10 |
| 100,000 results | ~$1.00 |

Platform usage fees (compute time) are separate and typically add less than $0.002 per 1,000 results. The scraper uses free datacenter proxy with automatic residential failover — no proxy cost in normal operation.

### 📥 Input

The scraper accepts Instagram usernames in any format — mix all three freely in a single run:

- Bare username: `nike`
- With @ prefix: `@adidas`
- Full URL: `https://www.instagram.com/cristiano/`

#### Input parameters

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| **usernames** | Array of strings | Yes | Instagram usernames, @handles, or profile URLs |
| maxItems | Integer | No | Maximum total tagged posts across all profiles. Leave empty for no limit. |
| resultsPerProfile | Integer | No | Maximum tagged posts per individual profile. Leave empty for all available. |

#### Example input

```json
{
    "usernames": [
        "nike",
        "@adidas",
        "https://www.instagram.com/leomessi/"
    ],
    "resultsPerProfile": 50,
    "maxItems": 500
}
````

#### Minimal input

```json
{
    "usernames": ["nike"]
}
```

### 📤 Output

Each tagged post is returned as a flat JSON object with 30+ fields. No nested blobs to parse — every field is ready to use in spreadsheets, databases, or downstream pipelines.

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| id | String | Unique post ID |
| shortCode | String | Instagram short code (used in post URLs) |
| url | String | Direct link to the post |
| mediaType | String | `Image`, `Video`, `Reel`, or `Carousel` |
| productType | String | `feed`, `clips` (Reels), or `igtv` |
| caption | String | Full caption text |
| hashtags | Array | Extracted #hashtags from caption |
| mentions | Array | Extracted @mentions from caption |
| likesCount | Integer | Number of likes |
| commentsCount | Integer | Number of comments |
| playCount | Integer | Video/Reel play count |
| videoViewCount | Integer | Video view count |
| videoDuration | Float | Video duration in seconds |
| timestamp | String | Post creation time (ISO 8601) |
| ownerUsername | String | Username of the person who posted |
| ownerFullName | String | Display name of the poster |
| ownerId | String | Poster's Instagram user ID |
| ownerIsVerified | Boolean | Whether the poster has a verified badge |
| ownerProfilePicUrl | String | Poster's profile picture URL |
| taggedUsername | String | The account that was tagged (your input username) |
| taggedUsers | Array | All users tagged in this post — username, ID, full name, verification status, profile pic |
| displayUrl | String | Highest resolution image URL |
| videoUrl | String | Highest resolution video URL (for videos and Reels) |
| carouselMedia | Array | All images and videos in carousel posts with individual URLs |
| carouselMediaCount | Integer | Number of items in a carousel post |
| width | Integer | Original media width in pixels |
| height | Integer | Original media height in pixels |
| location | Object | Location name, slug, latitude, and longitude |
| isPaidPartnership | Boolean | Whether the post is a paid partnership |
| isSponsored | Boolean | Whether the post is sponsored content |
| coauthorProducers | Array | Collaboration and co-author accounts |
| musicInfo | Object | Song name, artist name, and audio ID (for Reels) |
| scrapedAt | String | Timestamp when this data was collected (ISO 8601) |

#### Example output

```json
{
    "id": "3456789012345678901",
    "shortCode": "CrYolT-xkI5",
    "url": "https://www.instagram.com/p/CrYolT-xkI5/",
    "mediaType": "Reel",
    "productType": "clips",
    "caption": "Game day ready! @nike #JustDoIt #Basketball",
    "hashtags": ["JustDoIt", "Basketball"],
    "mentions": ["nike"],
    "likesCount": 45231,
    "commentsCount": 892,
    "playCount": 15249537,
    "videoViewCount": 15249537,
    "videoDuration": 59.93,
    "timestamp": "2026-07-15T14:30:00.000Z",
    "ownerUsername": "athlete_example",
    "ownerFullName": "Pro Athlete",
    "ownerId": "1234567890",
    "ownerIsVerified": true,
    "ownerProfilePicUrl": "https://scontent-...",
    "taggedUsername": "nike",
    "taggedUsers": [
        {
            "username": "nike",
            "id": "13460080",
            "fullName": "Nike",
            "isVerified": true,
            "profilePicUrl": "https://..."
        }
    ],
    "displayUrl": "https://scontent-...",
    "videoUrl": "https://scontent-...",
    "carouselMedia": [],
    "carouselMediaCount": 0,
    "width": 1080,
    "height": 1920,
    "location": {
        "id": "12345",
        "name": "Madison Square Garden",
        "slug": "madison-square-garden",
        "lat": 40.7505,
        "lng": -73.9934
    },
    "isPaidPartnership": true,
    "isSponsored": true,
    "coauthorProducers": [],
    "musicInfo": {
        "artistName": "Nike",
        "songName": "Original Audio",
        "audioId": "987654321"
    },
    "scrapedAt": "2026-07-22T10:00:00.000Z"
}
```

### 🏎️ Performance and reliability

| Metric | Value |
|--------|-------|
| Speed | ~600 posts/minute |
| Profiles per run | Unlimited (all scraped in parallel) |
| Memory usage | 100–120 MB |
| Resolution success | 99% on public accounts |
| Consecutive run stability | 10/10 runs successful in stress testing |
| Output formats | JSON, CSV, Excel, XML, RSS |

The scraper resolves all usernames in parallel and then scrapes all profiles simultaneously. A typical run with 10 profiles completes in 15–25 seconds.

### 💡 Tips and advanced usage

#### Flexible username input

You can paste any format — the scraper normalizes everything automatically:

```json
{
    "usernames": [
        "nike",
        "@cristiano",
        "https://www.instagram.com/leomessi/",
        "https://instagram.com/therock?hl=en"
    ]
}
```

#### Get only the latest tagged posts

Set `resultsPerProfile` to a small number for the most recent posts only:

```json
{
    "usernames": ["nike", "adidas", "puma", "reebok", "newbalance"],
    "resultsPerProfile": 10
}
```

#### 📅 Monitor brand mentions on a schedule

Use the [Apify scheduling feature](https://docs.apify.com/platform/schedules) to run this scraper daily or weekly. Each run collects the latest tagged posts. Combine with webhooks to trigger alerts when new tags appear.

#### 📊 Export to Google Sheets automatically

Connect this scraper to Google Sheets using the [Apify Google Sheets integration](https://docs.apify.com/platform/integrations/google-sheets). New tagged posts are appended to your spreadsheet after every run.

#### 🔗 Use with Make, Zapier, or n8n

Trigger downstream workflows whenever new tagged posts are found. Connect via [webhooks](https://docs.apify.com/platform/integrations/webhooks) or through the [Apify integrations page](https://docs.apify.com/platform/integrations).

#### 🧑‍💻 Call from your code

Use the [Apify API](https://docs.apify.com/api/v2) or official client libraries (Python, JavaScript, PHP) to run the scraper programmatically and retrieve results:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("scrapesmith/instagram-tagged-posts-scraper").call(
    run_input={
        "usernames": ["nike", "adidas"],
        "resultsPerProfile": 50
    }
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["ownerUsername"], item["likesCount"], item["url"])
```

#### 🤖 Connect to AI agents via MCP

This scraper is available as an MCP tool for Claude, ChatGPT, and other AI agents. Use it to feed real-time Instagram data into your AI workflows.

### ❓ Frequently asked questions

#### Can I scrape tagged posts from private accounts?

No. This scraper only works with public Instagram accounts. If an account is set to private, their tagged posts are not accessible through the API.

#### Why did a username return 0 results?

There are three possible reasons:

1. The account has tagged posts disabled in their privacy settings
2. The account genuinely has no tagged posts
3. A very small number of celebrity accounts (like Justin Bieber) restrict search visibility — these accounts cannot be resolved

#### Is there a limit on how many tagged posts I can get?

There is no artificial limit on paid plans. The scraper paginates through all available tagged posts. Some accounts with millions of followers may have tens of thousands of tagged posts — use `resultsPerProfile` to cap output per account if needed.

#### How fresh is the data?

The scraper fetches live data directly from Instagram on every run. There is no caching. You always get the current state of tagged posts at the time of the run.

#### What's the difference between tagged posts and mentions?

- **Tagged posts** — posts where someone tagged the account in a photo or video. These appear in the "Tagged" tab on the profile page. This is what this scraper collects.
- **Text mentions** — @username references in captions or comments. These are NOT the same as photo tags. However, each tagged post's full caption is included in the output, so you can search for text @mentions within the results.

#### Do I need to provide Instagram cookies or credentials?

No. The scraper handles authentication internally. You never need to provide login credentials, cookies, or API keys.

### 🔗 Related scrapers

Looking for other Instagram data? Check out these scrapers from our collection:

- [Instagram Comments Scraper](https://apify.com/scrapesmith/instagram-comments-scraper) — Extract all comments from any Instagram post or Reel
- [Instagram Hashtag Scraper](https://apify.com/scrapesmith/instagram-hashtag-scraper) — Scrape posts by hashtag with full engagement data
- [Instagram Post Scraper](https://apify.com/scrapesmith/instagram-post-scraper) — Get complete details for any Instagram post, Reel, or carousel
- [Instagram Profile Scraper](https://apify.com/scrapesmith/instagram-profile-scraper) — Scrape Instagram profile data, bio, follower counts, and stats
- [Instagram Followers Scraper](https://apify.com/scrapesmith/instagram-followers-following-scraper) — Get followers and following lists for any public account
- [Instagram Search Scraper](https://apify.com/scrapesmith/instagram-search-scraper) — Search Instagram for users, hashtags, and places by keyword

#### Other social media scrapers

- [TikTok Scraper](https://apify.com/scrapesmith/tiktok-posts-scraper) — Scrape TikTok posts, profiles, comments, and search results
- [TikTok Profile Scraper](https://apify.com/scrapesmith/tiktok-profile-scraper) — Get TikTok user profiles and stats
- [Facebook Posts Scraper](https://apify.com/scrapesmith/free-facebook-post-scraper) — Extract posts from Facebook pages
- [Facebook Ad Library Scraper](https://apify.com/scrapesmith/facebook-ad-library-scraper) — Scrape Facebook and Instagram ad transparency data
- [Twitter/X Scraper](https://apify.com/scrapesmith/twitter-x-scraper-tweets-profiles-replies) — Scrape tweets, profiles, and replies from X
- [YouTube Scraper](https://apify.com/scrapesmith/youtube-scraper) — Extract YouTube video data, channels, and transcripts
- [Reddit Scraper](https://apify.com/scrapesmith/reddit-scraper) — Scrape Reddit posts, comments, and subreddit data
- [LinkedIn Jobs Scraper](https://apify.com/scrapesmith/linkedin-jobs-scraper) — Scrape job listings from LinkedIn

# Actor input Schema

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

Instagram usernames, @handles, or profile URLs. Mix freely. Example: nike, @adidas, https://instagram.com/cristiano

## `resultsPerProfile` (type: `integer`):

Maximum tagged posts per profile. Leave empty to scrape all available.

## Actor input object example

```json
{
  "usernames": [
    "nike"
  ]
}
```

# 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": [
        "nike"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/instagram-tagged-posts-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 = { "usernames": ["nike"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Tagged Posts Scraper",
        "description": "Scrape Instagram tagged posts, profile posts, and Reels. Get captions, likes, comments, play counts, video duration, music info, location, tagged users, carousel media. Session rotation with auto-failover. 40+ fields. JSON/CSV/Excel. API ready.",
        "version": "0.0",
        "x-build-id": "GtqeYblRI16zDQQr3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~instagram-tagged-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-instagram-tagged-posts-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/scrapesmith~instagram-tagged-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-instagram-tagged-posts-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/scrapesmith~instagram-tagged-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-instagram-tagged-posts-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": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Instagram Usernames",
                        "type": "array",
                        "description": "Instagram usernames, @handles, or profile URLs. Mix freely. Example: nike, @adidas, https://instagram.com/cristiano",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsPerProfile": {
                        "title": "Results Per Profile",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum tagged posts per profile. Leave empty to scrape all available."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
