# Instagram Metrics Scraper - Posts, Reels & Profiles (`chronometrica/instagram-metrics-scraper`) Actor

Collect clean metric rows for public Instagram posts, reels, carousels, and recent profile content. Get views, plays, likes, comments, collaborators, captions, IDs, media links, and status fields without fake zeroes.

- **URL**: https://apify.com/chronometrica/instagram-metrics-scraper.md
- **Developed by:** [Chronometrica](https://apify.com/chronometrica) (community)
- **Categories:** Social media
- **Stats:** 27 total users, 23 monthly users, 96.1% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.00 / 1,000 instagram post metrics

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 Metrics Scraper

### 📊 What does Instagram Metrics Scraper do?

Instagram Metrics Scraper collects public metrics from Instagram post URLs,
reel URLs, carousel URLs, shortcodes, profile URLs, and `@handles`.

Use it when you need clean Instagram rows for creator research, influencer
reporting, campaign tracking, competitor monitoring, social analytics,
dashboards, warehouse loads, and scheduled metric snapshots.

The Actor returns flat CSV/API-friendly rows with Instagram views, plays, likes,
comments, public owner/collaborator context, IDs, captions, media links,
duration, status fields, and count availability details.

This Actor does not log in, use cookies, scrape private Instagram content,
collect comment text, scrape stories, scrape follower lists, or bypass
Instagram access controls. It only returns data available from public Instagram
content at run time.

With Instagram Metrics Scraper, you can:

- 📈 Track public Instagram post, reel, carousel, and image performance.
- 👤 Discover recent public content from Instagram profile URLs and `@handles`.
- 👀 Collect public views, plays, Instagram plays, likes, and comments when
  available.
- 🤝 Capture public owner and collaborator profiles in one clean collaboration
  field.
- 🆔 Extract useful IDs such as `postId`, `shortCode`, `profileId`, `fbPostId`,
  `fbOwnerId`, and `carouselIds`.
- 🎬 Save captions, publish time, media type, media links, video duration, and
  audio presence when available.
- 🎯 Check metric availability instead of treating every blank count as zero.
- 📦 Export results as JSON, JSONL, CSV, Excel, XML, RSS, or HTML.

### 📦 What Instagram metric data can I extract?

Each dataset row represents one public Instagram content item with at least one
public post metric.

| Data group       | Example fields                                                                                 |
| ---------------- | ---------------------------------------------------------------------------------------------- |
| 🔗 Source        | `platform`, `inputUrl`, `postUrl`, `status`, `statusReason`, `scrapedAt`                       |
| 🆔 Post identity | `postId`, `fbPostId`, `shortCode`, `mediaType`, `publishedAt`                                  |
| 🧾 Post content  | `title`, `caption`, `downloadUrl`, `carouselIds`, `videoDurationSeconds`, `hasAudio`           |
| 👤 Creator       | `profileId`, `fbOwnerId`, `profileHandle`, `profileUrl`, `profileVerified`, `profileAvatarUrl` |
| 📊 Metrics       | `views`, `plays`, `playsInstagram`, `likes`, `comments`                                        |
| 🎯 Count quality | `postMetricStatus`, `profileMetricStatus`                                                      |
| 🤝 Collaboration | `collaborationCount`, `collaborationProfiles`                                                  |

Metric availability depends on what Instagram exposes publicly for each URL or
profile. If a public count is unavailable, the Actor keeps it unavailable
instead of filling it with a fake zero.

For reels and video posts, `views`, `plays`, and `playsInstagram` are kept as
separate public counters. Some URLs expose one count but not the others, so
missing values stay missing instead of being guessed or mixed.

`collaborationProfiles` contains the public owner and confirmed collaborators
when available. Tagged accounts are not treated as collaborators by default.

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

Yes. You can run Instagram Metrics Scraper manually in Apify Console or use it
through:

- Apify API
- Python SDK
- Node.js SDK
- Webhooks
- Scheduled runs
- Apify integrations

This makes it useful for social media dashboards, influencer lists, competitive
intelligence, creator databases, campaign reporting, data warehouses, and
automated market research workflows.

### 🎯 Why scrape Instagram post and reel metrics?

Instagram public metrics help you understand which creators, posts, reels,
campaigns, products, and competitors are gaining traction.

| Use case                     | How Instagram metric data helps                                                      |
| ---------------------------- | ------------------------------------------------------------------------------------ |
| 📈 Track creator performance | Monitor public engagement across known creator post and reel URLs.                   |
| 🧑‍🎤 Research influencers      | Compare recent content performance, captions, collaborators, and profile context.    |
| 📣 Measure campaigns         | Collect repeatable snapshots for campaign posts, reels, and creator deliverables.    |
| 🕵️ Monitor competitors       | Track public metrics for competing brands, products, and creator accounts.           |
| 🤝 Audit collaborations      | See public owner and collaborator profiles in a single normalized field.             |
| 📊 Build reporting workflows | Feed normalized Instagram metrics into dashboards, spreadsheets, APIs, and BI tools. |
| 🔎 Audit availability        | Separate available, unavailable, blocked, invalid, and failed rows cleanly.          |

### 💵 How much does scraping Instagram metrics cost?

Instagram Metrics Scraper uses Pay Per Event pricing. One billable event is one
Instagram metric row written to the default dataset.

Use `maxItems` and `maxItemsPerProfile` to control result volume before a run.
Start with a small batch of 3 to 10 URLs when testing a new URL list or profile
set.

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

1. Create or log in to your Apify account.
2. Open **Instagram Metrics Scraper**.
3. Choose **Auto-detect URLs, handles, and shortcodes**, **Post and reel URLs
   only**, or **Profile discovery only**.
4. Paste Instagram post URLs, reel URLs, profile URLs, `@handles`, shortcodes,
   or a mix of them.
5. Set the maximum number of metric rows to collect.
6. Leave the default settings for your first run.
7. Click **Start**.
8. Open the **Output** tab to inspect the dataset and run summary.
9. Download your data in JSON, JSONL, CSV, Excel, XML, RSS, or HTML.

### ⬇️ Input

The main input is `startUrls`. Paste at least one Instagram content URL, profile
URL, `@handle`, or shortcode. `https://` is optional for normal Instagram URLs.

In **Auto-detect URLs, handles, and shortcodes** mode, you can paste direct
content URLs and profile inputs into the same list. The Actor combines direct
content and profile-discovered content under one shared metric row cap.

```json
{
  "mode": "contentUrls",
  "startUrls": ["https://www.instagram.com/reel/DIwcCZgxVZP/"],
  "maxItems": 1
}
````

#### 🔗 Instagram URLs and handles

Supported input shapes include:

```text
https://www.instagram.com/reel/CODE1234567/
https://www.instagram.com/p/CODE7654321/
https://www.instagram.com/tv/CODE2222222/
www.instagram.com/reel/CODE1234567/
CODE1234567
https://www.instagram.com/mrbeast/
@mrbeast
```

Use direct URLs when you need exact known media. Use profile discovery when you
want recent public content from a creator, brand, or competitor profile.

#### 👤 Profile discovery

Use profile discovery when you want the Actor to find recent public posts and
reels from an Instagram profile before collecting metrics.

```json
{
  "mode": "profileUrls",
  "startUrls": ["@mrbeast"],
  "maxItems": 25,
  "maxItemsPerProfile": 10
}
```

Use `maxItemsPerProfile` to control how many public content URLs are discovered
from each profile input. The shared `maxItems` cap still limits total output
rows for the whole run.

#### 🎛️ Settings

| Option               | What it does                                                                                       |
| -------------------- | -------------------------------------------------------------------------------------------------- |
| `mode`               | `auto` to detect mixed inputs, `contentUrls` for content URLs only, or `profileUrls` for profiles. |
| `startUrls`          | Instagram content URLs, shortcodes, profile URLs, or `@handles`.                                   |
| `maxItems`           | Maximum metric rows to save across the whole run.                                                  |
| `maxItemsPerProfile` | Maximum public content URLs to discover from each profile input.                                   |

### ⬆️ Output sample

The results are stored in the default dataset. Each result is one Instagram
metric row.

```json
{
  "platform": "instagram",
  "inputUrl": "https://www.instagram.com/reel/CODE1234567/",
  "postUrl": "https://www.instagram.com/reel/CODE1234567/",
  "postId": "3922329444068919711",
  "fbPostId": "18066137273686492",
  "shortCode": "CODE1234567",
  "mediaType": "reel",
  "title": null,
  "caption": "Example campaign reel #launch",
  "publishedAt": "2026-06-23T13:00:00.000Z",
  "profileId": "123456789",
  "fbOwnerId": "17841400000000000",
  "profileHandle": "examplebrand",
  "profileUrl": "https://www.instagram.com/examplebrand/",
  "profileVerified": true,
  "profileAvatarUrl": "https://scontent.cdninstagram.com/avatar.jpg",
  "downloadUrl": "https://scontent.cdninstagram.com/example.mp4",
  "carouselIds": null,
  "videoDurationSeconds": 42.1,
  "hasAudio": true,
  "views": 1234567,
  "plays": 1234999,
  "playsInstagram": 1234888,
  "likes": 23456,
  "comments": 345,
  "postMetricStatus": [
    {
      "metric": "views",
      "value": 1234567,
      "status": "present",
      "precision": "exact",
      "rawValue": 1234567
    }
  ],
  "collaborationCount": 1,
  "collaborationProfiles": [
    {
      "id": "123456789",
      "handle": "examplebrand",
      "url": "https://www.instagram.com/examplebrand/",
      "role": "owner"
    }
  ],
  "profileMetricStatus": [
    {
      "metric": "profileFollowersCount",
      "value": null,
      "status": "unavailable",
      "precision": "unavailable",
      "rawValue": null
    }
  ],
  "status": "ok",
  "statusReason": null,
  "scrapedAt": "2026-06-24T15:00:00.000Z"
}
```

`inputUrl` preserves the input that produced the row. `postUrl` is the resolved
public Instagram content URL.

When a saved row has a missing public metric, that metric is returned as `null`,
not `0`. Inputs with no public `views`, `plays`, `playsInstagram`, `likes`, or
`comments` are reported in `OUTPUT` and are not saved as dataset rows.

### 🎯 Metric status

Instagram can expose exact, rounded, delayed, hidden, or unavailable counters
depending on content type and public visibility. The status fields make that
visible:

- `present`: the metric was found.
- `unavailable`: Instagram did not expose the metric publicly for that row.
- `not_attempted`: the metric was not attempted for that row.
- `exact`: the public value appeared as a full integer.
- `display_rounded` or `likely_rounded`: the public value was rounded.

This lets you filter rows without guessing whether a blank value means zero.

### 👀 Views and plays

For reels and video posts, the Actor keeps video count families separate:

- `views`
- `plays`
- `playsInstagram`

These fields may differ or appear independently. Keeping them separate makes the
dataset safer for analytics and prevents one public count from silently filling
another.

### 🤝 Collaborations

`collaborationProfiles` contains the public owner and confirmed collaborators
for a post when available. Each profile includes:

- `id`
- `handle`
- `url`
- `role`, either `owner` or `collaborator`

Tagged accounts are not treated as collaborators by default.

### 🚦 Status values

Saved rows use explicit statuses, and no-metric or failed inputs are summarized
in `OUTPUT`:

| Status                       | Meaning                                                                                            |
| ---------------------------- | -------------------------------------------------------------------------------------------------- |
| `ok`                         | Public content was resolved and at least one useful public metric or metadata field was collected. |
| `resolved_no_public_metrics` | The input resolved, but public metric fields were not exposed for that item.                       |
| `invalid_input`              | The input was not a valid Instagram URL, shortcode, or handle.                                     |
| `unsupported_url`            | The URL is an Instagram surface this Actor does not support.                                       |
| `blocked_or_challenged`      | Instagram returned a login, challenge, unavailable, or blocked response.                           |
| `failed`                     | The input could not be resolved after retry.                                                       |

Runs with setup issues, zero discovered profile content, blocked responses, or
no exposed public post metrics finish with a clear `OUTPUT` summary instead of
ending as failed runs. Check `OUTPUT.stopReason`, `OUTPUT.statusMessage`,
`OUTPUT.skippedNoPostMetricRows`, and `OUTPUT.validationErrors` when no metric
rows are saved.

### ⚠️ Notes and limitations

- Public metrics can be hidden, rounded, delayed, or unavailable.
- Reels and video posts may expose different view and play counters.
- Image posts and carousels do not always have video-specific metrics.
- Profile discovery returns recent public content and may return fewer rows than
  requested.
- Private, deleted, login-only, age-gated, or restricted content returns status
  rows instead of private data.
- Media links can expire or become unavailable after collection.
- This Actor is not affiliated with Instagram or Meta.

# Actor input Schema

## `mode` (type: `string`):

Choose how to use the inputs below. Auto-detect accepts post URLs, reel URLs, profile URLs, @handles, and shortcodes in the same list.

## `startUrls` (type: `array`):

Paste public Instagram post URLs, reel URLs, carousel URLs, profile URLs, @handles, or shortcodes. Direct inputs are normalized and the actor applies one shared metric row cap.

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

Backward-compatible hidden field for API users that send Instagram content URLs as urls.

## `shortcodes` (type: `array`):

Backward-compatible hidden field for API users that send Instagram shortcodes directly.

## `profileUrls` (type: `array`):

Backward-compatible hidden field for API users that send Instagram profile URLs or @handles as profileUrls.

## `maxItems` (type: `integer`):

Maximum number of Instagram metric rows to collect across direct content URLs and content discovered from profiles.

## `maxItemsPerProfile` (type: `integer`):

Maximum number of public content URLs to discover from each Instagram profile URL or @handle. The shared cap still limits total output rows.

## `includeProfileSnapshot` (type: `boolean`):

Backward-compatible hidden field for older API users.

## Actor input object example

```json
{
  "mode": "auto",
  "startUrls": [
    "https://www.instagram.com/reel/DIwcCZgxVZP/"
  ],
  "urls": [],
  "shortcodes": [],
  "profileUrls": [],
  "maxItems": 25,
  "maxItemsPerProfile": 20,
  "includeProfileSnapshot": true
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `output` (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 = {
    "startUrls": [
        "https://www.instagram.com/reel/DIwcCZgxVZP/"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Metrics Scraper - Posts, Reels & Profiles",
        "description": "Collect clean metric rows for public Instagram posts, reels, carousels, and recent profile content. Get views, plays, likes, comments, collaborators, captions, IDs, media links, and status fields without fake zeroes.",
        "version": "1.0",
        "x-build-id": "523Co9noTtkO5lstp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/chronometrica~instagram-metrics-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-chronometrica-instagram-metrics-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-metrics-scraper/runs": {
            "post": {
                "operationId": "runs-sync-chronometrica-instagram-metrics-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-metrics-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-chronometrica-instagram-metrics-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": {
                    "mode": {
                        "title": "Input handling",
                        "enum": [
                            "auto",
                            "contentUrls",
                            "profileUrls"
                        ],
                        "type": "string",
                        "description": "Choose how to use the inputs below. Auto-detect accepts post URLs, reel URLs, profile URLs, @handles, and shortcodes in the same list.",
                        "default": "auto"
                    },
                    "startUrls": {
                        "title": "Instagram URLs, @handles, or shortcodes",
                        "minItems": 0,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Paste public Instagram post URLs, reel URLs, carousel URLs, profile URLs, @handles, or shortcodes. Direct inputs are normalized and the actor applies one shared metric row cap.",
                        "items": {
                            "type": "string",
                            "pattern": "^\\s*(?:(?:https?:\\/\\/)?(?:(?:www\\.)?instagram\\.com)\\/\\S+|@[A-Za-z0-9._]+|[A-Za-z0-9._-]{5,})\\s*$"
                        },
                        "default": [
                            "https://www.instagram.com/reel/DIwcCZgxVZP/"
                        ]
                    },
                    "urls": {
                        "title": "Legacy content URLs",
                        "type": "array",
                        "description": "Backward-compatible hidden field for API users that send Instagram content URLs as urls.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "shortcodes": {
                        "title": "Legacy shortcodes",
                        "type": "array",
                        "description": "Backward-compatible hidden field for API users that send Instagram shortcodes directly.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "profileUrls": {
                        "title": "Legacy profile URLs",
                        "type": "array",
                        "description": "Backward-compatible hidden field for API users that send Instagram profile URLs or @handles as profileUrls.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Metric rows to collect (shared cap)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of Instagram metric rows to collect across direct content URLs and content discovered from profiles.",
                        "default": 25
                    },
                    "maxItemsPerProfile": {
                        "title": "Posts and reels to discover per profile",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of public content URLs to discover from each Instagram profile URL or @handle. The shared cap still limits total output rows.",
                        "default": 20
                    },
                    "includeProfileSnapshot": {
                        "title": "Legacy profile option",
                        "type": "boolean",
                        "description": "Backward-compatible hidden field for older API users.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
