# Instagram Comments Scraper - Fast & No Login (`chronometrica/instagram-comments-scraper`) Actor

Fast Instagram comments scraper for public posts and Reels. Get clean, unique rows with text, dates, likes, reply counts, authors, and IDs—no login or cookies.

- **URL**: https://apify.com/chronometrica/instagram-comments-scraper.md
- **Developed by:** [Chronometrica](https://apify.com/chronometrica) (community)
- **Categories:** Social media, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 1,000 instagram 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

## 💬 Instagram Comments Scraper — Fast, Clean & No Login

### 💬 What does Instagram Comments Scraper do?

Paste one or more public Instagram post or Reel URLs. Get fast, clean, unique,
and structured top-level comment rows with text, public author details, dates,
likes, reply counts, and stable post and comment IDs.

Skip manual copy-and-paste. Choose a clear per-post limit or collect until the
public feed ends, sort the sample, add optional dates, and export organized rows.

Use it for social listening, brand monitoring, creator research, customer
feedback, academic research, spreadsheets, AI work, and data pipelines. Each
saved result is one public top-level comment. Empty or unavailable posts do not
make fake dataset rows.

The Actor uses logged-out public Instagram pages. It does not need your
Instagram account, cookies, API key, or copied browser session. It does not
open private posts or bypass access controls.

With Instagram Comments Scraper, you can:

- 💬 Collect public top-level comments from known posts, Reels, and old TV URLs.
- 👤 Save public usernames, verification flags, and stable author IDs.
- ❤️ Collect public comment likes and reply totals when Instagram shows them.
- 🆔 Join data with stable post, short code, and comment IDs.
- 🎯 Set a positive comment limit for each post, or remove it.
- ↕️ Keep Instagram's default order, or sort the collected sample by date.
- 📅 Save only comments inside an optional date range.
- 🧹 Get unique rows with one stable field shape.
- 📦 Export JSON, JSONL, CSV, Excel, XML, RSS, or HTML.
- 🔁 Use the Apify API, SDKs, webhooks, schedules, and integrations.

Each paid result is one unique public top-level comment saved to the default
dataset. Invalid, unavailable, empty, and duplicate results do not create paid
comment rows.

### ✨ Why use this Actor?

- 🪄 **Easy setup:** paste public post URLs, choose a limit, an order, and optional dates.
- 🔓 **No login:** no Instagram account, cookie, or browser session is needed.
- 🧹 **Clean, structured rows:** one unique top-level comment per result.
- 🆔 **Strict identity:** each row stays tied to the requested post short code.
- 🎛️ **Visible limits:** choose a positive row limit per post or collect until the public feed ends.
- 🚦 **Honest results:** the public feed may return fewer rows, and `OUTPUT` gives a clear reason.
- 💸 **Clear billing:** pay only for unique top-level comments saved to the dataset.

### 📦 What data do I get?

Each dataset row is one public top-level Instagram comment.

| Data group         | Main fields                                         |
| ------------------ | --------------------------------------------------- |
| 🔗 Post identity   | `postId`, `postShortCode`, `postUrl`                |
| 💬 Comment         | `commentId`, `text`, `createdAt`                    |
| ❤️ Public signals  | `likesCount`, `repliesCount`                        |
| 👤 Public author   | `ownerId`, `ownerUsername`, `ownerVerified`         |
| 🕒 Collection time | `collectedAt`                                       |

Optional values that Instagram does not expose stay `null`. They are not
guessed and are not replaced with fake zeros.

`repliesCount` is the public reply total shown for a top-level comment when it
is available.

### ⚙️ Can I use this Actor through an API?

Yes. You can use:

- 🔌 Apify API
- 🐍 Python SDK
- 🟢 JavaScript SDK
- 🪝 Webhooks
- ⏰ Scheduled runs
- 🧩 Apify integrations

This makes it easy to send comments into spreadsheets, databases, dashboards,
AI analysis tools, customer-feedback systems, and research pipelines.

#### 🔌 API example

Keep your Apify token in an environment variable or secret store.

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/chronometrica~instagram-comments-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "postUrls": ["https://www.instagram.com/reel/DZu6dkVyImf/"],
    "maxCommentsPerPost": 100,
    "collectAllAvailable": false,
    "commentSortMode": "default",
    "commentsFrom": "2026-07-01",
    "commentsUntil": "2026-07-14"
  }'
````

### 🎯 Why scrape Instagram comments?

