# Instagram Photos Downloader (`scraperoka/instagram-photos-downloader`) Actor

📸 Instagram Photos Downloader lets you save photos & videos fast with a smooth, user-friendly experience. 🚀 Download content effortlessly for sharing, backup, or inspiration. 🔒 Simple, efficient, and made for creators.

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

## Pricing

from $0.01 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Photos Downloader 🚀

Manually visiting Instagram posts to save images and media one by one wastes hours you don’t have. **Instagram Photos Downloader** scrapes Instagram posts, reels, and galleries in bulk so you can get consistent downloads-ready media data fast. This Instagram photo downloader is ideal for marketers, growth teams, and researchers looking to download Instagram photos without the busywork—running through your list in minutes and producing structured results at scale.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "url": "https://www.instagram.com/p/CaHpoweBjmx/",
  "source": "instagram",
  "shortcode": "CaHpoweBjmx",
  "author": "jane_doe",
  "music_attribution_info": null,
  "duration": 0,
  "owner": {
    "pk": "123456789",
    "id": "123456789",
    "username": "jane_doe",
    "profile_pic_url": "https://example.com/jane.jpg",
    "show_account_transparency_details": true,
    "__typename": "XDTUserDict",
    "is_private": false,
    "friendship_status": null,
    "transparency_product": null,
    "transparency_product_enabled": false,
    "transparency_label": null,
    "ai_agent_owner_username": null,
    "is_unpublished": false,
    "is_verified": false
  },
  "view_count": 15234,
  "like_count": 876,
  "title": "Check out my latest post ✨",
  "thumbnail": "https://example.com/thumbnail.jpg",
  "medias": [
    {
      "url": "https://example.com/media1.jpg",
      "height": 1080,
      "width": 1080,
      "id": "9999999999",
      "quality": "image 1080x1080p 1",
      "resolution": "1080x1080",
      "type": "image",
      "extension": "jpg"
    }
  ],
  "type": "image",
  "error": false,
  "time_end": 842
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `url` | string | The exact Instagram URL processed in your run |
| `source` | string | Confirms the origin is `instagram` for every record |
| `shortcode` | string | The media identifier extracted from the Instagram URL |
| `author` | string | The account name tied to the post/reel/gallery |
| `duration` | number | Video duration in seconds (0 for images) |
| `owner.pk` | string | Internal owner identifier used by Instagram for the media |
| `owner.username` | string | The creator’s handle (useful for grouping and reporting) |
| `owner.profile_pic_url` | string | Profile picture URL for quick profile visualization |
| `view_count` | number | View/play count value for ranking or benchmarking |
| `like_count` | number | Like count for engagement analysis |
| `title` | string | Caption text for context (handy for NLP or tagging) |
| `thumbnail` | string | A quick preview image URL |
| `medias` | array | One or more downloadable media items (single post vs carousel) |
| `type` | string | Whether the result is `image`, `video`, or `multiple` |
| `error` | boolean | Whether scraping succeeded for this URL |
| `time_end` | number | Time spent on this URL (milliseconds) |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Instagram Photos Downloader?

There are a lot of ways to pull data from Instagram — here’s what sets Instagram Photos Downloader apart.

#### Media-rich output (single + carousel)

Instagram Photos Downloader supports single media and carousels, returning a `medias` array that lists each image/video item with URL and dimensions. If you’re using an Instagram image downloader workflow, this “one record, many medias” structure makes downstream processing much easier.

#### Structured results you can use immediately

Each scraped post/reel/gallery returns consistent fields such as `owner`, `like_count`, `view_count`, `thumbnail`, and `medias`. This makes the Instagram post downloader output integration-friendly for analysts building tables, dashboards, or enrichment pipelines.

#### Resilient scraping with fallback handling

The actor uses a resilient approach: if the primary data retrieval fails, it falls back to HTML parsing and still tries to extract the same core data. The result includes `error` and a `message` when something goes wrong, so your pipeline can handle failures cleanly.

#### Real-time dataset writing for long lists

As it processes each input URL, it pushes results live to the dataset. That means you can stop, resume, or export partial progress while still keeping the run stable for larger batches of download Instagram photos tasks.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "startUrls": [
    { "url": "https://www.instagram.com/p/CaHpoweBjmx" }
  ]
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `startUrls` | ✅ | A list of Instagram URLs to scrape (Posts, Reels, or TV). You can provide each item as `{ "url": "..." }`. |
| `proxyConfiguration` | ⬜ | Proxy settings for the run (optional). |
| ↳ `proxy support` | ⬜ | When enabled, the actor will route requests using Apify Proxy for better reliability. |
| ↳ `proxy support` | ⬜ | Proxy group selection when using Apify Proxy (passed through from input). |
| `sleepMin` | ⬜ | Minimum delay (in seconds) between processing input URLs. |
| `sleepMax` | ⬜ | Maximum delay (in seconds) between processing input URLs. |

