# Instagram Posts Scraper (`fmchisti/instagram-posts-scraper`) Actor

Scrape public Instagram posts, reels, captions, hashtags, media URLs, and engagement data from usernames, profile URLs, or post links. Fast, HTTP-first, reliable, and cost-optimized for research, monitoring, and lead generation.

- **URL**: https://apify.com/fmchisti/instagram-posts-scraper.md
- **Developed by:** [Fahim Mahmud Chisti](https://apify.com/fmchisti) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.25 / 1,000 posts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### What does Instagram Posts Scraper do?

**Instagram Posts Scraper** extracts public Instagram post data from usernames, profile URLs, or specific post/reel URLs. It is an HTTP-first Apify Actor designed to keep compute costs low while still returning structured fields compatible with common Instagram post scrapers (caption, engagement, media URLs, comments sample, tagged users, and more).

Run it on the [Apify platform](https://apify.com) to schedule scrapes, export JSON/CSV/Excel, call it from the API, or connect webhooks and integrations.

### Why use this scraper?

- **Cost-aware defaults** — Basic detail level and modest post limits out of the box
- **Simple input** — Paste `@username`, a profile URL, or a `/p/` / `/reel/` link
- **Useful filters in the UI** — Date cutoff, skip pinned posts, post-type filter
- **Clear errors** — Private, login-required, blocked, and not-found cases return structured error rows instead of empty junk
- **Incremental runs** — Optional cross-run duplicate URL skipping for scheduled monitoring

### How to use Instagram Posts Scraper

1. Create a free Apify account.
2. Open **Instagram Posts Scraper**.
3. Add one or more usernames, profile URLs, or post URLs.
4. Keep **Data detail level** on **Basic data (cheaper)** unless you need video URLs, tagged users, or richer comments.
5. Click **Start** and download results from the Dataset tab.

### How to keep costs low

| Tip                                 | Why it helps                        |
| ----------------------------------- | ----------------------------------- |
| Use **Basic data**                  | Avoids a detail request per post    |
| Lower **Maximum posts per profile** | Fewer timeline pages and rows       |
| Set **Only posts newer than**       | Stops scrolling older history early |
| Skip pinned posts when irrelevant   | Avoids old pinned items             |
| Keep **Latest comments** small      | Smaller payloads on Detailed runs   |
| Enable duplicate check on schedules | Skips posts you already scraped     |

Detailed data is available when you need video URLs, carousel children, music info, coauthors, tagged users, or a larger comment sample — expect higher usage than Basic.

### Input

| Field                                        | Description                                                  |
| -------------------------------------------- | ------------------------------------------------------------ |
| Instagram username, profile URL, or post URL | Required list. Mix usernames and URLs.                       |
| Maximum posts per profile                    | Default `20`. Ignored for direct post URLs.                  |
| Only posts newer than                        | `YYYY-MM-DD`, ISO, or relative (`1 day`, `2 months`). UTC.   |
| Skip pinned posts                            | Omit pinned timeline items.                                  |
| Post type filter                             | All, Image, Video, Sidecar (carousel), or Reels (`clips`).   |
| Data detail level                            | `basicData` (default) or `detailedData`.                     |
| Latest comments to collect                   | Default `5` (0–20).                                          |
| Session cookies                              | Optional. Empty = anonymous HTML-first mode for public data. |

| Proxy | Residential US recommended. |

Example:

```json
{
    "username": ["natgeo", "https://www.instagram.com/p/DLNsnpUTdVS/"],
    "resultsLimit": 20,
    "skipPinnedPosts": false,
    "postTypeFilter": "all",
    "dataDetailLevel": "basicData",
    "latestCommentsLimit": 5
}
````

### Output

Results land in the default dataset. You can download JSON, CSV, Excel, HTML, or XML.

Sample fields (drop-in friendly with common Instagram post scrapers):

| Field                                       | Description                                   |
| ------------------------------------------- | --------------------------------------------- |
| `url` / `shortCode` / `id`                  | Post identity                                 |
| `type`                                      | `Image`, `Video`, or `Sidecar`                |
| `caption`, `hashtags`, `mentions`           | Caption-derived text                          |
| `likesCount`, `commentsCount`               | Engagement (`likesCount` is `-1` when hidden) |
| `displayUrl`, `images`, `videoUrl`          | Media                                         |
| `latestComments`, `firstComment`            | Comment sample                                |
| `ownerUsername`, `ownerId`, `ownerFullName` | Author                                        |
| `timestamp`, `isPinned`, `productType`      | Metadata                                      |
| `reshareCount`                              | When Instagram provides it                    |
| `childPosts`                                | Carousel children (mainly Detailed)           |
| `error`, `errorDescription`                 | Structured failure info                       |

Example item:

```json
{
    "inputUrl": "https://www.instagram.com/natgeo/",
    "id": "3660778310592222546",
    "type": "Image",
    "shortCode": "DLNsnpUTdVS",
    "caption": "Brain science #Nature @disney",
    "hashtags": ["Nature"],
    "mentions": ["disney"],
    "url": "https://www.instagram.com/p/DLNsnpUTdVS/",
    "commentsCount": 230,
    "likesCount": 73473,
    "displayUrl": "https://example.com/image1.jpg",
    "timestamp": "2025-06-22T19:00:10.000Z",
    "ownerUsername": "natgeo",
    "ownerId": "787132",
    "isPinned": false,
    "reshareCount": null,
    "error": null
}
```

### Pricing / cost estimation

Pay per event (PPE). Charges apply when a post is written to the dataset:

| Mode (`dataDetailLevel`)  | Event name | Price                             |
| ------------------------- | ---------- | --------------------------------- |
| Basic (`basicData`)       | `post`     | **$2.25 / 1,000** ($0.00225 each) |
| Advanced (`detailedData`) | `details`  | **$4.25 / 1,000** ($0.00425 each) |

Also keep Apify’s synthetic `apify-actor-start` event (covers the first ~5s of compute). Remove `apify-default-dataset-item` in Console so dataset writes are not double-charged.

Platform compute/proxy usage is separate from event fees unless you enable “PPE + usage”. The Actor stops when the user’s max spend limit is reached ([docs](https://docs.apify.com/actors/publishing/monetize/pay-per-event#respect-user-spending-limits)).

This Actor is built to minimize compute: no headless browser, Basic mode by default, early stop on date filters and duplicate streaks.

### Tips

- Public accounts only. Private profiles return a `private` error row.
- Cookies are **optional**. Leave empty for anonymous public scraping via Instagram’s web API + residential proxy rotation (same approach as other public IG scrapers).
- Add cookies only when needed: paste `sessionid=...; csrftoken=...` or a JSON cookie export. Without `sessionid`, the Actor stays in anonymous mode.
- Unlike [Apify Instagram Post Scraper](https://apify.com/apify/instagram-post-scraper), this Actor does not use Apify’s private session pool — cookies you provide are your own browser session.
- In Detailed mode without cookies, failed post detail fetches fall back to the basic timeline snapshot instead of only error rows.
- Keep Apify Residential proxies enabled. Anonymous mode rotates proxy sessions when Instagram blocks a request.
- Sidecar means carousel (multiple images/videos in one post).
- Reels appear as `type: "Video"` with `productType: "clips"`.
- Profile timelines paginate via Instagram's `feed/user` HTTP API after the first page (cookie mode). Anonymous mode usually stops after the first HTML page.
- For full comment threads, use a dedicated comments scraper; this Actor only samples latest comments.
- Old pinned posts are ignored when applying the date cutoff stop, so they won't block scraping of newer posts.

### FAQ

**Can it scrape private accounts?**\
No. Only public profiles and posts.

**Why is `likesCount` -1?**\
The author hid like counts. Instagram does not expose the number publicly.

**Does it extract reels?**\
Yes. Filter with Post type → Reels (clips) if you only want reels.

**Is reshare/repost count included?**\
When Instagram includes reshare/share counts in the payload, they are mapped to `reshareCount`.

**Is scraping Instagram legal?**\
This Actor only collects publicly available data. You are responsible for complying with Instagram’s terms and applicable privacy laws (including GDPR where relevant). If unsure, consult a lawyer.

### Support

Found a bug or have feedback? Open an issue on the Actor’s Issues tab on Apify.

# Actor input Schema

## `username` (type: `array`):

Add one or more Instagram usernames (@natgeo or natgeo), profile URLs, or specific post/reel URLs. Mix them freely. Profile targets respect Maximum posts and date filters; direct post URLs ignore those limits.

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

How many posts to return from each profile. Does not apply when scraping specific post URLs. Lower values cost less.

## `onlyPostsNewerThan` (type: `string`):

Optional cutoff. Use YYYY-MM-DD, full ISO timestamp, or relative time such as 1 day, 2 months, or 3 years. Values are interpreted in UTC. Stops scrolling older timeline pages early to save cost.

## `skipPinnedPosts` (type: `boolean`):

When enabled, pinned profile posts are omitted from results.

## `postTypeFilter` (type: `string`):

Keep only matching post types. Use All posts for every timeline item that passes other filters.

## `dataDetailLevel` (type: `string`):

Basic ($2.25 / 1,000 posts) uses the profile timeline only. Detailed ($4.25 / 1,000) opens each post for video URLs, tagged users, coauthors, music info, and a richer comment sample. Prefer Basic unless you need those fields.

## `latestCommentsLimit` (type: `integer`):

How many recent comments to include per post when available. Applies mainly to Detailed data. Keep low to reduce payload size and cost.

## `cookies` (type: `string`):

Optional — leave empty for public scraping (recommended default). If Instagram blocks requests, paste sessionid=...; csrftoken=... (or JSON cookie export). Never share cookies publicly.

## `duplicateCheck` (type: `boolean`):

When enabled, posts already recorded in the named key-value store (and optional exists API) are skipped. Useful for scheduled incremental scrapes.

## `duplicateCheckApiUrl` (type: `string`):

Optional POST endpoint that accepts { "listingUrls": string\[] } and returns { "existing": string\[], "missing": string\[] }.

## `duplicateCheckStoreName` (type: `string`):

Named Apify key-value store used to remember scraped post URLs across runs.

## `duplicateCheckLeadingStop` (type: `integer`):

When duplicate check is on, stop paginating a profile after this many consecutive already-known posts (newest-first timelines).

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

Residential proxies are recommended for Instagram. Datacenter IPs are often blocked.

## Actor input object example

```json
{
  "username": [
    "natgeo"
  ],
  "resultsLimit": 20,
  "skipPinnedPosts": false,
  "postTypeFilter": "all",
  "dataDetailLevel": "basicData",
  "latestCommentsLimit": 5,
  "duplicateCheck": false,
  "duplicateCheckStoreName": "instagram-post-urls",
  "duplicateCheckLeadingStop": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

No description

## `scrapeState` (type: `string`):

No description

## `debugPages` (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 = {
    "username": [
        "natgeo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fmchisti/instagram-posts-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 = { "username": ["natgeo"] }

# Run the Actor and wait for it to finish
run = client.actor("fmchisti/instagram-posts-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 '{
  "username": [
    "natgeo"
  ]
}' |
apify call fmchisti/instagram-posts-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Posts Scraper",
        "description": "Scrape public Instagram posts, reels, captions, hashtags, media URLs, and engagement data from usernames, profile URLs, or post links. Fast, HTTP-first, reliable, and cost-optimized for research, monitoring, and lead generation.",
        "version": "0.1",
        "x-build-id": "hrj81gEQpvO8b5O20"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fmchisti~instagram-posts-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fmchisti-instagram-posts-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/fmchisti~instagram-posts-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fmchisti-instagram-posts-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/fmchisti~instagram-posts-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fmchisti-instagram-posts-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": [
                    "username"
                ],
                "properties": {
                    "username": {
                        "title": "Instagram username, profile URL, or post URL",
                        "type": "array",
                        "description": "Add one or more Instagram usernames (@natgeo or natgeo), profile URLs, or specific post/reel URLs. Mix them freely. Profile targets respect Maximum posts and date filters; direct post URLs ignore those limits.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsLimit": {
                        "title": "Maximum posts per profile",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How many posts to return from each profile. Does not apply when scraping specific post URLs. Lower values cost less.",
                        "default": 20
                    },
                    "onlyPostsNewerThan": {
                        "title": "Only posts newer than",
                        "pattern": "^(\\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])(T([01]\\d|2[0-3]):[0-5]\\d(:[0-5]\\d)?(\\.\\d+)?Z?)?$|^(\\d+)\\s*(minute|hour|day|week|month|year)s?$",
                        "type": "string",
                        "description": "Optional cutoff. Use YYYY-MM-DD, full ISO timestamp, or relative time such as 1 day, 2 months, or 3 years. Values are interpreted in UTC. Stops scrolling older timeline pages early to save cost."
                    },
                    "skipPinnedPosts": {
                        "title": "Skip pinned posts",
                        "type": "boolean",
                        "description": "When enabled, pinned profile posts are omitted from results.",
                        "default": false
                    },
                    "postTypeFilter": {
                        "title": "Post type filter",
                        "enum": [
                            "all",
                            "Image",
                            "Video",
                            "Sidecar",
                            "clips"
                        ],
                        "type": "string",
                        "description": "Keep only matching post types. Use All posts for every timeline item that passes other filters.",
                        "default": "all"
                    },
                    "dataDetailLevel": {
                        "title": "Data detail level",
                        "enum": [
                            "basicData",
                            "detailedData"
                        ],
                        "type": "string",
                        "description": "Basic ($2.25 / 1,000 posts) uses the profile timeline only. Detailed ($4.25 / 1,000) opens each post for video URLs, tagged users, coauthors, music info, and a richer comment sample. Prefer Basic unless you need those fields.",
                        "default": "basicData"
                    },
                    "latestCommentsLimit": {
                        "title": "Latest comments to collect",
                        "minimum": 0,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many recent comments to include per post when available. Applies mainly to Detailed data. Keep low to reduce payload size and cost.",
                        "default": 5
                    },
                    "cookies": {
                        "title": "Session cookies (optional)",
                        "type": "string",
                        "description": "Optional — leave empty for public scraping (recommended default). If Instagram blocks requests, paste sessionid=...; csrftoken=... (or JSON cookie export). Never share cookies publicly."
                    },
                    "duplicateCheck": {
                        "title": "Skip known post URLs",
                        "type": "boolean",
                        "description": "When enabled, posts already recorded in the named key-value store (and optional exists API) are skipped. Useful for scheduled incremental scrapes.",
                        "default": false
                    },
                    "duplicateCheckApiUrl": {
                        "title": "Duplicate-check API URL",
                        "type": "string",
                        "description": "Optional POST endpoint that accepts { \"listingUrls\": string[] } and returns { \"existing\": string[], \"missing\": string[] }."
                    },
                    "duplicateCheckStoreName": {
                        "title": "Duplicate-check store name",
                        "type": "string",
                        "description": "Named Apify key-value store used to remember scraped post URLs across runs.",
                        "default": "instagram-post-urls"
                    },
                    "duplicateCheckLeadingStop": {
                        "title": "Stop after consecutive known posts",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "When duplicate check is on, stop paginating a profile after this many consecutive already-known posts (newest-first timelines).",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies are recommended for Instagram. Datacenter IPs are often blocked.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
