# QR Craft — QR Code Generator (PNG/SVG) (`perryay/qr-craft`) Actor

Generate high-quality QR codes in PNG or SVG format. Supports batch processing (up to 50 codes), custom colors, multiple error correction levels, and returns both public download URLs and inline data URIs. Perfect for marketing, events, product packaging, and developer workflows.

- **URL**: https://apify.com/perryay/qr-craft.md
- **Developed by:** [Perry AY](https://apify.com/perryay) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / actor start

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## QR Craft — Batch QR Code Generator with Custom Colors, Sizes, and SVG Export

### What does it do?

**QR Craft** generates high-quality QR codes in PNG or SVG format — up to 50 codes per request — with full control over size, color, and error correction. Whether you need a single QR code pointing to your landing page or a bulk batch for event badges, inventory labels, or marketing materials, QR Craft delivers production-ready output every time. Every code is spec-compliant and scannable by any standard QR reader.

### Who is it for?

| Persona | What they use it for |
|---|---|
| Marketing Manager | Creating branded QR codes for print campaigns, posters, and product packaging |
| Event Organizer | Generating unique QR codes for attendee badges, ticket verification, and session check-ins |
| Logistics Coordinator | Producing batch QR labels for inventory items, asset tags, and shipment tracking |
| Developer | Embedding QR code generation into CI/CD workflows for app store links or deployment URLs |
| Small Business Owner | Making QR codes for restaurant menus, storefront promotions, and business card links |
| Graphic Designer | Exporting SVG QR codes at any resolution for use in layouts, brochures, and signage |
| Retail Manager | Generating shelf-talker QR codes linking to product details, reviews, or video demos |

### Why use this?

- **Batch up to 50 codes in one run** — pass an array of data strings and get every QR code back in a single response. No more running the generator 50 times or writing a script to loop through a list.
- **Custom colors that match your brand** — set foreground and background hex colors so QR codes blend seamlessly with your marketing materials. Replace the default black-on-white with your brand palette.
- **Choose your output format** — PNG for pixel-perfect raster graphics or SVG for infinitely scalable vectors. SVGs look crisp on billboards, business cards, and 4K screens alike.
- **Multiple error correction levels** — pick L (7% recovery) for clean print surfaces, or H (30% recovery) for codes that need to survive damage, smudges, curved surfaces, or poor lighting during scanning.
- **High-resolution mode** — generate larger QR codes at 2x resolution for print use cases where standard sizes would look pixelated at close inspection. Ideal for posters, banners, and large-format signage.
- **Simple API with no dependencies** — a single POST request with your data returns downloadable image URLs. No SDKs to install, no image processing libraries, no rendering servers to maintain.

### Input Parameters

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `data` | string | conditional | — | The content to encode in the QR code. Required when `batchData` is not provided. Accepts URLs, plain text, phone numbers, email addresses, SMS, Wi-Fi config strings, and vCard data. |
| `batchData` | array | conditional | — | An array of strings, one per QR code, for batch generation. Required when `data` is not provided. Maximum 50 items. |
| `size` | integer | no | `500` | Width and height of the QR code image in pixels. Range: 100–2000. Larger sizes produce more detailed output suitable for print. |
| `format` | string | no | `png` | Output image format. `png` for raster image, `svg` for vector/scalable output. |
| `errorCorrection` | string | no | `M` | Error correction level: `L` (low, 7%), `M` (medium, 15%), `Q` (quartile, 25%), `H` (high, 30%). Higher levels survive more damage but produce denser QR patterns. |
| `foregroundColor` | string | no | `#000000` | Hex color for the QR code modules (the dark squares). Full 6-digit hex format, e.g. `#FF5733`. |
| `backgroundColor` | string | no | `#FFFFFF` | Hex color for the QR code background. Full 6-digit hex format, e.g. `#F0F0F0`. |
| `highRes` | boolean | no | `false` | When `true`, renders the QR code at 2x the requested `size` for sharper print output. Only applies to PNG format. |

### Example Input

#### Single QR code

```json
{
  "data": "https://example.com/landing-page",
  "size": 800,
  "format": "png",
  "errorCorrection": "H",
  "foregroundColor": "#1A73E8",
  "backgroundColor": "#FFFFFF",
  "highRes": true
}
````

#### Batch QR codes (SVG output)

```json
{
  "batchData": [
    "https://example.com/product/1",
    "https://example.com/product/2",
    "https://example.com/product/3",
    "https://example.com/product/4",
    "https://example.com/product/5"
  ],
  "size": 300,
  "format": "svg",
  "errorCorrection": "M",
  "foregroundColor": "#2E7D32",
  "backgroundColor": "#E8F5E9"
}
```

### Output Structure

| Field | Type | Description |
|---|---|---|
| `success` | boolean | Whether all QR codes were generated successfully |
| `count` | integer | Number of QR codes generated in this batch |
| `codes` | array | Array of generated QR code objects (one per input item) |
| `error` | string | Present only if the entire run failed |

#### Code object structure

| Field | Type | Description |
|---|---|---|
| `index` | integer | Zero-based index of this code in the batch, matching the order of input |
| `data` | string | The original data string that was encoded into this QR code |
| `format` | string | Output format of this code (`png` or `svg`) |
| `imageUrl` | string | Direct download URL for the QR code image |
| `size` | integer | Actual dimensions of the image in pixels |

### Example Output

```json
{
  "success": true,
  "count": 1,
  "codes": [
    {
      "index": 0,
      "data": "https://example.com/landing-page",
      "format": "png",
      "imageUrl": "https://api.apify.com/v2/key-value-stores/.../records/qr-0.png",
      "size": 800
    }
  ]
}
```

#### Batch output example

```json
{
  "success": true,
  "count": 5,
  "codes": [
    {
      "index": 0,
      "data": "https://example.com/product/1",
      "format": "svg",
      "imageUrl": "https://api.apify.com/v2/key-value-stores/.../records/qr-0.svg",
      "size": 300
    },
    {
      "index": 1,
      "data": "https://example.com/product/2",
      "format": "svg",
      "imageUrl": "https://api.apify.com/v2/key-value-stores/.../records/qr-1.svg",
      "size": 300
    }
  ]
}
```

### API Usage

#### cURL

```bash
## Single QR code (branded blue)
curl -X POST "https://api.apify.com/v2/acts/perryay~qr-craft/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "data": "https://example.com",
    "size": 500,
    "format": "png",
    "errorCorrection": "M",
    "foregroundColor": "#1565C0",
    "backgroundColor": "#FFFFFF"
  }'