***

### Core Capabilities

#### Bulk media scraping from Instagram URLs

Instagram Photos Downloader accepts a list of Instagram URLs and processes them one by one with pacing, producing structured output for each URL. It’s built for workflows like download Instagram photos, Instagram image downloader use cases, and Instagram media downloader tasks that start from a list of links.

#### Carousel-friendly media extraction

For galleries/carousels, results include a `medias` array containing each media item’s URL, type, and dimensions. That’s ideal when you need an Instagram carousel downloader style output—everything stays grouped under the same post record.

#### Download-ready media details

Each item inside `medias` includes the direct `url`, `type` (`image` or `video`), `extension` (`jpg` or `mp4`), `width`, `height`, and a `resolution` string. This makes an Instagram photos download online workflow easier to build on top of the dataset.

#### Reliability-oriented request handling

The actor includes a fallback parsing path and returns clear error info per URL. If you’re building a best Instagram photo downloader pipeline, this helps keep long runs from failing silently.

#### Live dataset writing for ongoing export

Results are appended to your Apify dataset as each URL is processed. That supports real-world “scrape now, export now” workflows for Instagram photos saving app-style projects and research tasks.

Overall, Instagram Photos Downloader gives you consistent, media-complete records suitable for analysis and automation.

***

### Who Gets the Most Out of This

Here’s how different teams put Instagram Photos Downloader to work:

**Influencer marketing teams** — they feed campaigns’ creator posts and reels into the actor to build a media inventory with `owner`, `like_count`, `view_count`, and a `medias` breakdown for quick visual sourcing. You can then export the dataset for campaign reviews or creative audits without manually opening every link.

**Growth teams and content researchers** — they use the caption `title`, media type (`image`, `video`, or `multiple`), and `thumbnail` to organize content themes and engagement performance across a set of Instagram posts. This is especially useful for Instagram reel to photo downloader-style workflows where you want a consistent output structure.

**Lead-gen and ops researchers** — they use structured owner and media metadata as input to downstream enrichment and documentation workflows, saving time compared to manual collection. When posts come in batches, the dataset-ready format makes it easier to keep records consistent.

**Developers and automation specialists** — they trigger the actor with `startUrls`, store the dataset output, and integrate it into an internal pipeline that expects stable JSON fields like `medias`, `type`, and `error`. For Instagram post downloader automation, the per-URL record model keeps processing logic straightforward.

**Marketers running creative audits** — they extract media dimensions and formats (`jpg` for images, `mp4` for videos) to understand what types of creatives dominate across targets. That helps guide what to reuse, remix, or standardize for future campaigns using an Instagram image downloader workflow.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Instagram Photos Downloader from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open the actor page for Instagram Photos Downloader.
2. **Enter your inputs** — in the `startUrls` field, paste one or more Instagram URLs (Posts, Reels, or TV). You can use the `{ "url": "..." }` format.
3. **Configure proxy settings** — if you want added reliability, enable `proxyConfiguration` and set `proxy support` accordingly.
4. **Hit Run and watch the live log** — track progress as each URL is processed and results are pushed to the dataset.
5. **View results in the dataset tab** — each input URL produces one record with fields like `owner`, `like_count`, `view_count`, and `medias`.
6. **Export as JSON, CSV, or Excel** — download directly from the Apify dashboard for reporting, analysis, or content planning.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Instagram Photos Downloader plugs directly into your existing workflow.

Export formats are available straight from the Apify dataset tab, including JSON, CSV, and Excel. This makes it easy to share results with non-technical teammates using an Instagram photo saving app workflow or to move data into analysis tools.

