# Code to Image: Beautiful Code Screenshots as PNG & SVG (`jumblemog/code-to-image`) Actor

Turn code into beautiful images like Carbon and ray.so: VS Code themes, 235 languages, ligature fonts, line highlights and diffs, as PNG, SVG or WebP. Paste code or link GitHub files. Built for AI agents, docs, blogs and social posts.

- **URL**: https://apify.com/jumblemog/code-to-image.md
- **Developed by:** [Jumble Mog](https://apify.com/jumblemog) (community)
- **Categories:** Developer tools, AI, For creators
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Code to Image: Beautiful Code Screenshots as PNG & SVG

**Turn code into beautiful images.** Send a snippet, a batch of snippets or links to files on GitHub, and get back a polished picture of an editor window on a gradient background, as **PNG, SVG or WebP** with a download link. The colors come from **VS Code's own grammars and themes** (through [Shiki](https://shiki.style)), so code looks exactly as it does in the editor: 235 languages, 65 themes, 11 coding fonts with ligatures, line numbers, highlighted and focused lines, and diffs in green and red. Like [Carbon](https://carbon.now.sh) or [ray.so](https://ray.so), but as an API that people, automations and AI agents can call.

![Four code images made by this Actor: Python on a violet gradient, a Go diff, TypeScript with focused lines on a 16:9 ocean background, and Rust in a light theme with a Windows title bar](https://api.apify.com/v2/key-value-stores/Km5b4PG3kYHdZSb1E/records/code-to-image-examples.png?signature=1B5d0hwT0zAITZDRQ77S2)

### What it does

- **Exact VS Code colors**: TextMate grammars and themes from VS Code, so keywords, strings, types, decorators, template literals and embedded languages are colored the way the editor colors them, in **235 languages** from Python, TypeScript, Go, Rust, Java, C#, C++, PHP, Ruby, Swift and Kotlin to SQL, Bash, YAML, Dockerfile, Terraform, Solidity, Zig and Vue.
- **65 themes**: One Dark Pro, Dracula, GitHub Dark and Light, Tokyo Night, Catppuccin, Nord, Monokai, Night Owl, Solarized, Gruvbox, Rosé Pine, Vitesse, Synthwave '84 and many more, dark and light.
- **11 coding fonts**: JetBrains Mono, Fira Code, Cascadia Code, Source Code Pro, IBM Plex Mono, Roboto Mono, Geist Mono, Hack, Ubuntu Mono, Space Mono and DejaVu Sans Mono, with bold and italics where the font has them and **ligatures** (`->` `=>` `!=` `===`) you can switch off.
- **Detects the language** with telltale patterns and VS Code's own language detection model, or takes it from a file name or a Markdown code fence (` ```python `), the way AI models write code.
- **Links to code**: GitHub file links (a range like `#L10-L25` shows just those lines, numbered as in the file), raw links, gists and other public raw files.
- **Line tools**: line numbers, highlighted lines, focus lines (everything else fades), a range of lines to show, and diffs: lines starting with `+` and `-` turn green and red while keeping the code's own colors.
- **Window and background**: macOS or Windows title bar or none, a window title, 12 backgrounds (gradients and solid colors), your own colors, the theme's color, transparent or none, a soft shadow, padding, rounded corners and a caption line.
- **Fixed shapes for social media**: 16:9 for slides and YouTube, 1.91:1 for link previews and X, 1:1 and 4:5 for Instagram, 9:16 for stories and Shorts, with the window centered.
- **Emoji and every script**: color emoji, Chinese, Japanese and Korean, Greek, Cyrillic and symbols, kept on the character grid so columns line up.
- **PNG, SVG and WebP**: PNG at 1× to 4× pixel density, lossless WebP, and SVG with the fonts embedded (only the characters used) so it looks the same everywhere. One charge per image, whatever the number of formats.
- **Fast and private**: about half a second per image, and nothing is sent to outside services.
- **Image straight from the API**: the first image is also the run's `OUTPUT`, so the run-sync endpoint answers with the image itself.

### Who it's for

- **AI agents and LLM apps** that write code and need to show it as a picture: in chats, posts, slides, emails and documents.
- **Developer advocates, bloggers and course creators** making code images for articles, tutorials, tweets, LinkedIn posts, newsletters and YouTube thumbnails, in batches with a consistent look.
- **Automation builders** in n8n, Make or Zapier who turn new snippets, release notes or GitHub files into social media posts.
- **Docs and changelog teams** who want diffs and highlighted lines as images that look the same on every platform.

### How to use it

1. Paste your code into **Code** (and, if you like, a window title such as `app.py`).
2. Pick a theme, background and font, or keep the defaults.
3. Click **Start**. The image appears in the **Output** tab with its download link.

For many images, put snippets in **More snippets** or links in **Links to code files**. You can also run it through the [Apify API](https://docs.apify.com/api/v2), on a schedule, or from Make, n8n, Zapier and other integrations.

### How-to examples

Each example below is a complete input, checked with a run of the Actor.

#### How to turn a code snippet into an image (like Carbon or ray.so)

```json
{"code": "def greet(name):\n    return f\"Hello, {name}!\"\n\nprint(greet(\"world\"))",
 "language": "python", "title": "hello.py", "theme": "tokyo-night", "background": "ocean"}
```

Result: a 978 x 538 PNG of an editor window titled hello.py, in Tokyo Night colors on a blue gradient, made in 0.12 seconds. Leave out `language` and it is detected from the code.

#### How to make an image of a code diff

```json
{"code": "-const total = items.length;\n+const total = items.filter(Boolean).length;", "diff": true, "language": "js", "aspectRatio": "16:9"}
```

Result: a 16:9 image with the removed line on red and the added line on green, each with its `-` or `+`, ready for a post or a slide.

#### How to screenshot lines of a file on GitHub

```json
{"urls": ["https://github.com/pallets/flask/blob/main/src/flask/app.py#L1-L12"], "highlightLines": "3-4",
 "theme": "github-light", "background": "white"}
```

Result: lines 1 to 12 of the file as a light image, with lines 3 and 4 highlighted. The language comes from the file name, and the line numbers in the link pick the lines.

#### How to let an AI agent share code as an image

Add this Actor to the [Apify MCP server](https://mcp.apify.com) with `https://mcp.apify.com/?tools=jumblemog/code-to-image`. The agent sends the code in `code` and shows the user `imageUrl`, for a tweet, a slide or a chat that can't show code blocks.

### FAQ

**Which languages and themes are there?** 235 languages and 65 VS Code themes, colored by the same grammars VS Code uses.

**Can I get SVG?** Yes. `formats` takes `png`, `svg` and `webp`.

**Can I make many images at once?** Yes. Put them in `snippets`, each with its own settings, or give several links in `urls`.

**Can I change the window and background?** Yes: the window style, title, padding, shadow, corner radius, font, line numbers, a gradient or solid background, or a transparent one.

**Does it work with Zapier, Make or n8n?** Yes. Call the Actor with its Apify app or an HTTP request and post `imageUrl`.

### Input

| Field | What it does |
| --- | --- |
| `code` | The code to draw. A Markdown code fence also sets the language. |
| `language` | `auto` (default) or a language name, alias, extension or file name: `python`, `ts`, `rust`, `c++`, `Dockerfile`. |
| `snippets` | More images: code strings, or objects with `code` (or `url`) and their own settings, such as `{"code": "...", "language": "go", "title": "main.go", "highlightLines": "3"}`. |
| `urls` | Links to code files: GitHub file links (with `#L10-L25` line ranges), raw links, gists, public raw files up to 1 MB. |
| `theme` | One of 65 VS Code themes (default `one-dark-pro`). |
| `background` | `violet` (default), `sunset`, `ocean`, `mint`, `candy`, `peach`, `aurora`, `lime`, `midnight`, `charcoal`, `silver`, `white`, `theme`, `transparent` or `none`. |
| `backgroundColors` | Your own background: one hex color, or two or three for a gradient (`#f97316, #db2777`). |
| `fontFamily`, `fontSize`, `lineHeight`, `ligatures` | Font (default JetBrains Mono, 14 px, 1.6), and ligatures on or off. |
| `windowStyle`, `title`, `fileName` | `mac` (default), `windows` or `none`; the title bar text; the file name (sets the language and title). |
| `shadow`, `padding`, `cornerRadius`, `caption` | Drop shadow (on), space around the window (56 px), corner radius (10 px) and a line of text under the window. |
| `aspectRatio` | `auto` (fit the code), `16:9`, `1.91:1`, `2:1`, `4:3`, `1:1`, `4:5` or `9:16`. |
| `lineNumbers`, `startLine` | Show line numbers, starting from 1 or any number. |
| `lines`, `highlightLines`, `focusLines` | Show part of the code (`10-30`), highlight lines (`3, 7-9`), or fade all but some lines (`4-6`). |
| `diff` | Show lines starting with `+` and `-` as added and removed. |
| `wrapColumns`, `minColumns`, `tabSize`, `maxLines` | Wrap long lines (100 characters), minimum width (40), tab width (4), and the most lines drawn (300). |
| `formats` | Any of `png` (default), `svg` and `webp`. |
| `scale` | Pixel density of PNG and WebP, 1 to 4 (default 2). |
| `maxImages` | Stop after this many images (default 100). |

The language, title, file name and line settings in the form belong to the `code` field. Every snippet and link has its own (or gets them detected), while the look and output settings apply to all of them unless a snippet sets its own.

Example with a batch:

```json
{
  "theme": "tokyo-night",
  "background": "ocean",
  "aspectRatio": "16:9",
  "snippets": [
    {"name": "hello", "code": "fn main() {\n    println!(\"Hello, world!\");\n}", "title": "main.rs"},
    {"name": "fix", "code": "-const total = items.length;\n+const total = items.filter(Boolean).length;", "diff": true, "language": "js"},
    {"name": "query", "code": "SELECT name, COUNT(*) AS orders\nFROM users JOIN orders USING (user_id)\nGROUP BY name;", "theme": "github-light", "background": "white"}
  ],
  "urls": ["https://github.com/pallets/flask/blob/main/src/flask/app.py#L1-L20"]
}
```

### Output

Each snippet becomes one dataset item, and the files are saved in the run's key-value store:

```json
{
  "index": 1,
  "name": "hello",
  "status": "ok",
  "error": null,
  "imageUrl": "https://api.apify.com/v2/key-value-stores/<store>/records/001-hello.png",
  "pngUrl": "https://api.apify.com/v2/key-value-stores/<store>/records/001-hello.png",
  "svgUrl": null,
  "webpUrl": null,
  "language": "rust",
  "languageFrom": "detected",
  "theme": "tokyo-night",
  "font": "JetBrains Mono",
  "width": 1600,
  "height": 900,
  "lines": 3,
  "sourceUrl": null,
  "notes": [],
  "processingSeconds": 0.52
}
```

When a snippet can't be drawn (for example a link to a private file), the item says why and isn't billed:

```json
{
  "index": 4,
  "status": "failed",
  "error": "The file isn't there or isn't public (HTTP 404). Check the link.",
  "imageUrl": null
}
```

Download your files within your plan's data retention period, or copy them to your own storage, because run storage expires.

### Pricing

You pay per **image created**, at the price shown on this page, whatever the number of formats (PNG, SVG and WebP of the same snippet count once). Snippets that can't be drawn are never charged. If you set a maximum cost per run, the Actor stops when the next image wouldn't fit.

### Speed

Measured on Apify at the default 1 GB of memory: a batch of 5 PNG images (7 to 11 lines each, mostly 16:9) was finished 4.4 seconds after the run started, at 0.4 to 0.7 seconds per image, and a whole `run-sync` call for one image took 4.5 seconds from request to PNG. Adding SVG and lossless WebP copies of every image makes each one take 1 to 2 seconds. Starting a run adds a few seconds, more when a server downloads the Actor for the first time, so for many images one run with a batch is much quicker than one run per image.

### Tips and limits

- Code can be up to 500,000 characters per snippet, and the image is cut after `maxLines` lines (300 by default, 5,000 at most). Very tall images are drawn at a lower scale to stay under 25 megapixels, and WebP files can't be taller or wider than 16,383 pixels.
- Indentation shared by all lines and blank lines at the start and end are removed, and tabs become spaces (`tabSize`).
- Links: GitHub file links are fetched from raw.githubusercontent.com. GitLab and Bitbucket raw files aren't fetched, because their robots.txt files forbid it; every other host's robots.txt is checked first. Only public files work: there are no logins.
- Unknown language names fall back to plain text, and the item's `notes` say so.
- Fira Code and Geist Mono have no italics, so italic tokens use their upright letters.
- SVG files embed the fonts as small WOFF2 subsets, so they look right in browsers and design tools without installing anything.

### For AI agents and developers

This Actor works with the [Apify MCP server](https://mcp.apify.com), so AI agents can call it as a tool: pass `code` (a model's fenced answer works as it is) and read `imageUrl` from the dataset item. For a direct API call that waits for the result:

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~code-to-image/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"code": "const greet = (name) => `Hello, ${name}!`;", "theme": "dracula", "title": "greet.js"}'
```

To get the image itself as the response, call `run-sync` instead. It returns the run's `OUTPUT`, which is the first image (or the error as JSON):

```bash
curl -X POST "https://api.apify.com/v2/acts/jumblemog~code-to-image/run-sync?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"code": "print(\"Hello, world!\")", "background": "sunset"}' \
  -o code.png
```

### Credits

- [Shiki](https://github.com/shikijs/shiki) (MIT) with VS Code's TextMate grammars and themes (each under its own license, mostly MIT), [VS Code's language detection model](https://github.com/microsoft/vscode-languagedetection) (MIT), [highlight.js](https://github.com/highlightjs/highlight.js) (BSD-3-Clause), [resvg](https://github.com/linebender/resvg) (Apache-2.0 / MIT), [fontTools](https://github.com/fonttools/fonttools) (MIT) and [Pillow](https://python-pillow.org) (MIT-CMU).
- Fonts: JetBrains Mono, Fira Code, Cascadia Code, Source Code Pro, IBM Plex Mono, Roboto Mono, Geist Mono and Space Mono (SIL Open Font License), Hack (MIT and Bitstream Vera), Ubuntu Mono (Ubuntu Font Licence), DejaVu Sans Mono (Bitstream Vera), and Noto Color Emoji and Noto Sans CJK (OFL) for emoji and East Asian characters.
- This Actor isn't affiliated with Carbon, ray.so, VS Code or the projects above.

# Actor input Schema

## `code` (type: `string`):

The code to draw. Any of 235 languages; a Markdown code fence (`python ... `), the way AI models write code, also sets the language, and text around the fence is left out.

## `language` (type: `string`):

auto detects it. Or a name, alias, file extension or file name: python, ts, tsx, rust, go, sql, bash, yaml, c++, c#, kotlin, swift, php, Dockerfile and 235 languages in all (every language VS Code's grammars cover through Shiki).

## `snippets` (type: `array`):

More images in one run. Each entry is a code string, or an object with "code" (or "url") and any settings of its own, such as {"code": "fmt.Println(42)", "language": "go", "title": "main.go", "theme": "nord", "highlightLines": "1", "name": "intro"}. Settings left out come from this form.

## `urls` (type: `array`):

Draw code straight from links: GitHub file links (a line range such as #L10-L25 shows just those lines, numbered as in the file), raw.githubusercontent.com links, gists, or any public raw text file. Hosts whose robots.txt forbids it (GitLab and Bitbucket raw files) are declined. Files up to 1 MB.

## `theme` (type: `string`):

One of 65 VS Code color themes, the same colors as in the editor.

## `background` (type: `string`):

What's around the window: a gradient, a solid color, the theme's own color, transparent, or none (just the window).

## `backgroundColors` (type: `string`):

Your own background instead: one hex color (#0f172a) or two or three for a diagonal gradient (#f97316, #db2777).

## `fontFamily` (type: `string`):

Coding font, with bold and italics where the font has them. Ligatures (-> => != ===) where the font has them.

## `fontSize` (type: `integer`):

Text size before scaling.

## `lineHeight` (type: `number`):

Space per line as a multiple of the font size.

## `ligatures` (type: `boolean`):

Join -> => != === and similar into single symbols, in fonts that have them (JetBrains Mono, Fira Code, Cascadia Code).

## `windowStyle` (type: `string`):

The editor window's title bar.

## `title` (type: `string`):

Text in the title bar, usually a file name such as app.py. Links to files use the file's name when this is empty.

## `fileName` (type: `string`):

The code's file name, such as main.rs: sets the language and the window title when those are empty.

## `shadow` (type: `boolean`):

A soft drop shadow under the window.

## `padding` (type: `integer`):

Space between the window and the image edge.

## `cornerRadius` (type: `integer`):

How round the window's corners are.

## `aspectRatio` (type: `string`):

auto fits the code. The others widen or heighten the background to a fixed shape, with the window centered: 16:9 for slides and YouTube, 1.91:1 for link previews and X posts, 1:1 and 4:5 for Instagram, 9:16 for stories and Shorts.

## `caption` (type: `string`):

A line of text under the window, such as your name, handle or site.

## `lineNumbers` (type: `boolean`):

Show line numbers.

## `startLine` (type: `integer`):

The number of the first line. Empty: 1, or the first line of the range picked with lines or a #L link.

## `lines` (type: `string`):

Show part of the code only, such as 10-30, 10- (to the end) or -30.

## `highlightLines` (type: `string`):

Lines to mark with a bright band, such as 3, 7-9 (numbers as shown).

## `focusLines` (type: `string`):

Lines to keep bright while all others fade, such as 4-6.

## `diff` (type: `boolean`):

Lines starting with + or - are shown as added (green) or removed (red), keeping the code's own colors, like a pull request. Git headers are left out.

## `wrapColumns` (type: `integer`):

Lines longer than this many characters wrap onto the next row, indented. 0 never wraps.

## `minColumns` (type: `integer`):

The window is at least this many characters wide. Give several images the same width for a matching set.

## `tabSize` (type: `integer`):

Spaces per tab character.

## `maxLines` (type: `integer`):

Longer code is cut after this many lines (the result says so).

## `formats` (type: `array`):

PNG for chats, docs and social posts; SVG for crisp scaling on the web, with the fonts embedded; WebP for small lossless files. One charge per image, whatever the number of formats.

## `scale` (type: `number`):

Pixel density of PNG and WebP files: 2 (default) is sharp on high-resolution screens, 1 gives smaller files, 3 or 4 for print. Very tall images are scaled down to stay under 25 megapixels.

## `maxImages` (type: `integer`):

Stop after this many images, so the cost of a run stays predictable.

## Actor input object example

```json
{
  "code": "from functools import cache\n\n@cache\ndef fibonacci(n: int) -> int:\n    \"\"\"The n-th Fibonacci number, each one computed only once.\"\"\"\n    if n < 2:\n        return n\n    return fibonacci(n - 1) + fibonacci(n - 2)\n\nprint([fibonacci(n) for n in range(10)])  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]",
  "language": "auto",
  "urls": [],
  "theme": "one-dark-pro",
  "background": "violet",
  "fontFamily": "JetBrains Mono",
  "fontSize": 14,
  "lineHeight": 1.6,
  "ligatures": true,
  "windowStyle": "mac",
  "shadow": true,
  "padding": 56,
  "cornerRadius": 10,
  "aspectRatio": "auto",
  "lineNumbers": false,
  "diff": false,
  "wrapColumns": 100,
  "minColumns": 40,
  "tabSize": 4,
  "maxLines": 300,
  "formats": [
    "png"
  ],
  "scale": 2,
  "maxImages": 100
}
```

# Actor output Schema

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

One item per snippet: image links, size, language and theme, or the error.

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

The PNG, SVG and WebP files saved in the run's 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 = {
    "code": `from functools import cache

@cache
def fibonacci(n: int) -> int:
    """The n-th Fibonacci number, each one computed only once."""
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print([fibonacci(n) for n in range(10)])  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]`,
    "urls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("jumblemog/code-to-image").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 = {
    "code": """from functools import cache

@cache
def fibonacci(n: int) -> int:
    \"\"\"The n-th Fibonacci number, each one computed only once.\"\"\"
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

print([fibonacci(n) for n in range(10)])  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]""",
    "urls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("jumblemog/code-to-image").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "code": "from functools import cache\\n\\n@cache\\ndef fibonacci(n: int) -> int:\\n    \\"\\"\\"The n-th Fibonacci number, each one computed only once.\\"\\"\\"\\n    if n < 2:\\n        return n\\n    return fibonacci(n - 1) + fibonacci(n - 2)\\n\\nprint([fibonacci(n) for n in range(10)])  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]",
  "urls": []
}' |
apify call jumblemog/code-to-image --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jumblemog/code-to-image"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/BWUnTt8Ybkns13pwj/builds/WFIIbOYkWFxPABNRP/openapi.json