# Markdown & HTML to PDF Converter (+ URL) (`bigaceboy/markdown-html-to-pdf`) Actor

Convert Markdown to PDF, HTML to PDF or any web page URL to PDF via API. GitHub-style tables, code and task lists; A4, Letter, Legal, landscape, margins, page numbers, headers, custom CSS, PNG preview. Batch up to 200 docs. $0.004 per PDF, failures free. For AI agents, MCP, n8n, Make.

- **URL**: https://apify.com/bigaceboy/markdown-html-to-pdf.md
- **Developed by:** [Anthony Crawford](https://apify.com/bigaceboy) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 pdf generateds

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

**Convert Markdown to PDF, HTML to PDF, or any web page URL to PDF with one API call.** Markdown & HTML to PDF Converter renders your document in a real Chrome browser and returns a clean, print-ready PDF with a direct download link. Markdown is styled like GitHub (tables, task lists, syntax-highlighted code), and you control **paper size (A4, Letter, Legal…), landscape, margins, page numbers, headers/footers and custom CSS**. Built for **AI agents, LLM apps and n8n/Make/Zapier automations** that write reports, invoices or summaries and need a real PDF file. **$0.004 per PDF**, failed documents are free.

### What can this Markdown & HTML to PDF converter do?

- 📝 **Markdown to PDF** with GitHub Flavored Markdown: tables, task lists `- [x]`, fenced code blocks with syntax highlighting, strikethrough, autolinks, block quotes, images.
- 🧾 **HTML to PDF** for full documents or fragments: invoices, receipts, reports, certificates, tickets, contracts. Your HTML is printed exactly as written, or with the clean stylesheet if you want it.
- 🌐 **URL to PDF**: print any public web page (archive an article, save a receipt page, snapshot docs) with `load`, `domcontentloaded` or `networkidle` waiting.
- 📄 **Paper sizes**: A4, US Letter, Legal, A5, A3, Tabloid, portrait or **landscape**, plus CSS `@page` sizes.
- 🔢 **Page numbers** ("Page X of Y") on by default, or your own **header/footer HTML** with `pageNumber`, `totalPages`, `title`, `date`, `url` placeholders.
- 🎨 **Custom CSS**, margins, background printing, scale, Google Fonts.
- 🖼️ **PNG preview of page 1** for thumbnails, chat apps and vision-capable AI agents (same price).
- 📦 **Batch**: up to 200 documents per run, one PDF and one dataset row each.
- 🛡️ **Safe by default**: JavaScript never runs for Markdown/HTML input; URL mode only fetches public http(s) addresses (private, loopback, link-local and cloud-metadata IPs are blocked, DNS is resolved and every redirect is checked).

### Who is it for?

- **AI agents and LLM apps** (via the Apify MCP server or API) that produce Markdown and need to hand back a PDF link.
- **No-code automations** in n8n, Make and Zapier that generate PDFs from templates, form data or Google Sheets rows.
- **Developers** who need an HTML to PDF API without running headless Chrome, Puppeteer or Gotenberg themselves.

### How to convert Markdown to PDF

1. Click **Try for free** (or **Start**) and sign in to Apify.
2. Paste your Markdown into **Markdown (single document shortcut)**, or HTML into the HTML field, or a link into **Web page URLs**. For many files at once, use **Documents**.
3. Pick the **Paper size**, **Landscape** and **Page numbers** options.
4. Click **Start**. The **Output** tab shows each document with its `pdfUrl`; click to download.

### Input example

The simplest possible call:

```json
{ "markdown": "# Hello\n\nThis becomes a PDF.", "format": "Letter" }
```

A batch with Markdown, HTML and a URL:

```json
{
  "documents": [
    { "fileName": "weekly-report", "markdown": "# Weekly Report\n\n| Item | Qty |\n| --- | ---: |\n| Widgets | 3 |\n\n- [x] Shipped\n- [ ] Invoice sent" },
    { "fileName": "invoice-1042", "html": "<h1>Invoice #1042</h1><table><tr><th>Item</th><th>Total</th></tr><tr><td>Design</td><td>$300</td></tr></table>" },
    { "url": "https://example.com" }
  ],
  "format": "Letter",
  "landscape": false,
  "pageNumbers": true,
  "customCss": "h1 { color: #0b5394; }",
  "firstPagePng": true
}
```

This creates 3 PDFs = **$0.012**.

#### Main input fields

| Field | Type | Default | Notes |
| --- | --- | --- | --- |
| `documents` | array of objects | – | Each object has exactly one of `markdown`, `html`, `url`, plus optional `fileName` (no `.pdf`) and `title`. |
| `markdown` | string | – | Shortcut for a single Markdown doc. |
| `html` | string | – | Shortcut for a single HTML doc or fragment. |
| `urls` | array of strings | – | Shortcut list of web pages. |
| `fileName` | string | – | File name for the `markdown`/`html` shortcut. |
| `format` | `A4` / `Letter` / `Legal` / `A5` / `A3` / `Tabloid` | `A4` | |
| `landscape` | boolean | `false` | |
| `pageNumbers` | boolean | `true` | "Page X of Y" footer. |
| `marginTop` / `marginRight` / `marginBottom` / `marginLeft` | string | `15mm` (`18mm` top/bottom with header/footer) | `mm`, `cm`, `in` or `px`. |
| `printBackground` | boolean | `true` | |
| `headerTemplate` / `footerTemplate` | HTML string | – | Chromium header/footer templates. Set a `font-size`. |
| `customCss` | string | – | Applied after the default stylesheet. |
| `useDefaultStyles` | boolean | `true` | GitHub-like stylesheet for Markdown. |
| `htmlUseDefaultStyles` | boolean | `false` | Also apply it to HTML input. |
| `scale` | number | `1` | 0.1–2. |
| `preferCSSPageSize` | boolean | `false` | Use the document's `@page { size }`. |
| `firstPagePng` | boolean | `false` | Save a PNG of page 1. |
| `pngDpi` | integer | `110` | 36–200. |
| `mediaType` | `print` / `screen` | `print` | |
| `waitUntil` | `load` / `domcontentloaded` / `networkidle` | `load` | URL mode. |
| `waitForMillis` | integer | `0` | URL mode extra wait, max 15000. |
| `timeoutSecs` | integer | `45` | Per document. |
| `urlJavaScript` | boolean | `true` | Let web pages run their own JS (never for Markdown/HTML). |
| `allowRemoteResources` | boolean | `true` | Let Markdown/HTML load public images/fonts/CSS. |
| `maxPdfSizeMb` | integer | `50` | Larger PDFs fail with `OUTPUT_TOO_LARGE` (free). |

### Output example

Each PDF (and optional PNG) is saved to the run's default key-value store, with one dataset row per document:

```json
{
  "index": 0,
  "sourceType": "markdown",
  "source": "362 chars",
  "fileName": "weekly-report.pdf",
  "title": "Weekly Report",
  "status": "ok",
  "pages": 1,
  "bytes": 61683,
  "format": "Letter",
  "landscape": false,
  "pdfKey": "001-weekly-report.pdf",
  "pdfUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/001-weekly-report.pdf",
  "pngUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/001-weekly-report-page1.png",
  "errorCode": null,
  "error": null,
  "charged": true
}
```

Failed rows have `status: "error"`, a machine-readable `errorCode` (`INVALID_INPUT`, `INVALID_URL`, `BLOCKED_URL`, `DNS_FAILED`, `HTTP_ERROR`, `FETCH_FAILED`, `NAVIGATION_FAILED`, `TIMEOUT`, `TOO_LARGE`, `OUTPUT_TOO_LARGE`, `RENDER_FAILED`), a readable `error`, and `charged: false`.

### How much does it cost to convert HTML or Markdown to PDF?

| What you do | PDFs | Price |
| --- | --- | --- |
| 1 Markdown report | 1 | $0.004 |
| 25 invoices from HTML | 25 | $0.10 |
| 1,000 PDFs | 1,000 | $4.00 |

| Event | Price | When |
| --- | --- | --- |
| `pdf-generated` | **$0.004** | One document became a downloadable PDF (PNG preview included). |
| `apify-actor-start` | Apify's tiny standard start fee | Once per run. |

Failed documents, blocked URLs and invalid input are **free**, and the run stops cleanly before going over your maximum charge per run. Apify's free plan includes monthly platform credit, enough to try it many times.

### Use with AI agents (Apify MCP server)

Let Claude, ChatGPT, Cursor, VS Code or any MCP client make PDFs. Load just this tool from the hosted [Apify MCP server](https://mcp.apify.com):

```
https://mcp.apify.com?tools=bigaceboy/markdown-html-to-pdf
```

```json
{
  "mcpServers": {
    "markdown-to-pdf": { "url": "https://mcp.apify.com?tools=bigaceboy/markdown-html-to-pdf" }
  }
}
```

Then ask: *"Turn this Markdown report into a Letter-size PDF with page numbers and give me the link."* The agent calls the Actor with `{"markdown": "...", "format": "Letter"}` and reads `pdfUrl` from the result. Pay-per-event pricing also works with Apify's agentic payments.

### Use with n8n, Make and Zapier

- **n8n**: add the **Apify** node → *Actors* → **Run an Actor and Get Dataset** → Actor `bigaceboy/markdown-html-to-pdf`. In *Custom input* use an expression such as `{ "markdown": {{ JSON.stringify($json.report) }}, "format": "A4" }`. Then download `pdfUrl` with an **HTTP Request** node (response format *File*) and attach it to Gmail, upload to Google Drive, post to Slack…
- **Make**: Apify → **Run an Actor** (wait for finish) → **Get Dataset Items** → **HTTP: Get a file** from `pdfUrl`.
- **Zapier**: Apify → **Run Actor** (synchronous), then use `pdfUrl` in the next step.

### Use with the API (curl, JavaScript, Python)

```bash
curl -X POST "https://api.apify.com/v2/acts/bigaceboy~markdown-html-to-pdf/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"markdown":"# Hello\n\nFrom curl","format":"A4"}'
```

The response is the dataset rows; download the file from `pdfUrl`.

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('bigaceboy/markdown-html-to-pdf').call({ markdown: '# Report\n\nHello', format: 'Letter' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].pdfUrl);
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("bigaceboy/markdown-html-to-pdf").call(run_input={"markdown": "# Report\n\nHello", "format": "Letter"})
print(next(client.dataset(run["defaultDatasetId"]).iterate_items())["pdfUrl"])
```

### FAQ

#### How do I convert Markdown to PDF without installing anything?

Paste the Markdown into the input and click Start, or send it to the API. You get a GitHub-styled PDF back. No Pandoc, LaTeX or wkhtmltopdf needed.

#### Is there an HTML to PDF API for n8n?

Yes. Use the Apify node's **Run an Actor and Get Dataset** operation with this Actor, then fetch `pdfUrl`. See the n8n section above.

#### Does it support US Letter, landscape and page numbers?

Yes: `format: "Letter"`, `landscape: true`, `pageNumbers: true` (on by default). Custom header and footer HTML is supported too.

#### How do I add a page break?

Insert `<div style="break-after: page"></div>` in Markdown or HTML.

#### Can I use custom fonts and colors?

Yes. Put CSS in `customCss`, e.g. `@import url('https://fonts.googleapis.com/css2?family=Inter&display=swap'); body { font-family: Inter; }`.

#### My wide table is cut off

Set `landscape: true` or `scale: 0.8`.

#### Does JavaScript run in my HTML?

No, never for Markdown/HTML input (safer and predictable). For web page URLs, page scripts run by default (`urlJavaScript`).

#### Can it print pages behind a login?

No. URL mode only prints public pages. For private content, send the HTML itself.

### Other tools by this developer

| Tool | What it does | Price |
| --- | --- | --- |
| [Website Screenshot to Social Image](https://apify.com/bigaceboy/website-screenshot-to-social) | Screenshot any URL into Instagram, Pinterest or OG 1200×630 images | $0.004 / image |
| [Social Image Resizer (No Crop)](https://apify.com/bigaceboy/social-image-letterboxer) | Fit photos into Instagram/Pinterest/Story sizes without cropping | $0.005 / image |
| [Image Optimizer & Converter](https://apify.com/bigaceboy/image-optimizer-converter) | Compress images to WebP/AVIF/JPG, target KB size, strip GPS | $0.002 / image |

### Limits

Max 200 documents per run, 5 million characters per Markdown/HTML document, 25 MB per fetched resource, PDF size up to 100 MB (default limit 50 MB), 180 s timeout per document. Header/footer templates can't load external images; use inline `data:` images. Questions or feature requests: use the **Issues** tab.

# Actor input Schema

## `documents` (type: `array`):

List of documents. Each item is an object with exactly one of "markdown", "html" or "url", plus optional "fileName" (without .pdf) and "title". Example: \[{"markdown": "# Report\n\nHello", "fileName": "report"}, {"url": "https://example.com"}]. Max 200 per run; each Markdown/HTML document up to 5 million characters.

## `markdown` (type: `string`):

Optional quick way to convert one Markdown document. Added to the Documents list. GitHub Flavored Markdown: tables, task lists, fenced code with syntax highlighting, strikethrough, autolinks.

## `html` (type: `string`):

Optional quick way to convert one HTML document or fragment. Added to the Documents list. Scripts are not executed for HTML input.

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

Optional public http(s) pages to print to PDF (one PDF each). Added to the Documents list. Private, loopback, link-local and cloud-metadata addresses are blocked.

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

Optional file name (without .pdf) used for the Markdown or HTML shortcut fields.

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

Page size of the PDF: A4 (most of the world) or US Letter/Legal (USA, Canada), plus A5, A3 and Tabloid.

## `landscape` (type: `boolean`):

Turn the page sideways (good for wide tables).

## `pageNumbers` (type: `boolean`):

Add "Page X of Y" at the bottom of every page. Ignored if you set your own footer template.

## `marginTop` (type: `string`):

CSS length, e.g. 15mm, 0.5in, 20px. Default 15mm (18mm with header/footer/page numbers).

## `marginRight` (type: `string`):

CSS length, e.g. 15mm, 0.5in, 20px. Default 15mm.

## `marginBottom` (type: `string`):

CSS length, e.g. 15mm, 0.5in, 20px. Default 15mm (18mm with header/footer/page numbers).

## `marginLeft` (type: `string`):

CSS length, e.g. 15mm, 0.5in, 20px. Default 15mm.

## `printBackground` (type: `boolean`):

Include background colors and images (table stripes, code block shading, colored banners).

## `headerTemplate` (type: `string`):

Optional HTML shown at the top of every page. Use classes pageNumber, totalPages, title, date and url to insert values, e.g. <div style="font-size:8px;width:100%;text-align:right;padding-right:15mm"><span class="title"></span></div>. Set an explicit font-size (Chromium defaults to a tiny size).

## `footerTemplate` (type: `string`):

Optional HTML shown at the bottom of every page (same placeholders as the header). Replaces the default page-number footer.

## `customCss` (type: `string`):

Extra CSS applied to every document (after the default stylesheet), e.g. body { font-family: Georgia, serif; } h1 { color: #0b5394; }. For URL documents it is injected after the page loads.

## `useDefaultStyles` (type: `boolean`):

Style Markdown like GitHub: readable fonts, bordered/striped tables, shaded code blocks with syntax highlighting. Turn off to start from a blank page and use only your Custom CSS.

## `htmlUseDefaultStyles` (type: `boolean`):

Also apply the clean stylesheet to HTML documents (off by default so your HTML looks exactly as written).

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

Zoom factor for the content, 0.1–2 (default 1). Use 0.8 to fit wide content.

## `preferCSSPageSize` (type: `boolean`):

If your HTML/CSS declares @page { size: ... }, use it instead of Paper size.

## `firstPagePng` (type: `boolean`):

Also save a PNG image of the first page (handy for thumbnails, chat previews and AI agents that can see images). Included in the same price.

## `pngDpi` (type: `integer`):

Resolution of the page-1 PNG in DPI (36–200). 110 ≈ 910 px wide for A4.

## `mediaType` (type: `string`):

print uses the page's print styles (default); screen makes web pages look like they do in a browser window.

## `waitUntil` (type: `string`):

When a web page counts as loaded before printing. networkidle is best for JavaScript-heavy pages but slower.

## `waitForMillis` (type: `integer`):

Extra time to wait after loading, for animations or lazy content (0–15000 ms).

## `timeoutSecs` (type: `integer`):

How long to wait for a page or its images to load before giving up (failed documents are not charged).

## `urlJavaScript` (type: `boolean`):

Allow web pages to run their own JavaScript (needed by most modern sites). JavaScript never runs for Markdown/HTML input.

## `allowRemoteResources` (type: `boolean`):

Let Markdown/HTML documents load public images, fonts and stylesheets by URL. Private and internal addresses are always blocked.

## `maxPdfSizeMb` (type: `integer`):

PDFs larger than this are discarded with an OUTPUT_TOO_LARGE error (not charged). Max 100.

## Actor input object example

```json
{
  "documents": [
    {
      "fileName": "weekly-report",
      "markdown": "# Weekly Report\n\n- [x] Shipped"
    },
    {
      "fileName": "invoice-1042",
      "html": "<h1>Invoice #1042</h1><p>Total: $300</p>"
    },
    {
      "url": "https://example.com"
    }
  ],
  "markdown": "# Hello\n\nThis becomes a **PDF**.\n\n| Item | Qty |\n| --- | ---: |\n| Widgets | 3 |",
  "html": "<h1>Invoice #1042</h1><table><tr><th>Item</th><th>Total</th></tr><tr><td>Design</td><td>$300</td></tr></table>",
  "urls": [
    "https://example.com"
  ],
  "fileName": "weekly-report",
  "format": "Letter",
  "landscape": false,
  "pageNumbers": true,
  "marginTop": "15mm",
  "marginRight": "15mm",
  "marginBottom": "15mm",
  "marginLeft": "15mm",
  "printBackground": true,
  "footerTemplate": "<div style=\"font-size:8px;width:100%;text-align:center\">Page <span class=\"pageNumber\"></span> of <span class=\"totalPages\"></span></div>",
  "customCss": "body { font-family: Georgia, serif; } h1 { color: #0b5394; }",
  "useDefaultStyles": true,
  "htmlUseDefaultStyles": false,
  "scale": 1,
  "preferCSSPageSize": false,
  "firstPagePng": false,
  "pngDpi": 110,
  "mediaType": "print",
  "waitUntil": "load",
  "waitForMillis": 0,
  "timeoutSecs": 45,
  "urlJavaScript": true,
  "allowRemoteResources": true,
  "maxPdfSizeMb": 50
}
```

# Actor output Schema

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

Dataset rows: index, sourceType, fileName, status, pages, bytes, pdfUrl, pngUrl, errorCode, error, charged.

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

Keys of the PDF (and PNG preview) files saved in the default 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 = {
    "documents": [
        {
            "fileName": "sample-report",
            "markdown": "# Weekly Report\n\nGenerated with **Markdown & HTML to PDF**.\n\n| Item | Qty | Price |\n| --- | ---: | ---: |\n| Widgets | 3 | $12.00 |\n| Gadgets | 1 | $4.50 |\n\n- [x] Tables, lists and task lists\n- [x] Code blocks with highlighting\n- [ ] Your content here\n\n```js\nconsole.log('Hello PDF');\n```\n\n> Tip: set `format`, `landscape` and `pageNumbers` to control the layout."
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bigaceboy/markdown-html-to-pdf").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 = { "documents": [{
            "fileName": "sample-report",
            "markdown": """# Weekly Report

Generated with **Markdown & HTML to PDF**.

| Item | Qty | Price |
| --- | ---: | ---: |
| Widgets | 3 | $12.00 |
| Gadgets | 1 | $4.50 |

- [x] Tables, lists and task lists
- [x] Code blocks with highlighting
- [ ] Your content here

```js
console.log('Hello PDF');
````

> Tip: set `format`, `landscape` and `pageNumbers` to control the layout.""",
> }] }

# Run the Actor and wait for it to finish

run = client.actor("bigaceboy/markdown-html-to-pdf").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 '{
  "documents": [
    {
      "fileName": "sample-report",
      "markdown": "# Weekly Report\\n\\nGenerated with **Markdown & HTML to PDF**.\\n\\n| Item | Qty | Price |\\n| --- | ---: | ---: |\\n| Widgets | 3 | $12.00 |\\n| Gadgets | 1 | $4.50 |\\n\\n- [x] Tables, lists and task lists\\n- [x] Code blocks with highlighting\\n- [ ] Your content here\\n\\n```js\\nconsole.log('\''Hello PDF'\'');\\n```\\n\\n> Tip: set `format`, `landscape` and `pageNumbers` to control the layout."
    }
  ]
}' |
apify call bigaceboy/markdown-html-to-pdf --silent --output-dataset

````

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bigaceboy/markdown-html-to-pdf"
        }
    }
}
```

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/2bf7v3Vu9zdaGtGcs/builds/yEsOk5qJsqwJLBbcq/openapi.json
