# URL to Markdown: Clean Text for RAG & LLMs (`kizukidata/url-to-markdown`) Actor

Extract text from a web page as Markdown and plain text over HTTP, keeping headings, links, tables, and code while dropping menus and footers for RAG and LLMs. JavaScript-only pages are skipped for free.

- **URL**: https://apify.com/kizukidata/url-to-markdown.md
- **Developed by:** [Kizuki](https://apify.com/kizukidata) (community)
- **Categories:** AI, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 0 monthly users, 91.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.23 / 1,000 results

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

### What does URL to Markdown do?

Extract text from a web page as Markdown and plain text for RAG pipelines, AI agents, and LLMs. Preserves headings, links, tables, lists, code blocks, and blockquotes while stripping navigation menus, cookie banners, sidebars, and footers.

Pass a list of URLs to fetch and convert over HTTP (ten pages in a few seconds); empty input (`{}`) converts three sample pages in about a second.

### Switching from another web page or Markdown scraper

If you already pass URLs to another web scraper or Markdown converter, you can point your existing input JSON at this Actor without renaming fields. Common input field names map directly to URL to Markdown fields, and any sample defaults are replaced when your URL list or page limit is set through an alias.

| Common input field name | Mapped field | Notes |
|---|---|---|
| `startUrls`, `pageUrls`, `sourceUrls`, `requests` | `urls` | Accepts string lists or `{"url": "..."}` objects |
| `url`, `targetUrl`, `websiteUrl`, `pageUrl`, `startUrl`, `inputUrl`, `query`, `queries` | `urls` | Single URL or separator-split list. `query` and `queries` must hold `http`/`https` URLs; plain search words are rejected as invalid input and nothing is charged |
| `maxCrawlPages`, `maxPagesPerCrawl`, `maxResults`, `maxResultsPerCrawl`, `resultsLimit`, `limit`, `maxPages`, `maxRows` | `maxItems` | `0` or values above 200 map to 200; if several limit fields are passed, the smallest is used |
| `maxContentLength`, `maxChars`, `maxBodyChars` | `maxCharsPerPage` | `0` or values above 500000 map to 500000 |
| `respectRobotsTxtFile`, `respectRobots` | `respectRobotsTxt` | Boolean; `ignoreRobotsTxt` and `ignoreRobots` invert the flag |
| `extractLinks` | `includeLinks` | Boolean |
| `proxy`, `proxyConfig`, `proxyUrl` | `proxyConfiguration` | Proxy object or single proxy URL string |

This Actor converts only the URLs you pass and does not follow links. Crawler-only settings such as depth limits, URL globs, browser flags, and CSS selectors are ignored without warning. If you pass both a field and its alias, the alias wins over a field left at its default. You can drop in an existing payload such as:

```json
{
    "startUrls": [
        { "url": "https://en.wikipedia.org/wiki/Markdown" },
        { "url": "https://developer.mozilla.org/en-US/docs/Web/HTML" }
    ],
    "maxCrawlPages": 10,
    "respectRobotsTxtFile": true
}
```

Each run fetches only the URLs you provide once over HTTP; it does not follow links across a site or run a browser. Pages that need JavaScript, return non-HTML content, or fail or refuse the request write no dataset row, cost nothing, and appear with their reason in the `OUTPUT` record (`skippedInputs` or `failedInputs`).

Under Launch pricing, converted pages cost $0.33 per 1,000 pages on the Free tier ($0.28 on Starter/Bronze, $0.24 on Scale/Silver, $0.23 on Business/Gold), plus a $0.00005 run start fee at 1 GB. Apify's USD 5 monthly Free plan credit covers about 15,151 converted pages, run start fees aside.

### Use cases

- **Material for RAG and LLMs.** One row per page with clean Markdown, so a chunk quotes the article, not the
  navigation.
- **A folder of pages at once.** Ten pages in a few seconds, without a browser or a proxy.
- **Read what a page links to, first.** `links` gives an agent the next pages to read before it fetches them.
- **A scheduled collection of pages.** Feed a list of URLs from a sheet, a crawler or another Actor and keep one
  table.
- **Comparison and research.** Keep the page's own title, description, author, publish time and language next to
  the text.

### What data can you get?

| Field | Description |
|---|---|
| `id` | Stable page ID (a hash of the URL) |
| `url`, `finalUrl` | The URL you gave, and where the page was actually served from |
| `title` | Page title (the `title` element, else the first `h1`) |
| `status` | `ok` (written only for successfully converted pages) |
| `markdown` | The page's main content as Markdown, cut to `maxCharsPerPage` (never empty) |
| `text` | The same content as plain text, without the Markdown syntax |
| `links` | Absolute links found in the content (up to 500) when `includeLinks` is on |
| `charCount`, `byteCount` | Size of the Markdown, and of the downloaded response |
| `truncated` | `true` when `maxCharsPerPage` cut the page |
| `description`, `author`, `publishedAt` | The summary, author and publication time the page states (`meta` tags, else the page's JSON-LD) |
| `siteName`, `image` | The site's own name, and its social image as an absolute URL |
| `languageCode` | Primary language subtag the page declares (`en`, `ja`, …) |
| `httpStatus` | Status code of the response that was converted (normally 200) |
| `scrapedAt` | When the page was converted |

Every row has every field; a value the page does not provide (a title, for example) is `null`. The metadata
fields are read from the page's `<head>` only: nothing is guessed, so a page that states no author gives
`author: null`.

### How to use URL to Markdown

1. Paste the page URLs into **Page URLs** (`urls`), one per entry (up to 200 per run).
2. Optionally set **Maximum pages** (`maxItems`), **Maximum characters per page** (`maxCharsPerPage`), or turn off **Collect page links** (`includeLinks`).
3. Run the Actor and read the dataset, or take the `markdown` field of each row.

For PDFs instead of pages, PDF to Markdown Extractor converts the file and keeps the page numbers.

#### Input example

```json
{
    "urls": [
        "https://en.wikipedia.org/wiki/Markdown",
        "https://developer.mozilla.org/en-US/docs/Web/HTML"
    ],
    "maxItems": 10,
    "maxCharsPerPage": 40000
}
```

### Input

| Field | Default | Meaning |
|---|---|---|
| `urls` | three small public sample pages | The page URLs to convert, one per entry (up to 200) |
| `maxItems` | 5 | **Maximum pages** per run; the same number also stops the work, so pages beyond it are not downloaded |
| `maxCharsPerPage` | 40000 (at most 500000) | **Maximum characters per page**; a longer page is cut and marked `truncated` |
| `includeLinks` | true | **Collect page links**: adds the content's absolute links to `links` (up to 500) |
| `respectRobotsTxt` | true | **Respect robots.txt**; a path a host disallows for this Actor is not returned and not charged |

### Output

One row per converted page (the default dataset):

```json
{
    "id": "6a47643138a7242a",
    "source": "url",
    "url": "https://developer.mozilla.org/en-US/docs/Web/HTML",
    "finalUrl": "https://developer.mozilla.org/en-US/docs/Web/HTML",
    "title": "HTML: HyperText Markup Language | MDN",
    "description": "HTML (HyperText Markup Language) is the most basic building block of the Web. It defines the meaning and structure of web content.",
    "author": null,
    "publishedAt": null,
    "siteName": "MDN Web Docs",
    "image": "https://developer.mozilla.org/mdn-social-image.46ac2375.png",
    "languageCode": "en",
    "httpStatus": 200,
    "status": "ok",
    "markdown": "# HTML: HyperText Markup Language\n\n**HTML** (HyperText Markup Language) is the most basic building block of the Web…",
    "text": "HTML: HyperText Markup Language HTML (HyperText Markup Language) is the most basic building block of the Web…",
    "links": ["https://developer.mozilla.org/en-US/docs/Web/CSS"],
    "charCount": 13352,
    "byteCount": 186758,
    "truncated": false,
    "scrapedAt": "2026-11-04T09:00:00.000Z"
}
```

#### What is kept, and what is not

- **Main content first**: the page's `article` or `main` region is used when it has one, otherwise the body;
  navigation, sidebars, footers, forms and site furniture inside it are removed.
- **Kept**: headings, paragraphs, links (made absolute), images (as `![alt](url)`), tables, ordered and unordered
  lists, code blocks, inline code, bold and emphasis, blockquotes.
- **Tables are written as GitHub-style pipe tables**: a `|` inside a cell is escaped, a table without a header row
  gets an empty header row, so its first row stays a data row, and a table inside a cell is flattened to its text. A link's text keeps its
  brackets (`[Array\[0\]]`), and a URL with parentheses is written in angle brackets, so both parse back exactly.
- **Not kept**: layout, styling, comment threads outside the content region, pagination, and anything that only
  renders after JavaScript — those pages write no row and are listed in `OUTPUT`.

### How much does it cost?

URL to Markdown uses **pay-per-event** pricing: you pay for the pages it converts, not for the time it runs.

| Apify plan (discount tier) | Price per 1,000 pages | Price per page |
|---|---|---|
| **Free** | $0.33 | $0.00033 |
| **Starter (Bronze)** | $0.28 | $0.00028 |
| **Scale (Silver)** | $0.24 | $0.00024 |
| **Business (Gold)** | $0.23 | $0.00023 |

Apify's Free plan includes USD 5 of monthly usage, which covers about 15,151 pages at the Free tier price, run
start fees aside.

- **Run start fee**: USD 0.00005 per GB of memory per run (USD 0.00005 at this Actor's default 1 GB).
- A page is charged once, whether it is a short note or a long article.
- **You pay only for pages with content.** A URL that produced no converted page is not charged: an invalid URL,
  a private address, a path disallowed by robots.txt, a page that needs JavaScript, a response that is not HTML,
  an empty page, or a page the site refused (403, 429, a challenge page) or no longer has (404, 410) is listed in
  the run's `OUTPUT` record with the reason and costs nothing.
- The empty-input sample (three pages) costs about $0.001 on the Free plan.
- **Maximum pages** and your run's maximum cost cap the charge.

### Use with AI agents (MCP)

URL to Markdown works as a tool for AI agents such as Claude, Cursor and n8n agents through the Apify MCP server. Load this Actor, plus the tool that reads its input schema and pricing, with this server URL:

```text
https://mcp.apify.com?tools=fetch-actor-details,kizukidata/url-to-markdown
```

- **Claude Code**: run `claude mcp add apify "https://mcp.apify.com?tools=fetch-actor-details,kizukidata/url-to-markdown" -t http`.
- **Claude (web or desktop app)**: open **Customize → Connectors**, choose **Add custom connector**, name it `Apify` and paste the server URL above.
- **Cursor**: add the server to `~/.cursor/mcp.json` (or `.cursor/mcp.json` in a project):

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

- **n8n**: add the Apify node (on self-hosted n8n, install the community package `@apify/n8n-nodes-apify`) and choose **Run an Actor and get dataset**; for an n8n AI Agent, add **Apify Tool** as a tool.

The server signs you in to Apify with OAuth. A client that cannot use OAuth can send your Apify API token in an `Authorization: Bearer <APIFY_TOKEN>` header instead.

#### What to send from an agent

- Calling it with **no arguments** (`{}`) converts three small sample pages in about a second.
- Every URL you send comes back as one row when it converts, or is listed in `OUTPUT` (`skippedInputs`,
  `failedInputs` or `uncheckedInputs`) with a fixed reason, so an agent never has to parse an error: "only renders
  with JavaScript" means "open it with a browser-capable tool", "not an HTML page" means "this was a file, not a
  page" (for a PDF, use PDF to Markdown Extractor), and an entry in `failedInputs` means the site refused the
  request, did not answer, sent more than 10 MB, or answered in a shape this Actor cannot read.
- `links` gives the agent the next pages to read without fetching them first.

### Integrations and API

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/kizukidata~url-to-markdown/runs" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"urls":["https://example.com/article"],"maxItems":10}'
```

Poll `GET https://api.apify.com/v2/actor-runs/<RUN_ID>` for the status, read `defaultDatasetId`, then fetch
`GET https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=json`.

#### n8n, Make and Zapier

Use the Apify integration, choose **Run Actor**, pass the URL list, then **Get dataset items**. A schedule over a
list of URLs keeps the Markdown fresh without a browser step.

### Limitations

- **Independent tool, no login.** Not affiliated with, endorsed by or sponsored by any of the sites whose pages you convert. Non-HTML, empty, or JS-only pages write no row (listed in `OUTPUT`) and are not charged.
- **No JavaScript rendering.** Single-page applications write no row (listed in `OUTPUT`, not charged); use a
  browser-capable tool for those.
- **Extraction is a rule-based approximation**: an unusual layout can leave a sidebar sentence in the text or drop a
  caption. The page's own `article`/`main` region is the main signal.
- **Tables become pipe tables**; merged cells are flattened, and a table nested inside a cell is flattened to its
  text (Markdown has no nested tables).
- **Only `http` and `https` URLs** are accepted, and local and private addresses are refused (loopback, private
  ranges, link-local) so the Actor can not be pointed at the platform's internal network.
- **A response larger than 10 MB** is rejected: the URL is listed in `failedInputs`, the page is not returned
  and no result is charged (the run start fee still applies).
- **Runs use 1 GB of memory.** Converting a page holds its whole HTML in memory.
- **No links are followed.** The Actor converts exactly the URLs you give it; `links` only reports them.
- **Pages behind a CAPTCHA or a login are not read**; they are reported as blocked.

#### Run status and the OUTPUT record

Each run ends with a short status message and writes an `OUTPUT` record to its key-value store with the counts
(requests, pages read, pages returned, blocked requests) and:

- `skippedInputs`: entries that were invalid, duplicated, private addresses, not found (404/410), disallowed by
  robots.txt, gave no content (needs JavaScript, not HTML, empty page), or were over `maxItems`, with their
  position in your list and the reason. None of them is charged;
- `failedInputs`: entries the site refused (403, 429, a challenge page), that never answered (a timeout or
  repeated connection errors), that sent a page larger than 10 MB, or that came back in a shape this Actor cannot
  read, with their position in your list and a fixed reason. None of them is charged;
- `uncheckedInputs`: entries the run did not reach because it stopped first (no budget left, or every site in the
  list refused). Entries over `maxItems` are in `skippedInputs`, not here.

Refusals are counted site by site: when one site in your list refuses several of its own pages, only the rest of
**that site's** URLs are skipped (with their reason in `failedInputs`) and the other sites are still read. The run
stops because of refusals only when every site in the list has refused, so one site that says no cannot keep the
URLs of other sites from being converted. `maxItems` or the run's spending limit can end a run as well; the pages
it did not reach are listed in `uncheckedInputs`.

A run **fails** only when the Actor stops on a problem on its own side: an unexpected error, a page whose
structure this build no longer reads (the Actor needs an update), or a request that failed in a way it cannot
attribute to the site (a failure that came back through a proxy, for example). You name every URL, so a site that
refuses them, a URL that times out or is too large to fetch, and a host that refuses the connection all end
**successfully** with an empty dataset: `OUTPUT` `failedInputs` gives the reason for each URL, and no result is
charged (the run start fee still applies). A page that needs JavaScript or gives a non-HTML response ends
**successfully** as well and says so in `OUTPUT`; a 404 or 410 is listed in `skippedInputs` as `not found` and
writes no row.

### FAQ

#### Why did a URL return no row?

Open the run's `OUTPUT` record. `failedInputs` lists the URLs the site refused (403, 429, a challenge page), that
never answered, that sent more than 10 MB, or that came back in a shape this Actor cannot read, with the position in
your list and the reason; `skippedInputs` lists the ones with nothing to convert (invalid, duplicate, 404,
robots.txt, JavaScript-only, not HTML, empty). Nothing in either list is charged. A page whose HTML is a shell that
a browser fills in with JavaScript (a single-page app, for example) has nothing to convert: this Actor never runs a
browser, so open such a page with a browser-capable tool. Some sites also refuse requests that do not come from a
browser; those URLs are listed in `failedInputs` and are not charged. Use a browser-capable tool for them, or set
`proxyConfiguration` with your own proxy.

#### Why is a page shorter than the original?

Check `truncated` and `charCount`. **Maximum characters per page** cuts long pages; raise it (up to 500000) and
run again.

#### Why is `author` null although the article has a byline?

The metadata is read from the page's `<head>` (meta tags and JSON-LD) only. A byline that exists only in the body
text is not promoted into `author`, so the field stays `null` instead of guessing.

#### Can it read a PDF or an image URL?

No. A response that is not HTML writes no row and is listed in `OUTPUT`; use PDF to Markdown Extractor for a PDF.

#### Is it legal to use this data?

The Actor fetches the page you point it at, once, like a browser, without login. How you use the text is your
responsibility; check the terms of the sites you read and the law where you operate, and handle personal data in
line with it (for example GDPR or CCPA). Published articles may also be protected by copyright. This is not legal
advice.

### Related Kizuki Actors

Other Actors from Kizuki that work well with this one:

- [PDF to Markdown Extractor](https://apify.com/kizukidata/pdf-to-markdown) — page-numbered Markdown from PDF files, for the same RAG pipeline.
- [YouTube Transcript Scraper](https://apify.com/kizukidata/youtube-transcripts) — transcripts with timestamps and chunks, the video side of the same corpus.
- [Google News Scraper](https://apify.com/kizukidata/google-news-feed) — a list of the outlets' own article URLs (`articleUrl`) on any topic, ready to convert here.
- [WeChat Article Scraper](https://apify.com/kizukidata/wechat-article-reader) — WeChat Official Account articles as text and Markdown, with the account and publish time as named fields.
- [MCP Server Registry Scraper](https://apify.com/kizukidata/mcp-server-directory) — one row per public MCP server from the MCP Registry, Smithery and awesome-mcp-servers, with `repository` and `homepage` URLs to convert here.
- [Website Contact Scraper](https://apify.com/kizukidata/website-contact-intelligence) — the contact and careers page URLs of a company, one row per domain, ready to convert here.

### Your feedback

Found a page that converts badly? Open an Issue in this Actor's Issues tab with the run ID and the URL. If you run
a site and do not want your pages read, name the URL pattern in an Issue; runs then skip it without sending a
request and list it in the `OUTPUT` record as `excluded at the site owner's request`.

# Actor input Schema

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

Up to 200 web page URLs. Empty converts 3 sample pages. Fetches each page once (no link crawling); refused or empty pages return free in OUTPUT.

## `maxItems` (type: `integer`):

Max pages to convert per run (1-200, default 5). Each converted page is charged; excess URLs go to OUTPUT skippedInputs.

## `maxCharsPerPage` (type: `integer`):

Max Markdown characters per page (1000-500000, default 40000). Longer pages are cut with truncated: true.

## `includeLinks` (type: `boolean`):

true (default) includes up to 500 absolute content links in links; false leaves links empty. Menus and footers are excluded either way.

## `respectRobotsTxt` (type: `boolean`):

true (default) skips paths disallowed by robots.txt (listed in OUTPUT, free); false ignores robots.txt (use only when allowed).

## `proxyConfiguration` (type: `object`):

Leave empty or {} for direct connection. Set {"useApifyProxy": true} for Apify datacenter proxy (no residential proxies).

## Actor input object example

```json
{
  "urls": [
    "https://en.wikipedia.org/wiki/Markdown"
  ],
  "maxItems": 5,
  "maxCharsPerPage": 40000,
  "includeLinks": true,
  "respectRobotsTxt": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Pages returned by this run, with their Markdown, text and links.

## `runSummary` (type: `string`):

Status code, counters, the input entries that were skipped, the entries the site refused (failedInputs; a site that refused several of its own pages stops only its remaining URLs), and the entries not checked.

# 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 = {
    "urls": [
        "https://en.wikipedia.org/wiki/Markdown",
        "https://developer.mozilla.org/en-US/docs/Web/HTML",
        "https://example.com/"
    ],
    "maxItems": 5,
    "maxCharsPerPage": 40000,
    "includeLinks": true,
    "respectRobotsTxt": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kizukidata/url-to-markdown").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 = {
    "urls": [
        "https://en.wikipedia.org/wiki/Markdown",
        "https://developer.mozilla.org/en-US/docs/Web/HTML",
        "https://example.com/",
    ],
    "maxItems": 5,
    "maxCharsPerPage": 40000,
    "includeLinks": True,
    "respectRobotsTxt": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("kizukidata/url-to-markdown").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 '{
  "urls": [
    "https://en.wikipedia.org/wiki/Markdown",
    "https://developer.mozilla.org/en-US/docs/Web/HTML",
    "https://example.com/"
  ],
  "maxItems": 5,
  "maxCharsPerPage": 40000,
  "includeLinks": true,
  "respectRobotsTxt": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call kizukidata/url-to-markdown --silent --output-dataset

```

## MCP server setup

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

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/OjoTmqGeAQVv9BBR6/builds/N9ETxEXOP2PbmMdDt/openapi.json
