# Instagram Post Scraper + Comments & Metadata (`cynix_dev/instagram-post-scraper-comments-metadata`) Actor

Scrape Instagram posts by username, profile URL, post/reel URL, or user ID. Returns captions, hashtags, mentions, likes, comments, media URLs, video views, location, and more — fast, reliable, no login required for public content.

- **URL**: https://apify.com/cynix\_dev/instagram-post-scraper-comments-metadata.md
- **Developed by:** [Cynix Dev](https://apify.com/cynix_dev) (community)
- **Categories:** Automation, Social media, Videos
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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 Post Scraper

Extract Instagram **posts, reels, and carousels** at scale — by username, profile
URL, post/reel URL, or user ID. No login required for public content. Fast,
reliable, and priced to be the best value on Apify Store.

### What it does

Give it any mix of Instagram usernames, profile links, or post/reel links and it
returns clean, structured data for every post: caption, hashtags, mentions,
likes, comments, video views, media URLs, location, owner details, and more.

### Features

- **Four input modes** — usernames/handles, profile URLs, post/reel/TV URLs, or numeric user IDs. Mix and match freely.
- **No login needed** for public posts — anonymous extraction via Apify Residential proxy.
- **Optional authenticated mode** — paste your session cookies to unlock higher volume and age-restricted/limited profiles.
- **Full pagination** — scrape from 1 to thousands of posts per profile.
- **Media type filter** — return only images, only videos/reels, only carousels, or all.
- **Rich output** — ~30 fields per post including carousel children, tagged users, coauthors, reel audio, and paid-partnership flags.
- **Cost guardrails** — sensible `resultsLimit` default so you never over-scrape by accident.
- **Comment scraping (optional)** — fetch top-level comments per post, plus nested replies, with author, text, likes, and timestamps. See below.

#### Comment scraping (requires login)

Instagram gates comments behind a logged-in session, so anonymous requests are
blocked. To scrape comments you must supply your Instagram **session cookies**
(`sessionid` + `ds_user_id`). The post itself is still scraped without them —
only the comments need the login.

##### Step 1 — log in to Instagram in your browser

Open a **desktop** browser (Chrome, Edge, Firefox, Brave) and go to
<https://www.instagram.com>, then **log in** to the account you want to scrape
with. **Use a secondary/spare account** — automated access can trigger rate
limits or a login challenge on the account whose cookie you use.

##### Step 2 — copy the two cookie values

**Option A — browser DevTools (no extension needed):**

1. With the Instagram tab open and you still logged in, press `F12` (or
   `Cmd+Option+I` / `Ctrl+Shift+I`) to open DevTools.
2. Go to the **Application** tab → **Cookies** → `https://www.instagram.com`.
   (In Firefox it's **Storage** → **Cookies**.)
3. Find the row named **`sessionid`** and copy its **Value**.
4. Find the row named **`ds_user_id`** and copy its **Value**.

**Option B — "Get cookies.txt" extension:**

1. Install a cookie-export extension such as *"Get cookies.txt LOCALLY"* from your
   browser's add-on store.
2. On the Instagram tab, click the extension and export as JSON (or .txt).
3. From the export, locate the `sessionid` and `ds_user_id` values and copy them.

> The `sessionid` is a long opaque string (e.g. starts with a digit + dot).
> `ds_user_id` is your numeric account ID. Both must come from the **same**
> logged-in session or comments won't load.

##### Step 3 — paste them into the Actor input

The easiest way: in the Actor's input, fill in the two dedicated text boxes —
no JSON needed:

- **Instagram sessionid** → paste the `sessionid` value.
- **Instagram ds_user_id** → paste the `ds_user_id` value.
- (Optional) **Instagram csrftoken** → paste if you ever see auth errors.

That's enough for comment scraping and higher-volume access.

<details><summary>Prefer to paste the full exported cookie JSON? (advanced / agents)</summary>

Open **Advanced: raw cookies JSON** and paste the full cookie array (e.g. from
the "Cookie Editor" browser extension) as an array of `{ name, value }` objects.
It is merged with the two text boxes above.

```json
"sessionCookies": [
  { "name": "sessionid",    "value": "PASTE_YOUR_sessionid_VALUE_HERE" },
  { "name": "ds_user_id",  "value": "PASTE_YOUR_ds_user_id_VALUE_HERE" }
]
````

</details>

##### Step 4 — enable comment scraping

- Turn **Scrape comments** ON.
- Set **Max comments per post** (default 20).
- Optionally turn on **Include comment replies** for nested replies.

That's it. Each scraped post will then include a `commentsScraped` array with
author, text, likes, timestamps, and nested replies.

```json
"commentsScraped": [
  { "id": "...", "text": "...", "username": "fan_one", "likes": 42,
    "timestamp": "2026-06-16T...", "ownerUsername": "natgeo",
    "childComments": [ { "text": "reply here", "username": "fan_two", ... } ] }
],
"commentsScrapedCount": 10
```

If **Scrape comments** is enabled but **Session cookies is empty**, the Actor
skips comments and logs a clear warning instead of failing — your posts are
still scraped.

### Input example

Basic (posts only):

```json
{
  "usernames": ["natgeo", "nasa"],
  "directUrls": ["https://www.instagram.com/p/DZpQwxqimz2/"],
  "resultsLimit": 30,
  "mediaTypeFilter": "all",
  "includePinned": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

With comments enabled (requires session cookies — see above):

```json
{
  "usernames": ["natgeo"],
  "resultsLimit": 10,
  "scrapeComments": true,
  "maxComments": 25,
  "scrapeCommentReplies": true,
  "sessionCookies": [
    { "name": "sessionid",   "value": "PASTE_YOUR_sessionid_VALUE_HERE" },
    { "name": "ds_user_id", "value": "PASTE_YOUR_ds_user_id_VALUE_HERE" }
  ],
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Output example (one post)

```json
{
  "id": "3920738671208852726",
  "type": "Video",
  "shortCode": "DZpQwxqimz2",
  "url": "https://www.instagram.com/p/DZpQwxqimz2/",
  "caption": "There's more to the story of Pompeii...",
  "hashtags": ["PompeiiOutOfTime"],
  "mentions": ["twhiddleston", "NatGeoTV"],
  "timestamp": "2026-06-16T16:00:07+00:00",
  "likesCount": 139079,
  "commentsCount": 1222,
  "isVideo": true,
  "mediaType": "video",
  "ownerUsername": "natgeo",
  "ownerFollowersCount": 280000000,
  "displayUrl": "https://scontent.cdninstagram.com/....jpg"
}
```

### How to use

1. Enter one or more usernames or paste Instagram URLs.
2. Set **Max posts per profile** (default 30).
3. Optionally choose a **Media type filter** and toggle **Include pinned posts**.
4. Click **Start**. Results appear in the dataset — export to JSON, CSV, Excel, or via API.

### Proxies

Instagram aggressively rate-limits datacenter IPs. This Actor defaults to
**Apify Residential proxy**, which is required for stable results. You can set a
specific exit country with **Proxy country**.

### Authenticated (cookie) mode

For heavy usage or limited profiles, export your Instagram cookies (e.g. with a
"Get cookies.txt" browser extension) and paste the `sessionid` and `ds_user_id`
entries into **Session cookies**. The Actor will attach them to every request.

> Use a secondary account for scraping. Automated access can trigger Instagram
> rate limits or blocks on the account whose cookies you provide.

### Pricing

This Actor uses **pay-per-result**: you are charged per post returned, plus your
Apify platform usage (compute + residential proxy traffic). See the Actor's
pricing tab for the current per-result rate.

### Data you can extract

Post ID, type, shortcode, URL, caption, hashtags, mentions, timestamp, likes,
comments, video views, video duration, media type, display URL, all image URLs,
video URL, carousel children, tagged users, coauthors, reel audio, location,
owner username/ID/full name/verified/followers, product type, and
paid-partnership flag.

### Legal

Scrape only publicly available data and use it in compliance with Instagram's
Terms of Service, the GDPR/CCPA, and applicable laws. You are responsible for how
you use the data. This Actor does not collect private or non-public information.

### Support

Found a bug or need a field added? Open an issue on the Actor's Issues tab.

# Actor input Schema

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

One or more Instagram usernames (e.g. "natgeo") or handles ("@natgeo"). The scraper resolves each to its posts automatically.

## `directUrls` (type: `array`):

Direct Instagram URLs. Supports profile URLs (https://www.instagram.com/natgeo/), post URLs (/p/CODE/), reel URLs (/reel/CODE/), and TV URLs (/tv/CODE/).

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

Maximum number of posts to scrape per profile. Post/reel URLs always return exactly that one post. Keep this reasonable to control cost.

## `mediaTypeFilter` (type: `string`):

Only return posts of the selected media type. "all" returns everything.

## `includePinned` (type: `boolean`):

Whether to include posts pinned to the top of the profile grid.

## `scrapeComments` (type: `boolean`):

Fetch comments for each scraped post. REQUIRES session cookies — Instagram gates comments behind a logged-in session on 2026. Provide sessionCookies (sessionid + ds\_user\_id) or comments will be skipped with a warning.

## `maxComments` (type: `integer`):

Maximum number of top-level comments to fetch per post.

## `scrapeCommentReplies` (type: `boolean`):

Also fetch nested replies (child comments) under each comment.

## `proxyCountry` (type: `string`):

ISO 3166-1 alpha-2 country code for residential proxy exit location (e.g. US, GB, DE, FR). Leave empty for auto/any.

## `sessionid` (type: `string`):

Your Instagram `sessionid` cookie. Required for comment scraping and higher-volume / limited-profile access. Log in to instagram.com, open DevTools → Application → Cookies, copy the `sessionid` value. Leave blank to scrape public posts anonymously.

## `dsUserId` (type: `string`):

Your Instagram `ds_user_id` cookie (your numeric account ID). Copy it from the same Cookies list as sessionid. Must come from the same logged-in session as sessionid.

## `csrfToken` (type: `string`):

Optional `csrftoken` cookie. Usually not required, but paste it if you see auth errors. Copy from the same Cookies list.

## `sessionCookies` (type: `array`):

Advanced / agent use. Paste the full exported cookie array (e.g. from the 'Cookie Editor' browser extension) as an array of {name, value} objects. If provided, it is merged with the individual cookie fields above. Most users should just fill in sessionid + ds\_user\_id above.

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

Apify proxy settings. Residential is strongly recommended for Instagram. Defaults to Apify residential proxy.

## Actor input object example

```json
{
  "usernames": [
    "natgeo",
    "nasa"
  ],
  "directUrls": [
    "https://www.instagram.com/p/DZpQwxqimz2/"
  ],
  "resultsLimit": 30,
  "mediaTypeFilter": "all",
  "includePinned": true,
  "scrapeComments": false,
  "maxComments": 20,
  "scrapeCommentReplies": false,
  "proxyCountry": "US",
  "sessionid": "PASTE_YOUR_sessionid_HERE",
  "dsUserId": "PASTE_YOUR_ds_user_id_HERE",
  "sessionCookies": [
    {
      "name": "sessionid",
      "value": "YOUR_SESSION_ID"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing all scraped Instagram posts

# 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": [
        "natgeo"
    ],
    "sessionid": "",
    "dsUserId": "",
    "csrfToken": "",
    "sessionCookies": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("cynix_dev/instagram-post-scraper-comments-metadata").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": ["natgeo"],
    "sessionid": "",
    "dsUserId": "",
    "csrfToken": "",
    "sessionCookies": [],
}

# Run the Actor and wait for it to finish
run = client.actor("cynix_dev/instagram-post-scraper-comments-metadata").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": [
    "natgeo"
  ],
  "sessionid": "",
  "dsUserId": "",
  "csrfToken": "",
  "sessionCookies": []
}' |
apify call cynix_dev/instagram-post-scraper-comments-metadata --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Post Scraper + Comments & Metadata",
        "description": "Scrape Instagram posts by username, profile URL, post/reel URL, or user ID. Returns captions, hashtags, mentions, likes, comments, media URLs, video views, location, and more — fast, reliable, no login required for public content.",
        "version": "1.2",
        "x-build-id": "nQ9pCAW53r25W8RIV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cynix_dev~instagram-post-scraper-comments-metadata/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cynix_dev-instagram-post-scraper-comments-metadata",
                "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/cynix_dev~instagram-post-scraper-comments-metadata/runs": {
            "post": {
                "operationId": "runs-sync-cynix_dev-instagram-post-scraper-comments-metadata",
                "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/cynix_dev~instagram-post-scraper-comments-metadata/run-sync": {
            "post": {
                "operationId": "run-sync-cynix_dev-instagram-post-scraper-comments-metadata",
                "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": {
                    "usernames": {
                        "title": "Instagram usernames or handles",
                        "type": "array",
                        "description": "One or more Instagram usernames (e.g. \"natgeo\") or handles (\"@natgeo\"). The scraper resolves each to its posts automatically.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "directUrls": {
                        "title": "Profile or post URLs",
                        "type": "array",
                        "description": "Direct Instagram URLs. Supports profile URLs (https://www.instagram.com/natgeo/), post URLs (/p/CODE/), reel URLs (/reel/CODE/), and TV URLs (/tv/CODE/).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsLimit": {
                        "title": "Max posts per profile",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of posts to scrape per profile. Post/reel URLs always return exactly that one post. Keep this reasonable to control cost.",
                        "default": 30
                    },
                    "mediaTypeFilter": {
                        "title": "Media type filter",
                        "enum": [
                            "all",
                            "image",
                            "video",
                            "carousel"
                        ],
                        "type": "string",
                        "description": "Only return posts of the selected media type. \"all\" returns everything.",
                        "default": "all"
                    },
                    "includePinned": {
                        "title": "Include pinned posts",
                        "type": "boolean",
                        "description": "Whether to include posts pinned to the top of the profile grid.",
                        "default": true
                    },
                    "scrapeComments": {
                        "title": "Scrape comments",
                        "type": "boolean",
                        "description": "Fetch comments for each scraped post. REQUIRES session cookies — Instagram gates comments behind a logged-in session on 2026. Provide sessionCookies (sessionid + ds_user_id) or comments will be skipped with a warning.",
                        "default": false
                    },
                    "maxComments": {
                        "title": "Max comments per post",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of top-level comments to fetch per post.",
                        "default": 20
                    },
                    "scrapeCommentReplies": {
                        "title": "Include comment replies",
                        "type": "boolean",
                        "description": "Also fetch nested replies (child comments) under each comment.",
                        "default": false
                    },
                    "proxyCountry": {
                        "title": "Proxy country",
                        "maxLength": 2,
                        "type": "string",
                        "description": "ISO 3166-1 alpha-2 country code for residential proxy exit location (e.g. US, GB, DE, FR). Leave empty for auto/any.",
                        "default": "US"
                    },
                    "sessionid": {
                        "title": "Instagram sessionid",
                        "type": "string",
                        "description": "Your Instagram `sessionid` cookie. Required for comment scraping and higher-volume / limited-profile access. Log in to instagram.com, open DevTools → Application → Cookies, copy the `sessionid` value. Leave blank to scrape public posts anonymously."
                    },
                    "dsUserId": {
                        "title": "Instagram ds_user_id",
                        "type": "string",
                        "description": "Your Instagram `ds_user_id` cookie (your numeric account ID). Copy it from the same Cookies list as sessionid. Must come from the same logged-in session as sessionid."
                    },
                    "csrfToken": {
                        "title": "Instagram csrftoken (optional)",
                        "type": "string",
                        "description": "Optional `csrftoken` cookie. Usually not required, but paste it if you see auth errors. Copy from the same Cookies list."
                    },
                    "sessionCookies": {
                        "title": "Advanced: raw cookies JSON (optional)",
                        "type": "array",
                        "description": "Advanced / agent use. Paste the full exported cookie array (e.g. from the 'Cookie Editor' browser extension) as an array of {name, value} objects. If provided, it is merged with the individual cookie fields above. Most users should just fill in sessionid + ds_user_id above."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Residential is strongly recommended for Instagram. Defaults to Apify residential proxy.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```