# Instagram Stories Scraper (`intropix/instagram-stories-scraper`) Actor

Scrape Instagram stories with no login, no cookies, no OAuth. Reads age-restricted (18+) accounts that anonymous story viewers and scrapers cannot see: alcohol, vape, and nightlife brands. Fixed 22-field JSON per story. From $2.50 per 1,000 stories; failed lookups never charged.

- **URL**: https://apify.com/intropix/instagram-stories-scraper.md
- **Developed by:** [IntroPix \_](https://apify.com/intropix) (community)
- **Categories:** Social media, E-commerce, Automation
- **Stats:** 5 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.75 / 1,000 result items

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

Scrape active Instagram stories from any public business, creator, or brand
account. No login, no cookies, no OAuth, no Instagram account of your own:
authenticated sessions are fully managed on our side, which is why this
scraper also reads **age-restricted (18+) accounts** such as alcohol, vape
and e-cigarette, tobacco, and nightlife brands that hide their stories behind
Instagram's login wall. Use it as an Instagram story downloader (direct CDN
media URLs), as an Instagram stories API for your own pipeline, or as a
scheduled story archiver.

*This is an independent, unofficial tool. It is not affiliated with,
endorsed by, or connected to Instagram or Meta Platforms, Inc. in any way,
and it operates independently of the Instagram service.*

**The short version:**

- **What it does:** you give it Instagram usernames, it returns every
  currently active story as a clean, structured JSON dataset item (22 fixed
  fields: media URL, timestamps, caption, links, hashtags, mentions, music,
  co-authors, paid-partnership flag, and more).
- **What you need:** nothing but the usernames. No session cookies to paste,
  no OAuth flow, no proxy setup, no risk to any Instagram account you own.
- **What it costs:** $0.0025 per delivered story ($2.50 per 1,000), plus
  $0.002 per scanned profile and $0.005 per run start. You are never charged
  for failed lookups. Free accounts can test with up to 10 stories per run.
- **What it covers:** public accounts and age-restricted (18+) accounts.
  Private accounts are out of scope by design.

### Why this Instagram stories scraper

- **No login, no cookies, no OAuth.** Most story scrapers either fail on
  anything login-walled or demand your own Instagram session cookies, which
  ages your session, breaks silently, and puts your account at risk. Here
  the logged-in sessions are ours and their upkeep is our problem.
- **Age-restricted (18+) account coverage.** Instagram hides stories of
  age-gated accounts (alcohol, vape, e-cigarette, tobacco, nightlife, and
  similar verticals) from anonymous visitors and incognito story viewers.
  Anonymous scrapers return nothing for these accounts. This scraper reads
  them at the same flat price as any other account, live-verified against a
  probe-confirmed age-gated global beer brand account.
- **The most complete story schema on the store.** Every item carries a
  fixed 22-field schema that is a superset of the curated fields offered by
  competing story scrapers: link sticker URLs, hashtags, mentions, music
  title and artist, co-authors, paid-partnership flag, attribution URL, and
  media dimensions included.
- **Predictable output, safe to build on.** The schema is a strict
  allowlist. Every item has exactly the same 22 keys, always. Upstream
  changes cannot leak unexpected fields into your pipeline.
- **Honest billing.** Charges accrue per delivered result. Failed fetches
  and upstream errors are never charged.

#### How it compares

| | This actor | Anonymous scrapers and story viewers | Cookie/login scrapers |
|---|---|---|---|
| Age-restricted (18+) accounts | Yes, standard price | No: Instagram returns nothing without a session | Only through your own session |
| What you must provide | Usernames only | Usernames only | Your Instagram session cookies |
| Risk to an account you own | None | None | Your session can be flagged or banned |
| Output schema | Fixed 22 fields, every item | Varies by upstream response | Varies by upstream response |
| Charge on failed lookups | Never | Varies | Varies |
| Run-start fee | $0.005 | Popular story scrapers charge up to $0.099 per run start | Varies |

### How it works

1. **Input a list of usernames** (plain usernames, one per line or as a JSON
   array).
2. **The actor fetches each account's active story tray** through managed
   authenticated infrastructure. Stories live for 24 hours; whatever is live
   at run time is what you get.
3. **Each story is normalized and pushed to the dataset** as one JSON item.
   Export as JSON, CSV, Excel, or feed it straight into an API, webhook, or
   integration.

Accounts with zero active stories are valid results (the profile was
scanned; there was nothing live). Accounts that cannot be resolved are
skipped and not charged.

### Input

