# QR Code Generator (`automation-lab/qr-code-generator`) Actor

Generate QR codes from URLs and text strings in bulk. Supports PNG and SVG formats with configurable sizes and error correction levels. Outputs data URIs and saves images to key-value store for direct download. Ideal for marketing campaigns and product labeling workflows.

- **URL**: https://apify.com/automation-lab/qr-code-generator.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools, Marketing, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## QR Code Generator

Generate QR codes from URLs and text in bulk. Export as PNG images or scalable SVG, save them to the Apify key-value store for easy download, and push structured results to a dataset — all in one automated run.

### What does it do?

QR Code Generator takes a list of URLs or text strings as input and converts each one into a QR code image. Each QR code is:

- **Saved to the key-value store** as a downloadable PNG or SVG file
- **Pushed to the dataset** as a structured record including the data URI (embeddable directly in HTML/CSS)
- Configurable in size (100–1000 px), error correction level (L/M/Q/H), and foreground/background color

The actor runs entirely server-side with no browser — it uses the well-established [`qrcode`](https://www.npmjs.com/package/qrcode) npm library (18M+ weekly downloads) for fast, reliable generation.

### Who is it for?

#### 📦 Product managers and marketers
Generate QR codes for product pages, landing pages, or campaign URLs in bulk. No need to open a browser tool for each one — submit a list and download all files at once.

#### 🛒 E-commerce teams
Create QR codes for product listings, invoice links, or loyalty program URLs automatically within your data pipeline.

#### 🏗 Developers and automation engineers
Integrate QR code generation into a Zapier workflow, Make scenario, or custom API pipeline. Use the dataset output (data URIs) to embed QR codes directly in HTML emails or web pages without separate image hosting.

#### 🖨 Print and signage production
Generate large batches of QR codes for menus, event tickets, packaging labels, or venue signage with custom sizes and error correction levels optimized for print.

#### 📊 Data teams and analysts
Automate QR code creation as part of a larger Apify workflow: scrape URLs from a website, pipe them here, and export the resulting QR codes — all without writing custom code.

### Why use this actor?

- **Bulk processing** — encode dozens or hundreds of items in a single run
- **Two export formats** — PNG for print/email, SVG for web (resolution-independent, infinitely scalable)
- **Data URI output** — embed QR codes directly in HTML without external image hosting: `<img src="data:image/png;base64,...">`
- **Key-value store download** — each QR code file is available via the Apify API as a downloadable binary file
- **Custom colors** — set dark/light module colors in hex to match your brand
- **Error correction control** — choose the recovery level appropriate for your use case (logos over QR? Use H)
- **No browser required** — fast, low-cost, pure server-side generation

### What data does it extract?

Each dataset item contains the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `input` | string | The original text/URL that was encoded |
| `format` | string | Output format: `png` or `svg` |
| `size` | integer | Image size in pixels (PNG only; SVG is always scalable) |
| `errorCorrectionLevel` | string | Error correction level used: L, M, Q, or H |
| `kvStoreKey` | string | Key in the Apify key-value store where the image file is saved |
| `qrCodeUrl` | string | Base64 data URI — embed directly in HTML: `<img src="...">` |
| `error` | string or null | Error message if generation failed; null on success |

### How much does it cost to generate QR codes in bulk?

QR Code Generator uses **pay-per-event pricing** — you only pay for what you use.

| Event | Price |
|-------|-------|
| Actor start | $0.01 (one-time per run) |
| Per QR code generated | $0.001 |

**Examples:**
- 10 QR codes: $0.01 + 10 × $0.001 = **$0.02**
- 100 QR codes: $0.01 + 100 × $0.001 = **$0.11**
- 500 QR codes: $0.01 + 500 × $0.001 = **$0.51**

The [Apify free plan](https://apify.com/pricing) includes $5 of free usage per month — enough for approximately **490 QR codes at no cost**.

There are no additional proxy or compute surcharges — QR generation is purely computational and requires no web requests.

### How to use QR Code Generator

#### Step 1 — Prepare your input list
Collect all the URLs or text strings you want to encode. These can be product page links, marketing URLs, text labels, Wi-Fi credentials (`WIFI:S:MyNetwork;T:WPA;P:password;;`), contact cards (vCard format), or any UTF-8 text.

#### Step 2 — Configure the actor
Open the actor in Apify Console and fill in:
- **URLs or text to encode** — paste your list (one item per line in the UI)
- **Output format** — choose PNG (default) or SVG
- **Size** — set 300px for standard use, 600px for print-quality output
- **Error correction level** — use M (default) for most cases; use H if you plan to overlay a logo on the QR code

#### Step 3 — Run the actor
Click **Run**. The actor processes all inputs, generates QR codes, and stores results.

#### Step 4 — Download your QR codes
- Go to the **Key-Value Store** tab in the run detail to download individual PNG/SVG files
- Go to the **Dataset** tab to view the structured output with data URIs
- Use the Apify API to retrieve files programmatically (see API section below)

#### Step 5 — Embed or use the QR codes
Use the `qrCodeUrl` field (a base64 data URI) to embed QR codes directly:
```html
<img src="data:image/png;base64,iVBORw0KGgo..." alt="QR Code" width="200" />
````

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `texts` | array of strings | Yes | — | URLs or text strings to encode as QR codes |
| `format` | string | No | `png` | Output format: `png` or `svg` |
| `size` | integer | No | `300` | Image width/height in pixels (PNG only). Range: 100–1000 |
| `errorCorrectionLevel` | string | No | `M` | Error correction: `L` (7%), `M` (15%), `Q` (25%), `H` (30%) |
| `darkColor` | string | No | `#000000` | Hex color for dark QR modules (PNG only) |
| `lightColor` | string | No | `#ffffff` | Hex color for QR background (PNG only) |

#### Error correction levels explained

| Level | Recovery | Use case |
|-------|----------|----------|
| L | 7% | Simple URLs, clean print environments |
| M | 15% | General purpose (recommended default) |
| Q | 25% | Environments with potential smudging or wear |
| H | 30% | When overlaying a logo or icon on the QR code |

Higher error correction = slightly larger/denser QR code but more robust scanning.

### Output example

```json
{
  "input": "https://apify.com",
  "format": "png",
  "size": 300,
  "errorCorrectionLevel": "M",
  "kvStoreKey": "qr-1-https-apify-com",
  "qrCodeUrl": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAASwAAAE...",
  "error": null
}
```

The `kvStoreKey` can be used to construct a direct download URL:

```
https://api.apify.com/v2/key-value-stores/{STORE_ID}/records/{KEY}
```

### Tips for best results

- **For print use** — set size to 600px or higher and use error correction level Q or H for durability
- **For web embedding** — SVG format is preferred as it scales without pixelation
- **For logos on QR codes** — always use error correction level H (30% recovery) so the QR still scans with a logo overlay
- **Wi-Fi QR codes** — use the format: `WIFI:S:NetworkName;T:WPA;P:YourPassword;;`
- **vCard QR codes** — use standard vCard 3.0 format for maximum scanner compatibility
- **Custom colors** — ensure sufficient contrast between dark and light colors; avoid light-on-light or dark-on-dark combinations
- **Large batches** — the actor processes items sequentially; runs of 100+ items may take a minute or two
- **Data URI embedding** — the `qrCodeUrl` field works directly in `<img src="...">` HTML attributes with no additional hosting required

### Integrations

#### Zapier — auto-generate QR codes for new form submissions

Use the Apify Zapier integration to trigger QR Code Generator whenever a new form response arrives in Typeform or Google Forms. Map the submission URL to the `texts` input, then send the generated `qrCodeUrl` back to the form platform or email it to the submitter.

#### Make (Integromat) — product page QR batch

In a Make scenario: pull product URLs from a Google Sheet → run QR Code Generator → write the `qrCodeUrl` data URIs back to the sheet. No external image storage needed.

#### Apify workflows — scrape-then-encode pipeline

Chain with another Apify actor: run a web scraper to collect landing page URLs, then pipe the results into QR Code Generator to produce QR codes for each scraped URL. Use the [Apify dataset-to-dataset chaining](https://docs.apify.com/platform/actors/running/input-and-output) pattern.

#### n8n — automated QR generation for CMS content

Use n8n's Apify node to call QR Code Generator whenever new content is published in your CMS (e.g., WordPress or Contentful). Store the resulting data URIs as custom fields on the content record.

#### Google Sheets + Apify API

Use `=IMAGE("data:image/png;base64,...")` in Google Sheets to display QR codes directly in cells by fetching the `qrCodeUrl` from the dataset via the Apify API.

### API usage

Run this actor programmatically using the Apify API. Replace `YOUR_API_TOKEN` with your token from [Apify Console settings](https://console.apify.com/settings/integrations).

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/qr-code-generator').call({
  texts: ['https://apify.com', 'https://example.com'],
  format: 'png',
  size: 300,
  errorCorrectionLevel: 'M',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
  console.log(`QR for ${item.input}: ${item.kvStoreKey}`);
}
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("automation-lab/qr-code-generator").call(
    run_input={
        "texts": ["https://apify.com", "https://example.com"],
        "format": "png",
        "size": 300,
        "errorCorrectionLevel": "M",
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"QR for {item['input']}: {item['kvStoreKey']}")
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~qr-code-generator/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "texts": ["https://apify.com", "https://example.com"],
    "format": "png",
    "size": 300,
    "errorCorrectionLevel": "M"
  }'
```

To retrieve results after the run completes:

```bash
## Get dataset items
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN"

## Download a specific QR code image
curl "https://api.apify.com/v2/key-value-stores/STORE_ID/records/qr-1-https-apify-com" \
  -o qr-code.png
```

### Use with Claude AI (MCP)

This actor is available as a tool in Claude AI through the Model Context Protocol (MCP). Add it to Claude Desktop, Cursor, Windsurf, or any MCP-compatible client.

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}
```

#### Example prompts

- "Generate QR codes for these 5 product URLs as 600px SVGs with high error correction for print: \[list]."
- "Create a QR code for my Wi-Fi network: SSID=HomeNetwork, password=secret123, encryption=WPA."
- "Generate a PNG QR code for https://example.com at 300px and give me the base64 data URI to embed in HTML."

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Legal and terms of use

QR Code generation is a purely computational process — this actor does not scrape any website or access any third-party service. All processing happens locally within the Apify actor environment.

- No third-party APIs are called
- No web requests are made during QR code generation
- Input data is processed in-memory and not stored beyond the actor run
- Generated QR codes and their data remain in your Apify account's storage

The actor is subject to [Apify's Terms of Service](https://apify.com/terms-of-use). Users are responsible for ensuring that content encoded into QR codes complies with applicable laws and platform policies.

### FAQ

**Q: What text/URL length is supported?**
A: The `qrcode` library supports QR codes up to approximately 7,089 numeric characters or 4,296 alphanumeric characters depending on the error correction level. For longer URLs, higher error correction levels reduce the maximum payload capacity.

**Q: Can I use custom colors for my brand?**
A: Yes — use the `darkColor` and `lightColor` fields with hex color codes. This applies to PNG output only; SVG output uses the `qrcode` library's default colors. Ensure sufficient contrast (at least 3:1 ratio) for reliable scanning.

**Q: Why does my QR code not scan reliably when printed?**
A: Increase the error correction level to Q or H, and make sure the printed size is at least 2cm × 2cm. Also ensure the printer output has good contrast — avoid printing on colored or textured paper without adjusting colors.

**Q: How do I embed the QR code in an HTML email?**
A: Use the `qrCodeUrl` field directly as the `src` of an `<img>` tag. Most email clients (Gmail, Outlook, Apple Mail) support base64 data URIs in image tags. Example: `<img src="data:image/png;base64,..." width="200" height="200" />`.

**Q: The actor returned `error: null` but the KV store file is missing. What happened?**
A: This should not occur in normal operation. If it does, check that the actor run completed successfully (status SUCCEEDED) and that the key-value store was not purged. Purging local storage before a run is expected behavior in development — on Apify cloud, storage persists after the run.

**Q: Can I generate QR codes with a logo in the middle?**
A: This actor does not overlay logos. However, you can download the PNG output and overlay a logo using an image editing tool or another automation step. When doing so, always use error correction level H (30%) so the QR code remains scannable after the logo covers part of it.

**Q: The SVG output `size` field shows 0 — is that correct?**
A: Yes. SVG is a vector format and has no fixed pixel size — it scales to any dimension. The `size` field is only meaningful for PNG output. The actor sets `size: 0` for SVG to indicate this.

### Related tools from automation-lab

- [Base64 Converter](https://apify.com/automation-lab/base64-converter) — encode/decode strings to Base64 in bulk
- [Canonical URL Checker](https://apify.com/automation-lab/canonical-url-checker) — verify canonical URL tags on web pages
- [Broken Link Checker](https://apify.com/automation-lab/broken-link-checker) — find and report broken links on any website
- [Robots & Sitemap Analyzer](https://apify.com/automation-lab/robots-sitemap-analyzer) — analyze robots.txt and sitemap files

# Actor input Schema

## `texts` (type: `array`):

Enter one or more URLs or text strings to convert to QR codes. Each item becomes a separate QR code.

## `format` (type: `string`):

Select PNG for raster images (best for printing and embedding) or SVG for scalable vector graphics (best for web and high-DPI displays).

## `size` (type: `integer`):

Width and height of the generated QR code image in pixels. Applies to PNG only; SVG is always scalable. Range: 100–1000.

## `errorCorrectionLevel` (type: `string`):

Higher levels allow QR codes to be read even when partially damaged or obscured. L=7%, M=15%, Q=25%, H=30% data recovery.

## `darkColor` (type: `string`):

Color of the dark QR code modules in hex format (e.g. #000000 for black). Applies to PNG only.

## `lightColor` (type: `string`):

Background color of the QR code in hex format (e.g. #ffffff for white). Applies to PNG only.

## Actor input object example

```json
{
  "texts": [
    "https://apify.com",
    "https://example.com"
  ],
  "format": "png",
  "size": 300,
  "errorCorrectionLevel": "M",
  "darkColor": "#000000",
  "lightColor": "#ffffff"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "texts": [
        "https://apify.com",
        "https://example.com"
    ],
    "size": 300
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/qr-code-generator").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 = {
    "texts": [
        "https://apify.com",
        "https://example.com",
    ],
    "size": 300,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/qr-code-generator").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 '{
  "texts": [
    "https://apify.com",
    "https://example.com"
  ],
  "size": 300
}' |
apify call automation-lab/qr-code-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/qr-code-generator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "QR Code Generator",
        "description": "Generate QR codes from URLs and text strings in bulk. Supports PNG and SVG formats with configurable sizes and error correction levels. Outputs data URIs and saves images to key-value store for direct download. Ideal for marketing campaigns and product labeling workflows.",
        "version": "0.1",
        "x-build-id": "Bb1bew513BSCEY7re"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~qr-code-generator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-qr-code-generator",
                "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/automation-lab~qr-code-generator/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-qr-code-generator",
                "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/automation-lab~qr-code-generator/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-qr-code-generator",
                "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": [
                    "texts"
                ],
                "properties": {
                    "texts": {
                        "title": "URLs or text to encode",
                        "type": "array",
                        "description": "Enter one or more URLs or text strings to convert to QR codes. Each item becomes a separate QR code.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "format": {
                        "title": "Output format",
                        "enum": [
                            "png",
                            "svg"
                        ],
                        "type": "string",
                        "description": "Select PNG for raster images (best for printing and embedding) or SVG for scalable vector graphics (best for web and high-DPI displays).",
                        "default": "png"
                    },
                    "size": {
                        "title": "Image size (px)",
                        "minimum": 100,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Width and height of the generated QR code image in pixels. Applies to PNG only; SVG is always scalable. Range: 100–1000.",
                        "default": 300
                    },
                    "errorCorrectionLevel": {
                        "title": "Error correction level",
                        "enum": [
                            "L",
                            "M",
                            "Q",
                            "H"
                        ],
                        "type": "string",
                        "description": "Higher levels allow QR codes to be read even when partially damaged or obscured. L=7%, M=15%, Q=25%, H=30% data recovery.",
                        "default": "M"
                    },
                    "darkColor": {
                        "title": "Dark module color",
                        "type": "string",
                        "description": "Color of the dark QR code modules in hex format (e.g. #000000 for black). Applies to PNG only.",
                        "default": "#000000"
                    },
                    "lightColor": {
                        "title": "Light module color",
                        "type": "string",
                        "description": "Background color of the QR code in hex format (e.g. #ffffff for white). Applies to PNG only.",
                        "default": "#ffffff"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```