| Use case                  | How comment data helps                                           |
| ------------------------- | ---------------------------------------------------------------- |
| 📣 Brand monitoring       | Find public praise, complaints, questions, and product feedback. |
| 🧑‍🎨 Creator research       | Review the public words around known creator posts.              |
| 🚀 Campaign research      | Study public response to a launch, ad, event, or partnership.    |
| 🔎 Social listening       | Track common topics and language in public discussions.          |
| 🧑‍🔬 Academic research      | Build structured public text samples for analysis.               |
| 🤖 AI and NLP             | Feed clean comment text into topic or sentiment tools.           |
| 🧱 Data pipeline building | Load stable rows into a spreadsheet, app, database, or warehouse. |

The Actor gives you public source data. It does not add sentiment labels or
guess a person's intent.

### 💵 Pricing

The price depends on your Apify pricing tier. Each result charge represents one
unique top-level comment saved to the default dataset. Empty, unavailable, and
duplicate comments do not create comment result charges.

| Apify tier | Price per comment | Price per 1,000 comments |
| --- | ---: | ---: |
| Free | `$0.0020` | $2.00 |
| Bronze | `$0.0015` | $1.50 |
| Silver | `$0.0014` | $1.40 |
| Gold, Platinum, or Diamond | `$0.0013` | $1.30 |

There is no start fee or minimum run charge.

Use `maxCommentsPerPost` to control the largest possible dataset before you
start. Begin with 20 to 100 comments while testing a new workflow. Turn on
`collectAllAvailable` only when you accept a larger and less predictable bill.

### 🚀 How do I use Instagram Comments Scraper?

1. Open **Instagram Comments Scraper** in Apify Console.
2. Paste one or more public Instagram post or Reel URLs.
3. Choose the maximum comments to save for each post.
4. Keep the default order or choose newest-first or oldest-first with optional dates.
5. Click **Start**.
6. Open **Output** to inspect the rows and run summary.
7. Download the dataset or send it to another tool.

### ⬇️ Input

```json
{
  "postUrls": ["https://www.instagram.com/reel/DZu6dkVyImf/"],
  "maxCommentsPerPost": 100,
  "collectAllAvailable": false,
  "commentSortMode": "default",
  "commentsFrom": "2026-07-01",
  "commentsUntil": "2026-07-14"
}
```

#### 🔗 Supported URLs

- 🖼️ `https://www.instagram.com/p/SHORT_CODE/`
- 🎬 `https://www.instagram.com/reel/SHORT_CODE/`
- 📺 `https://www.instagram.com/tv/SHORT_CODE/`

Query strings are removed. Duplicate versions of the same URL are collected
once. Profile, hashtag, search, Story, and Explore URLs are not supported.

#### 🎛️ Input settings

| Setting | What it controls |
| --- | --- |
| `postUrls` | Add one or more public Instagram post, Reel, or old TV URLs. |
| `maxCommentsPerPost` | Save at most this many unique top-level comments for each URL. Use a positive whole number. Default: 100. Ignored when the limit is removed. |
| `collectAllAvailable` | Remove the numeric limit and stream rows until the public feed ends, time runs out, or the source fails. Use Default order. Off by default and may cost much more. |
| `commentSortMode` | Keep Instagram's order, or sort the collected public sample with newest or oldest comments first. Default: Instagram's order. |
| `commentsFrom` | Only save comments on or after this date. Optional. |
| `commentsUntil` | Only save comments on or before this date. Optional. |

Dates are inclusive. A comment without a public date is skipped when either
date setting is used. Instagram chooses the public sample. Default keeps the
source order. The date options sort that sample; they do not ask Instagram for
a different comment feed.

### ⬆️ Output sample

```json
{
  "postUrl": "https://www.instagram.com/reel/DZu6dkVyImf/",
  "postId": "3922329444068919711",
  "postShortCode": "DZu6dkVyImf",
  "commentId": "18000000000000000",
  "text": "Example public comment",
  "createdAt": "2026-07-14T12:00:00.000Z",
  "likesCount": 12,
  "repliesCount": 3,
  "ownerId": "123456789",
  "ownerUsername": "example_user",
  "ownerVerified": false,
  "collectedAt": "2026-07-14T16:00:00.000Z"
}
```

#### 📊 Run summary

The `OUTPUT` record includes:

- 🎯 Posts requested, successful, empty, and failed;
- 💬 Total top-level comments saved;
- 🧢 Posts that reached the chosen limit;
- 🎛️ The chosen per-post limit, remove-limit switch, order, and optional dates;
- 🚦 A clear result and stop reason for each input URL.