## Batch of QR codes in SVG format
curl -X POST "https://api.apify.com/v2/acts/perryay~qr-craft/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "batchData": [
      "https://page1.com",
      "https://page2.com",
      "https://page3.com"
    ],
    "size": 300,
    "format": "svg",
    "errorCorrection": "Q",
    "foregroundColor": "#000000",
    "backgroundColor": "#FFFFFF"
  }'

## High-resolution print-ready QR code
curl -X POST "https://api.apify.com/v2/acts/perryay~qr-craft/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "data": "https://example.com/poster",
    "size": 1000,
    "format": "png",
    "errorCorrection": "H",
    "highRes": true
  }'
```

#### Python

```python
import requests

API_TOKEN = "YOUR_API_TOKEN"
ACTOR_URL = "https://api.apify.com/v2/acts/perryay~qr-craft/runs"

## Generate a batch of branded QR codes for event badges
attendees = [
    {"name": "Alice", "id": "ATT-001"},
    {"name": "Bob", "id": "ATT-002"},
    {"name": "Charlie", "id": "ATT-003"},
]

batch_data = [f"https://events.example.com/checkin/{a['id']}" for a in attendees]

response = requests.post(
    ACTOR_URL,
    headers={"Content-Type": "application/json",
             "Authorization": f"Bearer {API_TOKEN}"},
    json={
        "batchData": batch_data,
        "size": 600,
        "format": "png",
        "errorCorrection": "H",
        "foregroundColor": "#6A1B9A",
        "backgroundColor": "#F3E5F5",
        "highRes": True
    }
)