You can also access results via the Apify API (visit [apify.com/docs/api](https://apify.com/docs/api)) and connect it to automation platforms such as Zapier/Make for pushing exports downstream. Webhooks can trigger follow-up actions after the run completes, enabling scheduled jobs and batch pipelines for download Instagram pictures and media cataloging.

***

### Pricing & Free Trial

Instagram Photos Downloader runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

You pay using Apify’s usage model (compute units/CU) as the actor runs. For up-to-date plan details and exact pricing, check the Apify pricing page in your dashboard—start free first, then scale when your list grows.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Scraping resilience | Fallback handling when the primary request path fails |
| Dataset freshness | Results are pushed live as each URL is processed |
| Rate pacing | Uses a configurable sleep interval between items (`sleepMin` / `sleepMax`) |
| Failure visibility | Each record includes `error` and a `message` when available |
| Proxy support | Built-in proxy support for more reliable requests |
| Batch workflows | Works well for multi-URL lists in one run |

**Limitations:** Private or login-gated content can’t be accessed, and availability depends on what’s publicly visible for each Instagram URL. If a URL can’t be parsed into a valid shortcode/media, the actor returns an error for that specific input.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify offers a free tier on the platform, which is enough for trying Instagram Photos Downloader on smaller test lists. You can start quickly and scale once you confirm the output format works for your Instagram photo downloader workflow.

#### Do I need to log in to Instagram to use this?

No. Instagram Photos Downloader scrapes publicly available content from the Instagram URLs you provide. You only need to supply `startUrls` (and optionally proxy settings) to run.

#### How accurate is the data?

The actor returns structured fields based on what’s available from publicly accessible media pages. Accuracy depends on what the post/reel/gallery exposes publicly, and results include `error` plus a `message` when extraction fails.

#### How many results can I get per run?

You can provide as many items as you want via the `startUrls` array, and the actor will process them sequentially with delays. The practical limit is determined by your Apify run constraints (plan and compute availability), not by an output cap inside the actor.

#### How often is the data updated / how fresh is it?

Freshness is as current as the moment the run is executed. Each run scrapes the Instagram URL set you pass in and produces a new dataset export—so view and like counts reflect the time of scraping.

#### Is this legal? Does it comply with GDPR / CCPA?

You should treat it as publicly available data processing. Instagram Photos Downloader accesses **publicly available data** and does not attempt to bypass access controls; compliance with GDPR, CCPA, and platform rules is your responsibility based on your use case and storage practices.

#### Can I export results to Google Sheets or Excel?

Yes. You can export your Apify dataset from the dashboard as JSON, CSV, or Excel. From there, you can import into Google Sheets or other tools that accept CSV/Excel.

#### Can I run this on a schedule automatically?

Yes. You can schedule actor runs via Apify’s capabilities so the actor executes automatically at set intervals. This is useful for recurring Instagram post downloader tasks like periodic media catalog updates.

#### Can I access this via API?

Yes. You can trigger and retrieve results programmatically using the Apify API. This is ideal if you want Instagram photos download online data to feed into your own backend pipeline.

#### What happens if the actor hits an error?

Errors are handled per URL and the output includes `error: true` along with a `message` when an exception occurs. Since results are written live to the dataset, you still keep successful records even if some inputs fail.

***

### Need Help or Have a Request?

Got a question about Instagram Photos Downloader or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like webhook notifications on completion and batch CSV upload improvements. We actively maintain this actor based on user feedback.

***

### Disclaimer & Responsible Use

*Instagram Photos Downloader is the fastest, most reliable way to turn Instagram URLs into structured, media-complete records — start your free run today.*

This actor collects **publicly available data** from Instagram. It does not access private accounts, login-gated content, or password-protected pages. You’re responsible for complying with GDPR, CCPA, platform Terms of Service, and any applicable local regulations. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

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

List of Instagram URLs to scrape (Posts, Reels, or TV).

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.instagram.com/p/CaHpoweBjmx"
    }
  ]
}
```

# 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": [
        {
            "url": "https://www.instagram.com/p/CaHpoweBjmx"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/instagram-photos-downloader").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": [{ "url": "https://www.instagram.com/p/CaHpoweBjmx" }] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/instagram-photos-downloader").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": [
    {
      "url": "https://www.instagram.com/p/CaHpoweBjmx"
    }
  ]
}' |
apify call scraperoka/instagram-photos-downloader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Instagram Photos Downloader",
        "description": "📸 Instagram Photos Downloader lets you save photos & videos fast with a smooth, user-friendly experience. 🚀 Download content effortlessly for sharing, backup, or inspiration. 🔒 Simple, efficient, and made for creators.",
        "version": "1.0",
        "x-build-id": "eqD8GaRdSUMX1cbnQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~instagram-photos-downloader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-instagram-photos-downloader",
                "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/scraperoka~instagram-photos-downloader/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-instagram-photos-downloader",
                "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/scraperoka~instagram-photos-downloader/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-instagram-photos-downloader",
                "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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Instagram Post URLs",
                        "type": "array",
                        "description": "List of Instagram URLs to scrape (Posts, Reels, or TV).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
