# Image Resizer API (`maximedupre/image-resizer-api`) Actor

Resize, compress, and convert images with an image resizer API. Process URLs, base64 data, or Apify uploads, then export generated file URLs, dimensions, formats, byte sizes, and compression facts.

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

## Pricing

$0.90 / 1,000 processed images

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

### 🖼️ Image resizer API for batch image resizing

Image Resizer API resizes, compresses, and converts images from URLs, base64 data, or Apify key-value-store uploads. Use it when you need repeatable image processing for product photos, thumbnails, social assets, WhatsApp catalog images, or an API workflow that returns generated file URLs plus measured image facts.

- [`image resizer`](https://apify.com/maximedupre/image-resizer-api/examples/batch-image-resizing) - resize batches of source images to custom dimensions or preset sizes.
- [`compress image`](https://apify.com/maximedupre/image-resizer-api/examples/compress-image) - lower file sizes for JPEG, WebP, and AVIF outputs with quality and size-limit controls.
- [`resize image online`](https://apify.com/maximedupre/image-resizer-api/examples/resize-image-online) - run image resizing from Apify Console, API calls, schedules, or integrations.
- [`image resizer free`](https://apify.com/maximedupre/image-resizer-api/examples/image-resizer-free) - test the shape with a small batch before adding larger image lists.
- [`resize image to 100kb`](https://apify.com/maximedupre/image-resizer-api/examples/resize-image-to-100kb) - set an optional file-size target and check whether each generated file fits it.

#### ✅ What this Actor does

- Accepts image URLs, base64 image data, and Apify key-value-store file keys.
- Saves one dataset row per successfully generated image.
- Saves generated files to Apify key-value storage and returns direct `output.url` links.
- Supports custom width and height up to 10000 pixels.
- Supports presets for e-commerce squares, website thumbnails, social squares, and WhatsApp carousel, catalog, and template images.
- Supports `cover`, `contain`, `fill`, `inside`, and `outside` resize behavior.
- Supports center, edge, and corner crop positions.
- Supports solid, blurred, and edge-extended padding for contained layouts.
- Converts images to WebP, JPEG, PNG, AVIF, GIF, TIFF, or the source format when supported.
- Strips metadata by default, with an option to preserve it.
- Skips failed image attempts from the dataset and keeps processing the rest of the batch when possible.

This Actor is a mechanical image processor. It does not generate new images with AI, add watermarks, discover images from web pages, edit private files, or require a third-party image-processing API key.

#### 📦 Data you can export

Each output row represents one successfully generated image. Fields include:

- `id` - your optional image ID for matching output rows to input images.
- `source` - the submitted source type, URL, key-value-store key, and filename when available.
- `original` - source width, height, format, content type, and byte size.
- `output` - generated file URL, key, width, height, format, content type, and byte size.
- `compressionRatio` - byte-size reduction from source to output when it can be calculated.
- `metadataPreserved` - whether EXIF and other metadata were kept.
- `fileSizeLimitMb` - the applied size limit when you request one or use a preset with a limit.
- `fileSizeWithinLimit` - whether the generated file fits the applied size limit.

Open the dataset for rows you can export as JSON, CSV, Excel, XML, RSS, or HTML. Open the key-value store when you want to browse or download the generated image files directly.

#### 🚀 How to run

1. Add one or more image sources in **Images**.
2. Choose **Target size**, or leave it on **Custom size** and set **Custom width** and **Custom height**.
3. Pick **Resize fit**, **Padding style**, and **Output format**.
4. Set **Quality** or **Maximum file size** when you need smaller output files.
5. Start the Actor.
6. Open the dataset for output rows, or open the key-value store for generated files.

For a quick first run, keep the prefilled sample image, leave **Target size** on **Custom size**, and use the default WebP output.

#### ⚙️ Input

```json
{
	"images": [
		{
			"url": "https://placehold.co/1200x800.jpg",
			"id": "sample-image"
		}
	],
	"targetPreset": "website_thumbnail",
	"fit": "contain",
	"paddingMode": "edge_extend",
	"outputFormat": "webp",
	"quality": 80
}
````

Use `url` for public HTTP or HTTPS image files, `base64` for image bytes, or `keyValueStoreKey` for an uploaded image in the run key-value store. Add `id` or `filename` when you want stable matching in the output.

Enable `combineImages` only when you provide 2 or 3 source images and want one combined output image.

#### 📄 Output example

```json
{
	"id": "sample-image",
	"source": {
		"type": "url",
		"url": "https://placehold.co/1200x800.jpg",
		"keyValueStoreKey": null,
		"filename": "1200x800.jpg"
	},
	"original": {
		"width": 1200,
		"height": 800,
		"format": "jpeg",
		"contentType": "image/jpeg",
		"sizeBytes": 384212
	},
	"output": {
		"url": "https://api.apify.com/v2/key-value-stores/abc123/records/sample-image-website_thumbnail.webp",
		"key": "sample-image-website_thumbnail.webp",
		"width": 800,
		"height": 800,
		"format": "webp",
		"contentType": "image/webp",
		"sizeBytes": 72104
	},
	"compressionRatio": 0.8124,
	"metadataPreserved": false,
	"fileSizeLimitMb": null,
	"fileSizeWithinLimit": null
}
```

#### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each image that is successfully processed and saved with a downloadable output URL.

The local pricing event is `image-processed` at `$0.0009` per successful processed image. Failed image attempts, skipped inputs, invalid image sources, and runs that do not save generated images do not create processed-image events.

#### 🔌 Integrations

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

- Call the Actor through the Apify API when your app needs repeatable image resizing from URLs, base64 data, or uploaded files.
- Schedule recurring runs for product catalogs, campaign assets, or image batches that need the same output settings.
- Export dataset rows to JSON, CSV, Excel, XML, RSS, or HTML for review and reporting.
- Use webhooks to send generated output URLs and metadata to downstream storage, CMS, or automation tools.

#### ❓ FAQ

**Can I use this as an image resize API for many images?**

Yes. Add up to 100 image sources in one run. Each successful image creates one generated file and one dataset row.

**Can it compress image files as well as resize them?**

Yes. Use JPEG, WebP, or AVIF output with the `quality` setting, and optionally set `maxFileSizeMb`. The output row reports the byte sizes, compression ratio, and file-size-limit result.

**Can I resize image online without hosting files myself?**

Yes. You can paste public image URLs, pass base64 image data, or upload images to Apify key-value storage and pass their keys. Generated files are saved in the run key-value store.

**How does it compare with image resize API and cloud image processing API options?**

It covers the common API workflow: submit image sources and settings, then read generated file URLs and metadata from Apify storage and the dataset. It does not require an external cloud image-processing account or API key.

**Why not use the image source API?**

Most image sources do not offer a single API for resizing, conversion, compression, and Apify dataset exports. This Actor processes the image bytes you provide and returns generated files plus structured metadata in one Apify run.

**What are image resizer API alternatives?**

Alternatives include hosted image CDNs, command-line tools such as Sharp-based scripts, online resize forms, or custom backend jobs. This Actor is useful when you want Apify runs, API calls, schedules, webhooks, exports, and generated file storage in one workflow.

**What happens when one image fails?**

The Actor skips that image, logs a warning, and continues with the rest of the batch. Failed images are not saved as dataset rows and are not charged as processed images.

### 📝 Changelog

- 1.0: Initial release.

### 🆘 Support

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

### 🔗 Other actors

- [Watermark Image API ↗](https://apify.com/maximedupre/watermark-image-api) - Add text or logo watermarks to image URLs, uploads, KV files, or base64 data.
- [Web Images Scraper ↗](https://apify.com/maximedupre/web-images-scraper) - Extract image URLs and optional saved files from public webpages.
- [Unsplash Image Scraper ↗](https://apify.com/maximedupre/unsplash-image-scraper) - Collect Unsplash image search results for design and content research.
- [Craiyon AI Image Creator ↗](https://apify.com/maximedupre/craiyon-ai-image-creator) - Generate prompt-based images and save Apify download links.
- [Font Detector ↗](https://apify.com/maximedupre/font-detector) - Detect fonts and font files from public web pages.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `images` (type: `array`):

Use url, base64, or keyValueStoreKey for each image. Add id or filename when you want stable tracking in the output.

## `combineImages` (type: `boolean`):

Create one combined image from 2 or 3 sources for catalog cards, comparisons, or product angles.

## `targetPreset` (type: `string`):

Choose Custom to use width and height, or pick a ready-made platform size.

## `width` (type: `integer`):

Output width in pixels when Target size is Custom.

## `height` (type: `integer`):

Output height in pixels when Target size is Custom.

## `fit` (type: `string`):

Choose how each image fills, fits inside, or stretches to the target size.

## `position` (type: `string`):

Anchor the image when Resize fit crops or pads the source.

## `paddingMode` (type: `string`):

Fill extra space for padded layouts with a solid color, blurred image, or extended edge pixels.

## `backgroundColor` (type: `string`):

Hex color for solid padding and transparent areas.

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

Choose the generated image file format.

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

Quality for lossy formats such as JPEG, WebP, and AVIF.

## `maxFileSizeMb` (type: `number`):

Optional size limit in MB for platform-ready files.

## `preserveMetadata` (type: `boolean`):

Keep EXIF and other metadata in generated files.

## Actor input object example

```json
{
  "images": [
    {
      "url": "https://placehold.co/1200x800.jpg?text=sample-1",
      "id": "sample-image-1"
    },
    {
      "url": "https://placehold.co/1280x840.jpg?text=sample-2",
      "id": "sample-image-2"
    },
    {
      "url": "https://placehold.co/1360x880.jpg?text=sample-3",
      "id": "sample-image-3"
    },
    {
      "url": "https://placehold.co/1440x920.jpg?text=sample-4",
      "id": "sample-image-4"
    },
    {
      "url": "https://placehold.co/1520x960.jpg?text=sample-5",
      "id": "sample-image-5"
    }
  ],
  "combineImages": false,
  "targetPreset": "custom",
  "width": 800,
  "height": 600,
  "fit": "cover",
  "position": "center",
  "paddingMode": "solid",
  "backgroundColor": "#FFFFFF",
  "outputFormat": "webp",
  "quality": 80,
  "preserveMetadata": false
}
```

# Actor output Schema

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

Open the dataset with one row per successfully generated image.

## `files` (type: `string`):

Open the run key-value store containing generated image files.

# 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 = {
    "images": [
        {
            "url": "https://placehold.co/1200x800.jpg?text=sample-1",
            "id": "sample-image-1"
        },
        {
            "url": "https://placehold.co/1280x840.jpg?text=sample-2",
            "id": "sample-image-2"
        },
        {
            "url": "https://placehold.co/1360x880.jpg?text=sample-3",
            "id": "sample-image-3"
        },
        {
            "url": "https://placehold.co/1440x920.jpg?text=sample-4",
            "id": "sample-image-4"
        },
        {
            "url": "https://placehold.co/1520x960.jpg?text=sample-5",
            "id": "sample-image-5"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/image-resizer-api").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 = { "images": [
        {
            "url": "https://placehold.co/1200x800.jpg?text=sample-1",
            "id": "sample-image-1",
        },
        {
            "url": "https://placehold.co/1280x840.jpg?text=sample-2",
            "id": "sample-image-2",
        },
        {
            "url": "https://placehold.co/1360x880.jpg?text=sample-3",
            "id": "sample-image-3",
        },
        {
            "url": "https://placehold.co/1440x920.jpg?text=sample-4",
            "id": "sample-image-4",
        },
        {
            "url": "https://placehold.co/1520x960.jpg?text=sample-5",
            "id": "sample-image-5",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/image-resizer-api").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 '{
  "images": [
    {
      "url": "https://placehold.co/1200x800.jpg?text=sample-1",
      "id": "sample-image-1"
    },
    {
      "url": "https://placehold.co/1280x840.jpg?text=sample-2",
      "id": "sample-image-2"
    },
    {
      "url": "https://placehold.co/1360x880.jpg?text=sample-3",
      "id": "sample-image-3"
    },
    {
      "url": "https://placehold.co/1440x920.jpg?text=sample-4",
      "id": "sample-image-4"
    },
    {
      "url": "https://placehold.co/1520x960.jpg?text=sample-5",
      "id": "sample-image-5"
    }
  ]
}' |
apify call maximedupre/image-resizer-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Image Resizer API",
        "description": "Resize, compress, and convert images with an image resizer API. Process URLs, base64 data, or Apify uploads, then export generated file URLs, dimensions, formats, byte sizes, and compression facts.",
        "version": "1.0",
        "x-build-id": "3UmWi4J5h6AcqPT3t"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~image-resizer-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-image-resizer-api",
                "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~image-resizer-api/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-image-resizer-api",
                "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~image-resizer-api/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-image-resizer-api",
                "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": [
                    "images"
                ],
                "properties": {
                    "images": {
                        "title": "Images",
                        "minItems": 1,
                        "maxItems": 100,
                        "type": "array",
                        "description": "Use url, base64, or keyValueStoreKey for each image. Add id or filename when you want stable tracking in the output.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "Image URL",
                                    "description": "Public HTTP or HTTPS image URL."
                                },
                                "base64": {
                                    "type": "string",
                                    "title": "Base64 image data",
                                    "description": "Base64-encoded image data."
                                },
                                "keyValueStoreKey": {
                                    "type": "string",
                                    "title": "Key-value store key",
                                    "description": "Apify key-value store record key for an uploaded image."
                                },
                                "id": {
                                    "type": "string",
                                    "title": "Image ID",
                                    "description": "Optional stable ID copied to the output."
                                },
                                "filename": {
                                    "type": "string",
                                    "title": "Output filename",
                                    "description": "Optional generated file name."
                                }
                            }
                        }
                    },
                    "combineImages": {
                        "title": "Combine images into one output",
                        "type": "boolean",
                        "description": "Create one combined image from 2 or 3 sources for catalog cards, comparisons, or product angles.",
                        "default": false
                    },
                    "targetPreset": {
                        "title": "Target size",
                        "enum": [
                            "custom",
                            "ecommerce_square",
                            "website_thumbnail",
                            "social_square",
                            "whatsapp_carousel",
                            "whatsapp_catalog_thumbnail",
                            "whatsapp_template_header"
                        ],
                        "type": "string",
                        "description": "Choose Custom to use width and height, or pick a ready-made platform size.",
                        "default": "custom"
                    },
                    "width": {
                        "title": "Custom width",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Output width in pixels when Target size is Custom.",
                        "default": 800
                    },
                    "height": {
                        "title": "Custom height",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Output height in pixels when Target size is Custom.",
                        "default": 600
                    },
                    "fit": {
                        "title": "Resize fit",
                        "enum": [
                            "cover",
                            "contain",
                            "fill",
                            "inside",
                            "outside"
                        ],
                        "type": "string",
                        "description": "Choose how each image fills, fits inside, or stretches to the target size.",
                        "default": "cover"
                    },
                    "position": {
                        "title": "Crop position",
                        "enum": [
                            "center",
                            "top",
                            "bottom",
                            "left",
                            "right",
                            "top-left",
                            "top-right",
                            "bottom-left",
                            "bottom-right"
                        ],
                        "type": "string",
                        "description": "Anchor the image when Resize fit crops or pads the source.",
                        "default": "center"
                    },
                    "paddingMode": {
                        "title": "Padding style",
                        "enum": [
                            "solid",
                            "blur",
                            "edge_extend"
                        ],
                        "type": "string",
                        "description": "Fill extra space for padded layouts with a solid color, blurred image, or extended edge pixels.",
                        "default": "solid"
                    },
                    "backgroundColor": {
                        "title": "Background color",
                        "pattern": "^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$",
                        "type": "string",
                        "description": "Hex color for solid padding and transparent areas.",
                        "default": "#FFFFFF"
                    },
                    "outputFormat": {
                        "title": "Output format",
                        "enum": [
                            "webp",
                            "jpeg",
                            "png",
                            "avif",
                            "gif",
                            "tiff",
                            "original"
                        ],
                        "type": "string",
                        "description": "Choose the generated image file format.",
                        "default": "webp"
                    },
                    "quality": {
                        "title": "Quality",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Quality for lossy formats such as JPEG, WebP, and AVIF.",
                        "default": 80
                    },
                    "maxFileSizeMb": {
                        "title": "Maximum file size",
                        "minimum": 0.1,
                        "maximum": 50,
                        "type": "number",
                        "description": "Optional size limit in MB for platform-ready files."
                    },
                    "preserveMetadata": {
                        "title": "Preserve image metadata",
                        "type": "boolean",
                        "description": "Keep EXIF and other metadata in generated files.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