result = response.json()
for code in result["codes"]:
    idx = code["index"]
    print(f"Badge for {attendees[idx]['name']}: {code['imageUrl']}")

## Generate a Wi-Fi QR code
wifi_string = "WIFI:T:WPA;S:MyCoffeeShop;P:S3cr3tC0ff33;;"
response = requests.post(
    ACTOR_URL,
    headers={"Content-Type": "application/json",
             "Authorization": f"Bearer {API_TOKEN}"},
    json={
        "data": wifi_string,
        "size": 400,
        "format": "svg",
        "errorCorrection": "Q",
        "foregroundColor": "#4E342E",
        "backgroundColor": "#FFF8E1"
    }
)

svg_url = response.json()["codes"][0]["imageUrl"]
print(f"Wi-Fi QR SVG: {svg_url}")
```

### Use Cases

1. **Branded Marketing Campaigns** — Generate QR codes that match your brand colors — not the default black-on-white. Place them on flyers, posters, social media graphics, and product packaging. With high-res mode enabled, codes look sharp even on A1 posters and billboards.

2. **Event Ticketing & Badges** — Batch-create unique QR codes for every attendee before a conference. Each badge gets its own code for session scanning, door entry, and swag collection. Use `errorCorrection: "H"` so codes survive being folded, crumpled, or stuffed in pockets.

3. **Inventory & Asset Labels** — Generate a batch of QR codes for warehouse bins, equipment tags, or product SKUs. Print on adhesive labels and scan with any smartphone for instant access to asset details. SVG format keeps codes crisp even at tiny label sizes.

4. **Restaurant Contactless Menus** — Create a single QR code for your digital menu URL. Print it on table tents, window decals, and takeout bags. Use high error correction so greasy fingerprints, scratched laminate, or moisture doesn't break the scan.

5. **Wi-Fi Credential Sharing** — Encode your Wi-Fi SSID and password into a QR code using the standard format: `WIFI:T:WPA;S:MyNetwork;P:MyPass;;`. Guests scan with any smartphone camera and connect instantly — no more reciting passwords or printing complicated instructions.

6. **Digital Business Cards** — Encode a vCard with your name, phone, email, and social profiles into a QR code. Add it to your email signature, LinkedIn banner, or physical business card. Recipients scan and save your contact in one tap.

7. **Product Authentication** — Assign a unique QR code to each product unit linking to a verification page. Customers scan to confirm authenticity. The batch mode makes it practical to generate thousands of unique codes for a production run.

### FAQ

**Q: What data types can I encode in a QR code?**
A: QR Craft accepts any text string. Common use cases include URLs (`https://...`), email addresses (`mailto:name@domain.com`), phone numbers (`tel:+1234567890`), SMS (`smsto:12345:Hello`), Wi-Fi configs (`WIFI:T:WPA;S:SSID;P:PASS;;`), vCards, Bitcoin addresses, and plain text.

**Q: What is the maximum batch size?**
A: You can generate up to 50 QR codes in a single batch run. For larger batches (thousands of codes), make multiple requests — the API is designed for high-throughput programmatic access.

**Q: What is the difference between PNG and SVG output?**
A: PNG is a raster format — a grid of pixels at a fixed resolution. Good for screens and standard printing at the size you specify. SVG is a vector format — defined by mathematical paths that scale to any size without losing quality. SVG is ideal for large-format printing, embedding in web pages, and cases where someone might need to resize the code later.

**Q: Which error correction level should I choose?**
A: Use `L` (7%) or `M` (15%) for clean, high-contrast print surfaces — business cards, digital screens, stickers, product labels. Use `Q` (25%) or `H` (30%) when the QR code will be printed on curved surfaces, fabric, textured paper, or in environments where it might get scratched, smudged, or partially obscured. Higher levels create denser patterns but are more durable.