Common target results are:

| Result | Meaning |
| --- | --- |
| `capped` | The Actor saved the chosen per-post limit. |
| `sample` | The Actor saved a useful sample below the limit. |
| `source_exhausted` | The public feed ended before the limit. |
| `unavailable_or_no_public_data` | Instagram did not expose a public comment feed for that view. |
| `failed` | A temporary target error stopped that URL. |

An empty dataset does not always mean the post has no comments. Instagram may
show a page but leave the logged-out comment feed empty. Check `OUTPUT`, then
retry later if the post is public and comments are visible in your browser.

### 🔒 Source boundary

Instagram Comments Scraper uses logged-out public Instagram data only.

It does not:

- 🔑 Ask for your Instagram username or password;
- 🍪 Use your account, cookies, or copied session;
- 🔒 Collect private, followers-only, or login-only posts;
- 🧩 Solve access challenges or bypass access controls;
- 🔎 Discover posts from profiles, hashtags, search, or Explore;
- ♾️ Promise every comment in Instagram's displayed total.

### ⚠️ Limits and interpretation

- Instagram controls which comments are visible to a logged-out viewer.
- The same post can return a different public sample on another run.
- A displayed comment total can be higher than the public rows available.
- `maxCommentsPerPost` is a maximum, not a promise.
- Date filters and oldest-first order inspect at most 250 public comments per post unless the result limit is removed.
- Comment order applies to the collected sample, not every comment on Instagram.
- Deleted, hidden, filtered, region-limited, or moderated comments may be absent.
- Comment text, likes, reply totals, and author details can change.
- This Actor is not affiliated with Instagram or Meta.

### ❓ FAQ

#### Does this Actor need an Instagram login, cookie, or API key?

No. It uses public logged-out Instagram pages.

#### Why did I get fewer comments than the displayed total?

Instagram's displayed total and logged-out public feed can differ. The public
feed may end early or change between runs. Check each target in `OUTPUT`.

#### How do date filters and comment order work?

The Actor filters and sorts the public sample it collected. Dates include the
whole chosen day. Instagram can expose a different sample on a later run.

#### How are duplicates removed?

Duplicate input URLs are collected once. Saved rows use the post short code and
Instagram comment ID as the run key.

#### What happens when a post returns no public comments?

The target appears in `OUTPUT`. It does not create a fake comment row.

#### Can I remove the comment limit?

Yes. Turn on `collectAllAvailable`. The Actor then ignores the numeric limit
and streams rows until Instagram's public feed ends, the run times out, or the
source fails. Use Default comment order with this switch. This can take longer
and cost much more. It still cannot promise comments that Instagram does not
expose publicly.

#### Can I paste an Instagram profile URL?

No. Use known post, Reel, or old TV URLs. This Actor does not discover posts
from profiles.

### 🏆 Best practices

- 🎯 Start with 20 to 100 comments per post.
- 📚 Batch several known URLs in one run to lower run overhead per row.
- 🧾 Check `OUTPUT` before treating a small or empty dataset as a bug.
- 🆔 Join and deduplicate later work with `postShortCode` and `commentId`.
- 🔁 Use scheduled runs when you want to observe public comment changes.

### 🛟 Support

For help, include the Apify run ID, one public input URL, what you expected, and
the target result shown in `OUTPUT`. Do not send Instagram passwords, cookies,
session data, or private links.

### ⚖️ Responsible use

This Actor collects data that Instagram exposes to logged-out public viewers at
run time. You are responsible for using the data lawfully and for following
privacy, data-protection, research, and platform rules. Do not use public
comments to harass people, infer sensitive traits, or make high-impact choices
about individuals.

### 🔗 Related social media scrapers

Combine this Actor with our other social media scrapers for discovery,
performance tracking, comment research, and transcript collection.

#### Instagram

