# Instagram Comments Scraper (`supreme_coder/instagram-comments-scraper`) Actor

Scrape comments from instagram posts including replies

- **URL**: https://apify.com/supreme\_coder/instagram-comments-scraper.md
- **Developed by:** [Supreme Coder](https://apify.com/supreme_coder) (community)
- **Categories:** Social media
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 comments

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

**Extract every comment from any public Instagram post or reel — comment text, author, like count, timestamp and nested replies — with no login, no password and no cookies required.** This Instagram Comments Scraper turns any **post URL, reel URL, profile or username** into clean, structured JSON, CSV or Excel data in seconds. Perfect for marketers, social listening teams, researchers and developers who need reliable Instagram comment data without building and maintaining their own scraper.

> Paste a **post / reel URL** (`https://www.instagram.com/p/DZz4bjIjhdm/`), a **profile URL** or a **username** (`nasa`) and get back every comment — plus the **threaded replies** under each one, down to the depth you choose.

---

### ✨ What this Instagram scraper does

- 💬 **Scrape all comments** from any public Instagram **post or reel**
- 🧵 **Scrape nested replies** (threaded comments) with a configurable **depth limit**
- ❤️ Get each comment's **like count, reply count** and **edited / pinned-by-owner** flags
- 🧑 Capture the **comment author** — username, full name, ID, verified & private flags, profile picture
- #️⃣ Auto-extract **@mentions and #hashtags** from every comment
- 🕒 Get exact **timestamps** (ISO 8601) for sorting and time-series analysis
- 👤 **Scrape comments by profile or username** — automatically fans out to an account's most recent posts
- 🔢 **Limit results** per post, cap replies per comment, and bound how deep threads go
- 🔐 **No Instagram login or cookies needed** — nothing to configure, no account-ban risk for you
- 📦 Export to **JSON, CSV, Excel, HTML or XML**, or pull via API

---

### 💡 Popular use cases

| Who | What they use it for |
|---|---|
| 📣 **Marketers & agencies** | Measure engagement, read audience sentiment and spot top fans on campaign posts |
| 🛍️ **E-commerce & brands** | Collect product questions, feedback and complaints straight from comment threads |
| 🤝 **Influencer marketing** | Gauge real engagement and audience quality before partnering with a creator |
| 🧠 **Social listening & sentiment** | Build datasets of comments for NLP, sentiment and trend analysis |
| 🎁 **Giveaways & contests** | Pull every entrant comment (and replies) to pick winners fairly |
| 📈 **Researchers & analysts** | Study conversations, virality and community behavior at scale |
| 🛟 **Customer support teams** | Catch questions and issues raised in comments so none slip through |

---

### 🚀 How to use it (step by step)

No coding needed. If you can fill in a form, you can use this scraper.

1. **Click "Try for free" / Start.**
2. **Add sources.** Paste **post or reel URLs** into the **Post / reel / profile URLs** field — or paste a **profile URL / username** to scrape comments from that account's latest posts. Add as many as you like.
3. **Choose how much to collect** (optional). Set **Max comments per post**, toggle **Scrape replies**, and pick a **Replies depth limit**.
4. **Click "Start".** Watch comments stream into the results table.
5. **Download your data** as **JSON, CSV, Excel, HTML or XML**, or pull it via the API.

That's it — your Instagram comment data is ready to use. 🎉

---

### ⚙️ Input fields

| Field | Type | Emoji | Description |
|---|---|---|---|
| `urls` | array of text | 🔗 | Instagram **post/reel URLs** (`https://www.instagram.com/p/DZz4bjIjhdm/`), **profile URLs** or **usernames** (`nasa`). A profile/username scrapes comments from that account's most recent posts |
| `limitPerSource` | number | 🔢 | Max **top-level comments** to scrape per post. Leave empty for all available comments (default `50`) |
| `scrapeReplies` | true / false | 🧵 | Also scrape the nested replies under each comment (default `true`) |
| `repliesDepthLimit` | number | 🪜 | How many levels of replies to follow. `1` = direct replies (Instagram's native depth); higher follows replies-of-replies where they exist (default `1`) |
| `maxRepliesPerComment` | number | ↩️ | Max replies to scrape per comment. Leave empty for all replies |
| `maxPostsPerProfile` | number | 📸 | When a profile/username is given, how many recent posts to scrape comments from (default `12`) |
| `rawData` | true / false | 🧬 | Advanced: return Instagram's raw comment objects instead of the clean output below |

#### 📝 Example input

```json
{
  "urls": [
    "https://www.instagram.com/p/DZz4bjIjhdm/",
    "https://www.instagram.com/reel/DZYvGYIv1nr/",
    "nasa"
  ],
  "limitPerSource": 100,
  "scrapeReplies": true,
  "repliesDepthLimit": 1,
  "maxRepliesPerComment": 50,
  "maxPostsPerProfile": 12
}
````

***

### 📤 Output

Each **top-level comment** is returned as one record, with its replies nested inside a `replies` array (each reply has the same shape). Export to **JSON, CSV, Excel, HTML or XML**.

#### 📦 Sample output

```json
{
  "id": "18157433164466233",
  "postUrl": "https://www.instagram.com/p/DZz4bjIjhdm/",
  "mediaId": "3923727884124821350",
  "commentUrl": "https://www.instagram.com/p/DZz4bjIjhdm/c/18157433164466233/",
  "text": "Besties in the sky 🚀♥️",
  "ownerUsername": "nutella",
  "ownerId": "628802811",
  "owner": {
    "id": "628802811",
    "username": "nutella",
    "fullName": "Nutella",
    "isVerified": true,
    "isPrivate": false,
    "profilePicUrl": "https://scontent.cdninstagram.com/v/....jpg"
  },
  "likesCount": 21,
  "repliesCount": 2,
  "mentions": [],
  "hashtags": [],
  "timestamp": "2026-06-22T13:46:40.000Z",
  "createdAtTimestamp": 1782136000000,
  "isEdited": false,
  "isRanked": true,
  "isLikedByOwner": true,
  "didReportAsSpam": false,
  "depth": 0,
  "parentCommentId": null,
  "replies": [
    {
      "id": "17880451044460103",
      "postUrl": "https://www.instagram.com/p/DZz4bjIjhdm/",
      "text": "@nutella 👏❤️",
      "ownerUsername": "debbi_officiel",
      "likesCount": 0,
      "repliesCount": 0,
      "mentions": ["nutella"],
      "timestamp": "2026-06-23T05:36:18.000Z",
      "depth": 1,
      "parentCommentId": "18157433164466233",
      "replies": []
    }
  ],
  "inputUrl": "https://www.instagram.com/p/DZz4bjIjhdm/"
}
```

> A post with no comments returns `{ "postUrl": "...", "commentsCount": 0, "info": "No comments found on this post" }`, and an unreachable source returns an `error` record — so a single bad entry never stops the rest of your run.

#### 🗂️ Output fields

| Field | Emoji | Description |
|---|---|---|
| `id` | 🆔 | Unique comment ID |
| `postUrl` | 🔗 | Link to the post/reel the comment belongs to |
| `mediaId` | 🧩 | Numeric Instagram media ID of the post |
| `commentUrl` | 🔗 | Direct link to the comment |
| `text` | 💬 | The comment text |
| `ownerUsername` | 👤 | Handle of the comment author |
| `ownerId` | 🆔 | Numeric user ID of the author |
| `owner` | 🧑 | Author object — `id`, `username`, `fullName`, `isVerified`, `isPrivate`, `profilePicUrl` |
| `likesCount` | ❤️ | Number of likes on the comment |
| `repliesCount` | 🧵 | Number of replies under the comment |
| `mentions` | #️⃣ | `@usernames` mentioned in the comment |
| `hashtags` | 🏷️ | `#hashtags` used in the comment |
| `timestamp` | 🕒 | When the comment was posted (ISO 8601) |
| `createdAtTimestamp` | ⏱️ | Same time as a Unix epoch (milliseconds) |
| `isEdited` | ✏️ | `true` if the comment was edited |
| `isRanked` | 📊 | `true` if surfaced as a top/ranked comment |
| `isLikedByOwner` | 💖 | `true` if liked by the post's owner |
| `didReportAsSpam` | 🚩 | Spam-report flag |
| `depth` | 🪜 | Thread depth — `0` for top-level, `1` for a reply, etc. |
| `parentCommentId` | 🧷 | ID of the parent comment (`null` for top-level) |
| `replies` | 🧵 | Array of nested reply records (same shape as a comment) |
| `inputUrl` | 🌐 | The URL/username this record came from |

***

### 🔌 Using the API

Run the scraper programmatically with the [Apify API](https://docs.apify.com/api/v2). Replace `YOUR_TOKEN` with your Apify API token and `USERNAME~instagram-comments` with the actor's ID.

#### Run and get results in one call (cURL)

```bash
curl -X POST "https://api.apify.com/v2/acts/USERNAME~instagram-comments/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
        "urls": ["https://www.instagram.com/p/DZz4bjIjhdm/"],
        "limitPerSource": 100,
        "scrapeReplies": true,
        "repliesDepthLimit": 1
      }'
```

#### Start a run (JavaScript / Apify client)

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

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

const run = await client.actor('USERNAME/instagram-comments').call({
  urls: ['https://www.instagram.com/p/DZz4bjIjhdm/', 'nasa'],
  limitPerSource: 100,
  scrapeReplies: true,
  repliesDepthLimit: 1,
});

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

#### Start a run (Python / Apify client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("USERNAME/instagram-comments").call(run_input={
    "urls": ["https://www.instagram.com/p/DZz4bjIjhdm/", "nasa"],
    "limitPerSource": 100,
    "scrapeReplies": True,
    "repliesDepthLimit": 1,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

📚 More: [Apify API reference](https://docs.apify.com/api/v2) · [API client for JavaScript](https://docs.apify.com/api/client/js/) · [API client for Python](https://docs.apify.com/api/client/python/)

***

### ❓ FAQ

**Do I need an Instagram account, password or cookies?**
No. You only provide the public post, reel or profile URLs you want to scrape — authentication is handled for you.

**What sources can I paste in?**
Post URLs (`/p/<code>/`), reel URLs (`/reel/<code>/`), profile URLs (`https://www.instagram.com/nasa/`) and bare usernames (`nasa`). A profile or username automatically scrapes comments from that account's most recent posts (up to **Max posts per profile**).

**How do nested replies and the depth limit work?**
Instagram threads comments one level deep: a top-level comment (`depth: 0`) can have replies (`depth: 1`). Set `repliesDepthLimit` to `1` for direct replies (the default). Higher values follow replies-of-replies wherever Instagram exposes them. Turn replies off entirely with `scrapeReplies: false` for the fastest, comments-only runs.

**Can I limit how much I scrape?**
Yes. Use `limitPerSource` to cap top-level comments per post, `maxRepliesPerComment` to cap replies per comment, and `maxPostsPerProfile` to bound profile fan-out.

**Can I scrape comments from private posts?**
No. Only comments on **public** posts and reels are accessible. Private accounts hide their posts (and comments) from non-followers.

**Why do some posts return fewer comments than the total count?**
Instagram serves comments in ranked pages and occasionally hides or filters some. The scraper paginates and de-duplicates automatically; set `limitPerSource` empty to pull as many as Instagram exposes.

**Is it legal to scrape Instagram?**
This scraper collects **publicly available** data only. You are responsible for how you use the data and for complying with applicable laws (e.g. GDPR), Instagram's Terms, and not collecting personal data without a lawful basis. When in doubt, consult a lawyer.

**What export formats are supported?**
JSON, CSV, Excel, HTML, XML, plus direct API/webhook access.

***

### 🔎 Keywords

Instagram comments scraper, scrape Instagram comments, Instagram comment extractor, Instagram reply scraper, Instagram post comments scraper, Instagram reel comments scraper, export Instagram comments to CSV/JSON/Excel, Instagram engagement scraper, Instagram sentiment analysis data, scrape Instagram without login, Instagram giveaway comment picker, Instagram social listening, Instagram comment API alternative, scrape Instagram replies, nested Instagram comments.

# Actor input Schema

## `urls` (type: `array`):

Instagram post or reel URLs to scrape comments from (e.g. "https://www.instagram.com/p/DZz4bjIjhdm/"). You can also paste a profile URL or username (e.g. "nasa") to scrape comments from that profile's most recent posts.

## `limitPerSource` (type: `integer`):

Maximum number of top-level comments to scrape per post. Leave empty for unlimited (scrape all available comments).

## `scrapeReplies` (type: `boolean`):

Also scrape the nested replies (threaded comments) under each top-level comment.

## `repliesDepthLimit` (type: `integer`):

How many levels of nested replies to follow. 1 = direct replies to top-level comments (Instagram's native depth). Higher values follow replies-of-replies where available. Ignored when "Scrape replies" is off.

## `maxRepliesPerComment` (type: `integer`):

Maximum number of replies to scrape for each comment. Leave empty for all replies.

## `maxPostsPerProfile` (type: `integer`):

When a profile URL or username is given, how many of its most recent posts to scrape comments from.

## `rawData` (type: `boolean`):

Push the scraped data directly to the dataset without any processing and filtering. Useful for retrieving fields not exposed by the default output.

## Actor input object example

```json
{
  "urls": [
    "https://www.instagram.com/p/DZz4bjIjhdm/"
  ],
  "limitPerSource": 50,
  "scrapeReplies": true,
  "repliesDepthLimit": 1,
  "maxPostsPerProfile": 12,
  "rawData": false
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "urls": [
        "https://www.instagram.com/p/DZz4bjIjhdm/"
    ],
    "limitPerSource": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("supreme_coder/instagram-comments-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 = {
    "urls": ["https://www.instagram.com/p/DZz4bjIjhdm/"],
    "limitPerSource": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("supreme_coder/instagram-comments-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 '{
  "urls": [
    "https://www.instagram.com/p/DZz4bjIjhdm/"
  ],
  "limitPerSource": 50
}' |
apify call supreme_coder/instagram-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Comments Scraper",
        "description": "Scrape comments from instagram posts including replies",
        "version": "1.0",
        "x-build-id": "Qj6aod8DQLd56rRbi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/supreme_coder~instagram-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-supreme_coder-instagram-comments-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/supreme_coder~instagram-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-supreme_coder-instagram-comments-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/supreme_coder~instagram-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-supreme_coder-instagram-comments-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",
                "properties": {
                    "urls": {
                        "title": "Post / reel / profile URLs",
                        "type": "array",
                        "description": "Instagram post or reel URLs to scrape comments from (e.g. \"https://www.instagram.com/p/DZz4bjIjhdm/\"). You can also paste a profile URL or username (e.g. \"nasa\") to scrape comments from that profile's most recent posts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "limitPerSource": {
                        "title": "Max comments per post",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of top-level comments to scrape per post. Leave empty for unlimited (scrape all available comments)."
                    },
                    "scrapeReplies": {
                        "title": "Scrape replies",
                        "type": "boolean",
                        "description": "Also scrape the nested replies (threaded comments) under each top-level comment.",
                        "default": true
                    },
                    "repliesDepthLimit": {
                        "title": "Replies depth limit",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many levels of nested replies to follow. 1 = direct replies to top-level comments (Instagram's native depth). Higher values follow replies-of-replies where available. Ignored when \"Scrape replies\" is off.",
                        "default": 1
                    },
                    "maxRepliesPerComment": {
                        "title": "Max replies per comment",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of replies to scrape for each comment. Leave empty for all replies."
                    },
                    "maxPostsPerProfile": {
                        "title": "Max posts per profile",
                        "minimum": 1,
                        "type": "integer",
                        "description": "When a profile URL or username is given, how many of its most recent posts to scrape comments from.",
                        "default": 12
                    },
                    "rawData": {
                        "title": "Get raw data (Advanced)",
                        "type": "boolean",
                        "description": "Push the scraped data directly to the dataset without any processing and filtering. Useful for retrieving fields not exposed by the default output.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