**Q: Can I generate QR codes with transparent backgrounds?**
A: QR Craft does not support transparent backgrounds directly, but you can set the background color to match your surface color. For SVG output, you can also edit the generated SVG file in any vector editor to remove or adjust the background rectangle.

**Q: What happens in batch mode if one of my data strings is invalid or empty?**
A: Each item in the batch is processed independently. Empty strings and invalid data produce an error for that specific index, while the rest of the batch continues normally. Check the `error` field on individual code objects for per-item failures.

**Q: How large can I make a QR code?**
A: The `size` parameter accepts values from 100 to 2000 pixels. For print use, a 1000px QR code at 300 DPI gives you about 3.3 inches — suitable for posters and signage. For even larger output, enable `highRes: true` which doubles the effective resolution.

**Q: Can I use QR Craft to generate dynamic QR codes (editable destinations)?**
A: QR Craft generates standard QR codes with whatever data string you provide. For dynamic QR codes that redirect to changeable URLs, you would need a URL shortening service that supports redirect editing. QR Craft can encode your short link URL.

### Related Tools

- [JSON Studio](https://apify.com/perryay/json-studio) — Format, validate, diff, and transform JSON documents
- [Meta Mate](https://apify.com/perryay/meta-mate) — Extract Open Graph, Twitter Cards, and JSON-LD metadata from URLs
- [UUID Lab](https://apify.com/perryay/uuid-lab) — Generate UUIDs, nanoids, short IDs, and ULIDs
- [Domain Intel](https://apify.com/perryay/domain-intel) — WHOIS lookups, DNS enumeration, and SSL certificate validation

### Comparison: PNG vs. SVG — which format should you choose?

| Factor | PNG | SVG |
|---|---|---|
| File type | Raster (pixel grid) | Vector (mathematical paths) |
| Scalability | Fixed resolution — looks pixelated when enlarged | Infinitely scalable — looks sharp at any size |
| File size | Larger at high resolutions | Compact, independent of display size |
| Best for | Digital screens, social media, standard print at defined size | Large-format print, billboards, embedded in web pages, logos |
| Editing | Requires image editor (Photoshop, GIMP) | Editable in any vector app or text editor |
| Transparency support | Via background color setting | Adjustable in any SVG editor |
| Browser support | Universal | Universal |

### SEO Keywords

QR code generator, batch QR codes, custom color QR code, SVG QR code, high resolution QR code, QR code API, QR code generator online, QR code for business cards, QR code for marketing, QR code for events, branded QR codes, error correction QR code, Wi-Fi QR code generator, QR code batch generator, PNG QR code, vector QR code, QR code print quality

# Actor input Schema

## `data` (type: `string`):

The text, URL, or other data to encode in the QR code. Leave empty if using batch mode.

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

Image format for the QR code. PNG for raster, SVG for scalable vector.

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

Width and height of the QR code image in pixels (PNG only). SVG is always scalable.

## `error_correction` (type: `string`):

More error correction = more durable but denser QR: L=7%, M=15%, Q=25%, H=30%

## `fill_color` (type: `string`):

Hex color for the QR code pattern (e.g. #000000 for black)

## `back_color` (type: `string`):

Hex color for the background (e.g. #FFFFFF for white). PNG only.

## `batch` (type: `array`):

Generate multiple QR codes at once. Each item can have its own data, format, and colors.

## Actor input object example

```json
{
  "data": "https://example.com",
  "format": "png",
  "size": 400,
  "error_correction": "M",
  "fill_color": "#000000",
  "back_color": "#FFFFFF",
  "batch": [
    {
      "data": "https://example.com",
      "format": "png",
      "error_correction": "M",
      "fill_color": "#000000",
      "back_color": "#FFFFFF"
    },
    {
      "data": "https://apify.com",
      "format": "svg",
      "error_correction": "H",
      "fill_color": "#FF6600"
    }
  ]
}
```

# Actor output Schema

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

Per-code generation metadata in the default dataset

## `generatedFiles` (type: `string`):

QR code image files in the key-value store

# 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 = {
    "data": "https://example.com",
    "fill_color": "#000000",
    "back_color": "#FFFFFF",
    "batch": [
        {
            "data": "https://example.com",
            "format": "png",
            "error_correction": "M",
            "fill_color": "#000000",
            "back_color": "#FFFFFF"
        },
        {
            "data": "https://apify.com",
            "format": "svg",
            "error_correction": "H",
            "fill_color": "#FF6600"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("perryay/qr-craft").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 = {
    "data": "https://example.com",
    "fill_color": "#000000",
    "back_color": "#FFFFFF",
    "batch": [
        {
            "data": "https://example.com",
            "format": "png",
            "error_correction": "M",
            "fill_color": "#000000",
            "back_color": "#FFFFFF",
        },
        {
            "data": "https://apify.com",
            "format": "svg",
            "error_correction": "H",
            "fill_color": "#FF6600",
        },
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("perryay/qr-craft").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 '{
  "data": "https://example.com",
  "fill_color": "#000000",
  "back_color": "#FFFFFF",
  "batch": [
    {
      "data": "https://example.com",
      "format": "png",
      "error_correction": "M",
      "fill_color": "#000000",
      "back_color": "#FFFFFF"
    },
    {
      "data": "https://apify.com",
      "format": "svg",
      "error_correction": "H",
      "fill_color": "#FF6600"
    }
  ]
}' |
apify call perryay/qr-craft --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "QR Craft — QR Code Generator (PNG/SVG)",
        "description": "Generate high-quality QR codes in PNG or SVG format. Supports batch processing (up to 50 codes), custom colors, multiple error correction levels, and returns both public download URLs and inline data URIs. Perfect for marketing, events, product packaging, and developer workflows.",
        "version": "1.0",
        "x-build-id": "r4Ud5DuIDsff8g2B9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/perryay~qr-craft/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-perryay-qr-craft",
                "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/perryay~qr-craft/runs": {
            "post": {
                "operationId": "runs-sync-perryay-qr-craft",
                "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/perryay~qr-craft/run-sync": {
            "post": {
                "operationId": "run-sync-perryay-qr-craft",
                "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": {
                    "data": {
                        "title": "Data to encode",
                        "type": "string",
                        "description": "The text, URL, or other data to encode in the QR code. Leave empty if using batch mode.",
                        "default": "https://example.com"
                    },
                    "format": {
                        "title": "Output format",
                        "enum": [
                            "png",
                            "svg"
                        ],
                        "type": "string",
                        "description": "Image format for the QR code. PNG for raster, SVG for scalable vector.",
                        "default": "png"
                    },
                    "size": {
                        "title": "Size (pixels)",
                        "minimum": 100,
                        "maximum": 4000,
                        "type": "integer",
                        "description": "Width and height of the QR code image in pixels (PNG only). SVG is always scalable.",
                        "default": 400
                    },
                    "error_correction": {
                        "title": "Error correction level",
                        "enum": [
                            "L",
                            "M",
                            "Q",
                            "H"
                        ],
                        "type": "string",
                        "description": "More error correction = more durable but denser QR: L=7%, M=15%, Q=25%, H=30%",
                        "default": "M"
                    },
                    "fill_color": {
                        "title": "QR code color",
                        "type": "string",
                        "description": "Hex color for the QR code pattern (e.g. #000000 for black)",
                        "default": "#000000"
                    },
                    "back_color": {
                        "title": "Background color",
                        "type": "string",
                        "description": "Hex color for the background (e.g. #FFFFFF for white). PNG only.",
                        "default": "#FFFFFF"
                    },
                    "batch": {
                        "title": "Batch QR codes",
                        "type": "array",
                        "description": "Generate multiple QR codes at once. Each item can have its own data, format, and colors."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
