# Bulk Image Compressor (`maximedupre/bulk-image-compressor`) Actor

Compress image files in bulk from URLs or uploaded images. Choose output format, quality, resize, target size, and metadata stripping, then get optimized download URLs with size savings for each successful image.

- **URL**: https://apify.com/maximedupre/bulk-image-compressor.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Marketing, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 image processeds

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

### 🖼️ Bulk image compressor for web-ready files

Bulk Image Compressor helps developers, marketers, creators, and ecommerce teams compress image files in one Apify run. Give it image URLs or an uploaded image file, choose output format and optimization options, and get one dataset row for each successfully processed image with a downloadable optimized file and size-savings data.

- [Compress images in bulk](https://apify.com/maximedupre/bulk-image-compressor/examples/compress-images-in-bulk) before publishing them on websites, landing pages, CMS pages, or product catalogs.
- [Convert and optimize common web image formats](https://apify.com/maximedupre/bulk-image-compressor/examples/convert-and-optimize-web-image-formats) such as original format, JPEG, PNG, WebP, and supported AVIF outputs when available.
- [Resize large images](https://apify.com/maximedupre/bulk-image-compressor/examples/resize-large-images) by maximum width or height while preserving their aspect ratio.
- [Strip image metadata](https://apify.com/maximedupre/bulk-image-compressor/examples/strip-image-metadata) to reduce file size and remove embedded private data from optimized outputs.
- [Track original size, optimized size, savings percentage, dimensions, filenames, and output download URLs](https://apify.com/maximedupre/bulk-image-compressor/examples/track-image-size-savings) for each successful image.

#### 📦 What you get

This actor focuses on the practical `compress image` job: turn user-supplied images into smaller, downloadable optimized files. It combines compression, optional resizing, output format choice, quality tuning, metadata stripping, and per-image reporting without requiring a source account or external API credentials.

Each accepted output row represents a successful processed image. Failed downloads, unsupported files, empty runs, and no-result outcomes are not described as successful image results.

#### ▶️ How to run

1. Add one or more image URLs in **Image URLs**, or provide an uploaded/stored image in **Image file**.
2. Choose the **Output format** you want, or keep the original format behavior when that fits your workflow.
3. Set **Quality** for lossy formats when you need a smaller file or higher visual quality.
4. Optionally set **Max width**, **Max height**, **Target size KB**, and **Strip metadata**.
5. Run the actor and download optimized files from the dataset rows.

#### ⚙️ Input options

| Input | What it does |
| --- | --- |
| `imageUrls` | List of user-supplied image URLs to process. |
| `imageFile` | Uploaded or stored image file reference to process. |
| `outputFormat` | Desired optimized output format. |
| `quality` | Quality level for lossy output formats. |
| `stripMetadata` | Removes image metadata from the optimized output when enabled. |
| `targetSizeKb` | Optional target size in KB for suitable compression workflows. |
| `maxWidth` | Maximum output width in pixels. |
| `maxHeight` | Maximum output height in pixels. |

#### 📊 Output data

The dataset is designed for direct use in scripts, dashboards, exports, or downstream automation. Rows include source and output evidence, file size facts, savings, dimensions, metadata status, and processing timing when available.

Common fields include:

- `sourceReference` and `outputUrl`
- `originalFilename` and `outputFilename`
- `originalFormat` and `outputFormat`
- `originalSizeBytes` and `optimizedSizeBytes`
- `savingsPercent`
- `originalWidth`, `originalHeight`, `outputWidth`, and `outputHeight`
- `metadataStripped`
- `durationMs`

#### 🧾 Output example

```json
{
  "id": "img_001",
  "sourceReference": "https://example.com/images/product-photo.png",
  "originalFilename": "product-photo.png",
  "outputFilename": "product-photo.webp",
  "outputUrl": "https://api.apify.com/v2/key-value-stores/example/records/product-photo.webp",
  "originalFormat": "png",
  "outputFormat": "webp",
  "originalSizeBytes": 842144,
  "optimizedSizeBytes": 214980,
  "savingsPercent": 74.47,
  "originalWidth": 1600,
  "originalHeight": 1200,
  "outputWidth": 1200,
  "outputHeight": 900,
  "metadataStripped": true,
  "durationMs": 438
}
````

#### 💳 Pricing

This actor uses pay-per-event pricing. You are charged only for each successful user-visible optimized image result saved to the dataset. Empty runs, invalid images, failed downloads, unsupported formats, setup checks, and no-result outcomes are not charged as processed images.

#### 🔌 Integrations

https://www.youtube.com/watch?v=bNACk1\_S\_6w\&list=PLObrtcm1Kw6MUrlLNDbK9QRg8VDJg0gOW\&index=4

Use this actor with Apify integrations, API clients, webhooks, scheduled runs, and dataset exports. Send results to spreadsheets, BI tools, databases, or your own app after each run.

#### ❓ FAQ

##### 🖼️ Can I process many images in one run?

Yes. The actor is built for bulk image compression from user-supplied image targets, including image URL lists and uploaded or stored image inputs.

##### 🔗 Do I need an account on the image source website?

No. The actor works with direct image targets supplied by you and does not require source-site credentials or an external image-compression API key.

##### 📉 Am I charged for failed images?

No. Pricing is tied to a successful processed image result. Empty runs, invalid images, failed downloads, unsupported formats, and no-result outcomes are not charged as processed images.

##### 🧩 What formats can I use?

The workflow is centered on common web image formats, including original-format output, JPEG, PNG, WebP, and supported AVIF output when available. The actual output row reports the detected original format and the optimized output format.

##### 📏 Can this compress images to a target size such as 100 KB?

Use `targetSizeKb` when you need a target file size for suitable lossy output formats. Exact final size can depend on the source image, chosen format, dimensions, and quality settings, so the dataset reports the measured optimized size.

##### 🧹 Does it remove image metadata?

Yes, enable `stripMetadata` to remove metadata from the optimized output when the processing path supports it. The dataset includes `metadataStripped` so you can audit the result.

##### 📐 Can I resize images while compressing them?

Yes. Set `maxWidth` and/or `maxHeight` to constrain output dimensions while preserving the image aspect ratio.

##### 📥 Where do optimized images go?

Each successful row includes an `outputUrl` for the optimized image file generated by the actor, so you can download it or pass it to another workflow.

##### 🔄 Is this a full image converter or PDF/Base64 tool?

No. This actor focuses on bulk image compression, web image format output, resizing, metadata stripping, and downloadable optimized files. PDF export and Base64 conversion are not core workflow goals.

### 📝 Changelog

- 0.1.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~bulk-image-compressor/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Ahrefs Free Website Stats Scraper ↗](https://apify.com/maximedupre/ahrefs-free-website-stats-scraper) - Use it for related bulk workflows.
- [Email MX Verifier ↗](https://apify.com/maximedupre/email-mx-verifier) - Use it for related bulk workflows.
- [Gmail Username Checker ↗](https://apify.com/maximedupre/gmail-username-checker) - Use it for related bulk workflows.
- [Image Resizer API ↗](https://apify.com/maximedupre/image-resizer-api) - Use it for related compress workflows.
- [Password Generator ↗](https://apify.com/maximedupre/password-generator) - Use it for related bulk workflows.
  **Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `imageUrls` (type: `array`):

Add public image URLs to compress in this run.

## `imageFile` (type: `string`):

Upload an image file to compress when your image is not available from a URL.

## `outputFormat` (type: `string`):

Choose the optimized file format. Keep original format preserves each image format when possible.

## `quality` (type: `integer`):

Set lossy compression quality for JPEG and WebP outputs. Higher values keep more detail and usually create larger files.

## `stripMetadata` (type: `boolean`):

Remove image metadata to reduce file size and avoid carrying private camera or location details into the optimized file.

## `targetSizeKb` (type: `integer`):

Optionally ask the Actor to aim for a maximum output size for lossy formats. Leave empty to use quality-based compression only.

## `maxWidth` (type: `integer`):

Optionally resize images wider than this pixel width while preserving aspect ratio.

## `maxHeight` (type: `integer`):

Optionally resize images taller than this pixel height while preserving aspect ratio.

## Actor input object example

```json
{
  "imageUrls": [
    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGAAAABACAIAAABqVuVZAAAACXBIWXMAAAPoAAAD6AG1e1JrAAAAwUlEQVR4nO3ZwQ3CUBDE0JT2S6NQF8MdiVwQmhyelAosj9mE67zynO8QLnTOrSIABVC/rIRBARSD+t9PjYkFUAzKxFodtBoUQDEoE0uDeuZ3BZEOoBiUiaVBzXss0gEUgzKx5t1xKAZQDMrEmgfIy2oAxaBMLA1qHmORDqAYlIk1j45DMYBiUCbWQx7/rAZQDMrE0qDmPRbpAIpBmVjz7jgUAygGZWLNA+RlNYBiUCaWBjWPsUgHUAzKxJpH5+NQfANuGaI7B6QfugAAAABJRU5ErkJggg=="
  ],
  "outputFormat": "webp",
  "quality": 85,
  "stripMetadata": true
}
```

# Actor output Schema

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

Open the default dataset rows for successfully processed images.

# 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 = {
    "imageUrls": [
        "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGAAAABACAIAAABqVuVZAAAACXBIWXMAAAPoAAAD6AG1e1JrAAAAwUlEQVR4nO3ZwQ3CUBDE0JT2S6NQF8MdiVwQmhyelAosj9mE67zynO8QLnTOrSIABVC/rIRBARSD+t9PjYkFUAzKxFodtBoUQDEoE0uDeuZ3BZEOoBiUiaVBzXss0gEUgzKx5t1xKAZQDMrEmgfIy2oAxaBMLA1qHmORDqAYlIk1j45DMYBiUCbWQx7/rAZQDMrE0qDmPRbpAIpBmVjz7jgUAygGZWLNA+RlNYBiUCaWBjWPsUgHUAzKxJpH5+NQfANuGaI7B6QfugAAAABJRU5ErkJggg=="
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/bulk-image-compressor").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 = { "imageUrls": ["data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGAAAABACAIAAABqVuVZAAAACXBIWXMAAAPoAAAD6AG1e1JrAAAAwUlEQVR4nO3ZwQ3CUBDE0JT2S6NQF8MdiVwQmhyelAosj9mE67zynO8QLnTOrSIABVC/rIRBARSD+t9PjYkFUAzKxFodtBoUQDEoE0uDeuZ3BZEOoBiUiaVBzXss0gEUgzKx5t1xKAZQDMrEmgfIy2oAxaBMLA1qHmORDqAYlIk1j45DMYBiUCbWQx7/rAZQDMrE0qDmPRbpAIpBmVjz7jgUAygGZWLNA+RlNYBiUCaWBjWPsUgHUAzKxJpH5+NQfANuGaI7B6QfugAAAABJRU5ErkJggg=="] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/bulk-image-compressor").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 '{
  "imageUrls": [
    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGAAAABACAIAAABqVuVZAAAACXBIWXMAAAPoAAAD6AG1e1JrAAAAwUlEQVR4nO3ZwQ3CUBDE0JT2S6NQF8MdiVwQmhyelAosj9mE67zynO8QLnTOrSIABVC/rIRBARSD+t9PjYkFUAzKxFodtBoUQDEoE0uDeuZ3BZEOoBiUiaVBzXss0gEUgzKx5t1xKAZQDMrEmgfIy2oAxaBMLA1qHmORDqAYlIk1j45DMYBiUCbWQx7/rAZQDMrE0qDmPRbpAIpBmVjz7jgUAygGZWLNA+RlNYBiUCaWBjWPsUgHUAzKxJpH5+NQfANuGaI7B6QfugAAAABJRU5ErkJggg=="
  ]
}' |
apify call maximedupre/bulk-image-compressor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/bulk-image-compressor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bulk Image Compressor",
        "description": "Compress image files in bulk from URLs or uploaded images. Choose output format, quality, resize, target size, and metadata stripping, then get optimized download URLs with size savings for each successful image.",
        "version": "0.1",
        "x-build-id": "7i5zuBr2VJAb61IeY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~bulk-image-compressor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-bulk-image-compressor",
                "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/maximedupre~bulk-image-compressor/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-bulk-image-compressor",
                "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/maximedupre~bulk-image-compressor/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-bulk-image-compressor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "imageUrls": {
                        "title": "Image URLs",
                        "type": "array",
                        "description": "Add public image URLs to compress in this run.",
                        "default": [
                            "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGAAAABACAIAAABqVuVZAAAACXBIWXMAAAPoAAAD6AG1e1JrAAAAwUlEQVR4nO3ZwQ3CUBDE0JT2S6NQF8MdiVwQmhyelAosj9mE67zynO8QLnTOrSIABVC/rIRBARSD+t9PjYkFUAzKxFodtBoUQDEoE0uDeuZ3BZEOoBiUiaVBzXss0gEUgzKx5t1xKAZQDMrEmgfIy2oAxaBMLA1qHmORDqAYlIk1j45DMYBiUCbWQx7/rAZQDMrE0qDmPRbpAIpBmVjz7jgUAygGZWLNA+RlNYBiUCaWBjWPsUgHUAzKxJpH5+NQfANuGaI7B6QfugAAAABJRU5ErkJggg=="
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "imageFile": {
                        "title": "Image file",
                        "type": "string",
                        "description": "Upload an image file to compress when your image is not available from a URL."
                    },
                    "outputFormat": {
                        "title": "Output format",
                        "enum": [
                            "original",
                            "jpeg",
                            "png",
                            "webp"
                        ],
                        "type": "string",
                        "description": "Choose the optimized file format. Keep original format preserves each image format when possible.",
                        "default": "webp"
                    },
                    "quality": {
                        "title": "Quality",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Set lossy compression quality for JPEG and WebP outputs. Higher values keep more detail and usually create larger files.",
                        "default": 85
                    },
                    "stripMetadata": {
                        "title": "Strip metadata",
                        "type": "boolean",
                        "description": "Remove image metadata to reduce file size and avoid carrying private camera or location details into the optimized file.",
                        "default": true
                    },
                    "targetSizeKb": {
                        "title": "Target size KB",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optionally ask the Actor to aim for a maximum output size for lossy formats. Leave empty to use quality-based compression only."
                    },
                    "maxWidth": {
                        "title": "Max width",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optionally resize images wider than this pixel width while preserving aspect ratio."
                    },
                    "maxHeight": {
                        "title": "Max height",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optionally resize images taller than this pixel height while preserving aspect ratio."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```