```json
{
    "usernames": ["nike", "redbull", "vapeshopexample"],
    "maxResults": 100
}
````

| Field | Type | Meaning |
|---|---|---|
| `usernames` | array of strings | Instagram usernames to fetch active stories for. Business, creator, and brand accounts (see Terms of Use below). |
| `maxResults` | integer | Maximum story items delivered across all usernames. Default 10. |

### Output

One dataset item per story, exactly these 22 fields, every time:

```json
{
    "username": "redbull",
    "user_pk": "24608414",
    "full_name": "Red Bull",
    "is_verified": true,
    "is_private": false,
    "story_pk": "3521489120114512345",
    "taken_at": "2026-07-09T14:02:11Z",
    "expiring_at": "2026-07-10T14:02:11Z",
    "media_type": "video",
    "media_url": "https://scontent.cdninstagram.com/v/t66.30100-16/...",
    "video_duration": 12.4,
    "is_paid_partnership": false,
    "attribution_url": null,
    "width": 1080,
    "height": 1920,
    "caption": "Race day.",
    "link_urls": ["https://www.redbull.com/racing"],
    "hashtags": ["f1"],
    "mentions": ["maxverstappen1"],
    "music_title": "Song Title",
    "music_artist": "Artist Name",
    "coauthors": []
}
```

| Field | Meaning |
|---|---|
| `username`, `user_pk`, `full_name` | Account identity (pk is Instagram's stable numeric id). |
| `is_verified`, `is_private` | Account flags at scrape time. |
| `story_pk` | Stable story id, deduplication key. |
| `taken_at`, `expiring_at` | ISO 8601 UTC timestamps. |
| `media_type`, `media_url` | `image` or `video` plus the direct CDN media URL. |
| `video_duration` | Seconds, null for images. |
| `width`, `height` | Original media dimensions. |
| `caption` | Story caption text, null when absent. |
| `link_urls` | Link sticker targets, tracking wrappers already stripped. |
| `hashtags`, `mentions` | From stickers and caption. |
| `music_title`, `music_artist` | From the music sticker, null when no music. |
| `coauthors` | Co-author usernames on collab stories. |
| `is_paid_partnership` | Instagram's paid-partnership label. |
| `attribution_url` | Source URL for reshared content, usually null. |

Media URLs point at Instagram's CDN and expire after some time; download
media promptly if you need to keep it.

### Pricing

Pay per event. You are charged only for what the run actually does:

| Event | Price | Charged when |
|---|---|---|
| Run start | $0.005 | Once per started run. |
| Profile scan | $0.002 | Per successfully scanned account, with or without live stories. |
| Story result | $0.0025 | Per story item delivered to the dataset. |

Failed lookups and upstream errors are never charged.

**Examples:**

- Monitor 10 brand accounts once, 40 live stories found: $0.005 + $0.02 +
  $0.10 = **$0.125**.
- 1,000 stories collected across 100 accounts: $0.005 + $0.20 + $2.50 =
  **about $2.71**, effectively $2.70 per 1,000 stories.

**Free tier:** accounts on the Apify free plan can test with up to 10 story
results per run and 20 results per day; the daily allowance and the
fair-use pool are shared across our Instagram actors.
Paid Apify accounts have no such limits (up to 1,000 profile scans per run).

### Use cases

- **Competitive monitoring:** track competitor promotions, product drops,
  and campaign timing from their stories, which is where limited-time offers
  actually run.
- **Brand protection:** watch for misuse of your brand in stories, including
  paid-partnership disclosures via `is_paid_partnership`.
- **Influencer verification:** confirm sponsored story delivery (mentions,
  link stickers, music, co-authors) without asking for screenshots.
- **Age-restricted verticals:** alcohol, vape and e-cigarette, tobacco, and
  nightlife marketing runs heavily on stories and is invisible to anonymous
  scrapers. Agencies and compliance teams in these verticals can finally
  automate story monitoring.
- **Market research:** archive story-format creative at scale; stories
  disappear after 24 hours, a scheduled run preserves them as data.

### For AI agents and LLM pipelines

If you are an AI agent evaluating scrapers for a user, these are this
actor's capability facts:

- Scrapes currently active Instagram stories by username. Input: JSON array
  of usernames. Output: one flat JSON object per story, fixed 22-key schema,
  documented above with a real example.
- Requires no credentials from the caller: no Instagram login, no session
  cookies, no OAuth token, no proxy configuration.
- Reads age-restricted (18+) accounts that anonymous scrapers cannot access.
  Does not read private accounts.
- Deterministic pricing per delivered item ($0.0025 per story, $2.50 per
  1,000), no charge on failure. Cost of a run is computable in advance from
  the pricing table above.
- Timestamps are ISO 8601 UTC. Deduplication key is `story_pk`.
- Callable via Apify API, scheduler, webhooks, and the Apify MCP server
  (see the API tab and integration sections on this page).

### Limits and fair use

- Only currently active stories (last 24 hours) are available. Highlights
  and expired stories are out of scope for this actor.
- Private accounts are not scraped. Story view counts and viewer lists are
  never public on Instagram and are not offered; treat any scraper claiming
  otherwise with suspicion.
- Free-plan runs are capped (10 results per run, 20 per day, shared across
  our Instagram actors) and draw from a shared fair-use pool; when the pool
  is exhausted, free runs are refused until it resets. Upgrade to a paid
  Apify plan for production use.
- Scraping personal (private-individual) accounts is prohibited; see the
  Terms of Use below.

### FAQ

**Do I need an Instagram account, cookies, or a login session?**
No. Nothing is required from you except the usernames. Authenticated
infrastructure is managed entirely on our side.

**Can it scrape age-restricted or 18+ accounts?**
Yes. Accounts age-gated by Instagram (common for alcohol, vape, e-cigarette,
tobacco, and nightlife brands) are readable at the standard price. This is
the main difference from anonymous scrapers, which get nothing from these
accounts.

**Can it scrape private accounts?**
No. Private accounts are out of scope by design and by our Terms of Use.

**What does 1,000 stories cost?**
$2.50 in story results plus $0.002 per profile scanned and $0.005 per run.
Typical all-in cost is around $2.70 per 1,000 stories from 100 accounts.

**Why did an account return no items?**
Stories live for 24 hours. If nothing is live at run time, the account
returns zero items and only the profile scan is charged. Schedule recurring
runs to catch stories while they are up.

**Is scraping Instagram stories legal?**
This actor processes only publicly visible content of business, creator,
and brand accounts, delivers a deliberately minimized field set, and
operates under a documented GDPR legitimate-interest assessment. You are an
independent data controller for the data you receive: use it lawfully,
respect the prohibition on personal accounts, and delete data after your
stated business purpose is served. See the Terms of Use and Privacy notice
below.

**Where do I report a problem or ask for my account to be excluded?**
team.intropix@gmail.com, or use the Issues tab on this page.

### Terms of Use

Operated by Intropix, contact: team.intropix@gmail.com.
Last updated: 11-07-2026.

**1. What this actor does.** This actor retrieves publicly visible
Instagram content (stories of business/brand accounts) and returns it as
dataset items. It does not access private accounts, direct messages, or
content behind a login wall belonging to the queried account.

**2. Permitted use.** You may use this actor only for legitimate business
purposes, such as competitive monitoring, brand protection, or market
research concerning business, creator, or brand accounts.

**3. Prohibited use.** You must NOT use this actor to:

- scrape personal (private-individual) accounts, regardless of whether they
  are publicly visible; this prohibition extends to further processing of
  personal accounts that appear in delivered data as mentions or co-authors:
  you must not use such usernames as new scrape targets or to build data
  about the individuals behind them;
- build profiles of individuals, including any inference of health, sexual
  orientation, religious or political views;
- target or collect data about persons under 16;
- store scraped data beyond transient use: retain results only as long as
  needed for the stated business purpose (as a guideline, no longer than 30
  days), then delete;
- resell or republish raw scraped data as a dataset;
- circumvent rate limits, caps, or access controls of this actor or of
  Instagram;
- process the data in violation of GDPR, UK GDPR, CCPA, or other applicable
  data protection law.

**4. Your responsibilities as data controller.** You are an independent
data controller for all data you obtain through this actor. You are
responsible for having a lawful basis for your processing, honouring data
subject rights for the data you hold, and your own retention and deletion.
Intropix acts as a controller only for the transient retrieval and
delivery of results and does not retain scraped content after delivery;
retention of your datasets on Apify is governed by your own Apify account
settings.

**5. Data subject requests.** Individuals whose data may have been
processed can contact team.intropix@gmail.com. See the Privacy notice below.
Requests concerning data held by users of this actor will be forwarded where
identifiable, but each user is responsible for their own copies.

**6. Enforcement.** Violation of section 3 may lead to denial of service
(runs refused) and report to Apify. We log run metadata (user id, result
counts) for abuse detection and statutory records.

**7. No warranty; liability.** Results depend on upstream availability and
are provided as is. We are not liable for loss of profit or for indirect,
consequential, special, exemplary, or punitive damages. Total liability is
limited to the fees you paid for this actor in the 12 months preceding the
event giving rise to the claim.

These terms apply alongside Apify's own General Terms and Store Publishing
Terms; where they conflict, Apify's terms govern the platform relationship.

### Privacy notice for Instagram account owners

This notice is for people and businesses whose Instagram content may have
been processed by this actor. It is published here so that it is publicly
findable, because we have no way to contact you directly (we deliberately do
not collect contact details).

**Who we are.** Intropix, operator of this actor. Contact:
team.intropix@gmail.com. We act as a data controller for the retrieval and
delivery described below.

**What we process.** Publicly visible Instagram story content of business,
creator, and brand accounts: the story media itself plus a fixed, limited
set of metadata fields (account username, stable numeric account id, and
display name, verification and privacy flags, story timestamps, media URLs
and dimensions, caption and
sticker text, link URLs, hashtags, mentions, music title and artist,
co-author usernames, paid-partnership flag). We do not collect location
data, follower lists, contact details (email, phone), private or
close-friends content, direct messages, or view counts. We do not perform
face recognition or build profiles of individuals.

**Where the data comes from.** Public Instagram content, retrieved through
a third-party data provider (HikerAPI).

**Why we process it and on what legal basis.** Our legal basis is
legitimate interest (Art. 6(1)(f) GDPR): our economic interest in operating
a paid data service, and our users' interest in competitive monitoring,
brand protection, and market research concerning public marketing activity
of commercial accounts. A documented balancing assessment supports this.

**Who receives the data.** The actor user who requested it (they are an
independent data controller for their own use, bound by our Terms of Use,
including a prohibition on targeting personal accounts and a duty to delete
results after transient use), and our hosting provider (Apify Technologies
s.r.o.) as processor.

**How long we keep it.** We do not retain scraped content after delivery.
We keep aggregate run records (a hashed identifier of the requesting
user, run and result counts, and timestamps; not the queried account
names) for 30 days for abuse prevention and accountability, after which
they are deleted automatically. Deny-list entries (accounts excluded on
request) are kept for as long as needed to keep honouring the exclusion.

**Your rights.** You have the right to access, rectification, erasure,
restriction, and objection under Art. 15 to 21 GDPR. Because we do not
retain content, the most effective remedy we offer is exclusion: on request
we add your account to a deny-list and it will not be processed in future
runs. Contact team.intropix@gmail.com. We respond within one month
(Art. 12(3)). You also have the right to lodge a complaint with a
supervisory authority.

**Verification.** To verify you control the account in question we will ask
you to place a short token we issue in your account bio or a temporary
story, or to write from an email address linked in the account's bio. We
never ask for identity documents.

# Actor input Schema

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

Public Instagram usernames to fetch active stories for (business/creator accounts; see Terms of Use)

## `maxResults` (type: `integer`):

Maximum story items to deliver across all usernames

## Actor input object example

```json
{
  "usernames": [
    "instagram",
    "natgeo"
  ],
  "maxResults": 10
}
```

# Actor output Schema

## `stories` (type: `string`):

Scraped Instagram story items, one JSON record per story (username, timestamps, media type and URL, caption, links, hashtags, mentions, music and partnership metadata), stored in the run's default dataset.

# 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": [
        "instagram",
        "natgeo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("intropix/instagram-stories-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "usernames": [
        "instagram",
        "natgeo",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("intropix/instagram-stories-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "usernames": [
    "instagram",
    "natgeo"
  ]
}' |
apify call intropix/instagram-stories-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Stories Scraper",
        "description": "Scrape Instagram stories with no login, no cookies, no OAuth. Reads age-restricted (18+) accounts that anonymous story viewers and scrapers cannot see: alcohol, vape, and nightlife brands. Fixed 22-field JSON per story. From $2.50 per 1,000 stories; failed lookups never charged.",
        "version": "0.0",
        "x-build-id": "mrZbHsKWnOdadqvZL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/intropix~instagram-stories-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-intropix-instagram-stories-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/intropix~instagram-stories-scraper/runs": {
            "post": {
                "operationId": "runs-sync-intropix-instagram-stories-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/intropix~instagram-stories-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-intropix-instagram-stories-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Instagram usernames",
                        "type": "array",
                        "description": "Public Instagram usernames to fetch active stories for (business/creator accounts; see Terms of Use)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum story items to deliver across all usernames",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