- [Instagram Metrics Scraper](https://apify.com/chronometrica/instagram-metrics-scraper)
  — collect public post, Reel, carousel, profile, and collaboration metrics.

#### Facebook

- [Facebook Metrics Scraper](https://apify.com/chronometrica/facebook-metrics-scraper)
  — collect public post, Reel, video, and profile/page metrics.
- [Facebook Comments Scraper](https://apify.com/chronometrica/facebook-comments-scraper)
  — collect public comments, replies, authors, dates, and reactions from known
  Facebook content.

#### TikTok

- [TikTok Search Scraper](https://apify.com/chronometrica/tiktok-search-scraper)
  — find public TikTok videos, creators, and metrics by keyword.
- [TikTok Metrics Scraper](https://apify.com/chronometrica/tiktok-metrics-scraper)
  — collect public video, profile, engagement, hashtag, and music data.
- [TikTok Comments Scraper](https://apify.com/chronometrica/tiktok-comments-scraper)
  — collect public comments, replies, authors, likes, and thread links.
- [TikTok Transcript Scraper](https://apify.com/chronometrica/tiktok-transcript-scraper)
  — extract public caption text and timestamped segments from TikTok videos.

#### YouTube

- [YouTube Search Scraper](https://apify.com/chronometrica/youtube-search-scraper)
  — find public videos, Shorts, channels, and metrics by keyword.
- [YouTube Metrics Scraper](https://apify.com/chronometrica/youtube-metrics-scraper)
  — collect public video, Short, channel, and engagement metrics.
- [YouTube Comments Scraper](https://apify.com/chronometrica/youtube-comments-scraper)
  — collect public comments, replies, authors, likes, pins, and creator hearts.
- [YouTube Transcript Scraper](https://apify.com/chronometrica/youtube-transcript-scraper)
  — extract public captions as clean text, timestamps, SRT, VTT, or LLM-ready
  output.

# Actor input Schema

## `postUrls` (type: `array`):

Add one or more public Instagram post or Reel URLs.

## `maxCommentsPerPost` (type: `integer`):

Save at most this many unique top-level comments for each post. This is ignored when Remove the result limit is on.

## `commentSortMode` (type: `string`):

Keep Instagram's default order, or sort the collected top-level comment sample by date.

## `commentsFrom` (type: `string`):

Only save top-level comments on or after this date. Leave empty for no start date.

## `commentsUntil` (type: `string`):

Only save top-level comments on or before this date. Leave empty for no end date.

## `collectAllAvailable` (type: `boolean`):

Ignore the maximum above and stream rows as they arrive. Use Default comment order. This may cost much more. The run still stops when the public feed ends, time runs out, or the source fails.

## Actor input object example

```json
{
  "postUrls": [
    "https://www.instagram.com/reel/DZu6dkVyImf/"
  ],
  "maxCommentsPerPost": 100,
  "commentSortMode": "default",
  "collectAllAvailable": false
}
```

# Actor output Schema

## `summary` (type: `string`):

No description

## `comments` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "postUrls": [
        "https://www.instagram.com/reel/DZu6dkVyImf/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("chronometrica/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 = { "postUrls": ["https://www.instagram.com/reel/DZu6dkVyImf/"] }

# Run the Actor and wait for it to finish
run = client.actor("chronometrica/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 '{
  "postUrls": [
    "https://www.instagram.com/reel/DZu6dkVyImf/"
  ]
}' |
apify call chronometrica/instagram-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Comments Scraper - Fast & No Login",
        "description": "Fast Instagram comments scraper for public posts and Reels. Get clean, unique rows with text, dates, likes, reply counts, authors, and IDs—no login or cookies.",
        "version": "0.1",
        "x-build-id": "6XiTGzWzDAa4wI2I4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/chronometrica~instagram-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-chronometrica-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/chronometrica~instagram-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-chronometrica-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/chronometrica~instagram-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-chronometrica-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",
                "required": [
                    "postUrls",
                    "maxCommentsPerPost"
                ],
                "properties": {
                    "postUrls": {
                        "title": "Post and Reel URLs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Add one or more public Instagram post or Reel URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxCommentsPerPost": {
                        "title": "Maximum top-level comments per post",
                        "minimum": 1,
                        "maximum": 999999,
                        "type": "integer",
                        "description": "Save at most this many unique top-level comments for each post. This is ignored when Remove the result limit is on.",
                        "default": 100
                    },
                    "commentSortMode": {
                        "title": "Comment order",
                        "enum": [
                            "default",
                            "newest",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Keep Instagram's default order, or sort the collected top-level comment sample by date.",
                        "default": "default"
                    },
                    "commentsFrom": {
                        "title": "From date",
                        "type": "string",
                        "description": "Only save top-level comments on or after this date. Leave empty for no start date."
                    },
                    "commentsUntil": {
                        "title": "To date",
                        "type": "string",
                        "description": "Only save top-level comments on or before this date. Leave empty for no end date."
                    },
                    "collectAllAvailable": {
                        "title": "Remove the result limit",
                        "type": "boolean",
                        "description": "Ignore the maximum above and stream rows as they arrive. Use Default comment order. This may cost much more. The run still stops when the public feed ends, time runs out, or the source fails.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
