# Telegram Channel Scraper — Posts, Views & Engagement (`viralanalyzer/telegram-channel-scraper`) Actor

Extract posts, view counts, subscriber numbers, and engagement metrics from public Telegram channels. Pure HTTP via t.me/s/ public preview — no API key, no login. Track competitors, monitor channels, and analyze reach for growth and market research. Clean JSON.

- **URL**: https://apify.com/viralanalyzer/telegram-channel-scraper.md
- **Developed by:** [viralanalyzer](https://apify.com/viralanalyzer) (community)
- **Categories:** Social media
- **Features:** Limited permissions
- **Stats:** 230 total users, 5 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 4.82 out of 5 stars

## Pricing

from $15.75 / 1,000 post scrapeds

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

## 📡 Telegram Channel Scraper — Posts, Views, Subscribers & Engagement Analytics

> **$0.03 per post** · 📡 public channels · ⚡ no API key or bot token needed
> 🔗 [View on Apify Store](https://apify.com/viralanalyzer/telegram-channel-scraper) | 🇺🇸 English | [🇧🇷 Português](#português)

Extract **posts, view counts, subscriber numbers, and engagement metrics** from public Telegram channels. Uses t.me/s/ public preview pages — pure HTTP with Cheerio parsing, no Telegram API key or bot token needed.

**Who it's for:** social-media analysts, crypto & community researchers, OSINT investigators, and growth teams who need public-channel metrics without an API key or bot token.

▶️ Click **Try for free** — your first run returns real data in seconds.

### ✨ Features

- **Multi-channel scraping** — Analyze up to 50 public Telegram channels per run
- **Post extraction** — Full text, views, date, media type, forwarded source
- **Subscriber count** — Channel subscriber/member numbers
- **Channel analytics summary** — Average views, median views, max views, engagement rate, media ratio
- **Media detection** — Classifies photo, video, document, sticker, and poll content
- **Forwarded post attribution** — Identifies the original channel for forwarded posts
- **Pagination** — Automatically loads older posts via before= parameter
- **Flexible input** — Accepts usernames, @handles, or full t.me URLs
- **Anti-placeholder guardrails** — Every result validated against placeholder patterns
- **Pure HTTP** — Uses got-scraping + Cheerio, no browser needed

### 📥 Input

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `channels` | string\[] | Yes | — | Telegram channel usernames or URLs. Accepts "durov", "@durov", "https://t.me/durov", or "https://t.me/s/durov" (1-50 channels) |
| `maxPostsPerChannel` | integer | No | 50 | Maximum number of posts to extract per channel (1-500) |
| `proxyConfiguration` | object | No | — | Proxy settings. May be needed if Telegram blocks your IP |

#### Input Example

```json
{
  "channels": [
    "durov",
    "https://t.me/telegram",
    "@bbcnews"
  ],
  "maxPostsPerChannel": 100
}
```

### 📤 Output

Each run produces **channel_summary** (one per channel) and **post** (one per post). When a username is not a readable public channel (a personal account, a private channel, or a non-existent username — `t.me/s/<name>` redirects to a contact page), the run emits a **channel_diagnostic** item instead with `_dataQuality: "diagnostic"` and `_blockReason: "not_a_public_channel"`, and **that item is not charged**. A metric the page did not expose is returned as `null`, never a fabricated `0`.

#### Post Fields

| Field | Type | Description |
|---|---|---|
| `type` | string | Always "post" |
| `postId` | number | Telegram post ID (numeric) |
| `postUrl` | string | Direct link to the post (https://t.me/username/postId) |
| `text` | string | Full post text content |
| `views` | number | View count (parsed from K/M suffixes) |
| `viewsText` | string | Raw view text as displayed (e.g., "12.5K") |
| `mediaType` | string | Content type: none, photo, video, document, sticker, or poll |
| `mediaUrl` | string | Media URL (available for photos) |
| `hasReply` | boolean | Whether the post has a reply |
| `forwardedFrom` | string | Original channel name if forwarded, empty otherwise |
| `publishedAt` | string | Post publication date (ISO 8601) |
| `channelName` | string | Channel display name |
| `channelUsername` | string | Channel username |
| `channelSubscribers` | number | Channel subscriber count |
| `platform` | string | Always "telegram" |
| `scrapedAt` | string | ISO 8601 scrape timestamp |

#### Channel Summary Fields

| Field | Type | Description |
|---|---|---|
| `type` | string | Always "channel_summary" |
| `channelName` | string | Channel display name |
| `channelUsername` | string | Channel username |
| `channelSubscribers` | number | null | Total subscriber count; `null` when the page did not expose it (never a fabricated 0) |
| `channelDescription` | string | Channel bio/description |
| `channelPhotoUrl` | string | Channel profile photo URL |
| `postCount` | number | Number of posts analyzed |
| `avgViews` | number | null | Average views per post; `null` when no post was read |
| `medianViews` | number | null | Median views per post; `null` when no post was read |
| `maxViews` | number | null | Highest view count; `null` when no post was read |
| `engagementRate` | number | null | Average views / subscribers (0-1); `null` when it cannot be measured |
| `postsWithMedia` | number | Count of posts containing media |
| `postsForwarded` | number | Count of posts forwarded from other channels |
| `topPostText` | string | Text of the most-viewed post (first 200 chars) |
| `topPostViews` | number | View count of the most-viewed post |
| `platform` | string | Always "telegram" |
| `scrapedAt` | string | ISO 8601 scrape timestamp |

#### Output Example

```json
{
  "type": "post",
  "postId": 1042,
  "postUrl": "https://t.me/durov/1042",
  "text": "Telegram now has 950 million monthly active users. We hope to pass the one billion mark soon.",
  "views": 4832100,
  "viewsText": "4.8M",
  "mediaType": "photo",
  "mediaUrl": "https://cdn4.telegram-cdn.org/file/abc123.jpg",
  "hasReply": false,
  "forwardedFrom": "",
  "publishedAt": "2026-02-15T18:30:00+00:00",
  "channelName": "Pavel Durov",
  "channelUsername": "durov",
  "channelSubscribers": 12450000,
  "platform": "telegram",
  "scrapedAt": "2026-03-06T12:00:00.000Z"
}
```

### 📋 Use Cases

- **Channel Analytics** — Measure engagement rates, view trends, and content performance
- **Competitor Monitoring** — Track competitor Telegram channels and their posting strategies
- **Content Research** — Discover viral posts and high-performing content formats
- **Media Monitoring** — Track news channels and detect breaking stories
- **Influencer Analysis** — Evaluate channel reach, engagement, and audience size
- **Market Intelligence** — Monitor industry channels for trends and announcements

### ✅ Capabilities & Limits

Stated up front, so you do not pay a run to find out.

**Built here:** if the first request for a channel fails through the proxy, the same channel is retried with no proxy at all. That fallback covers the first page only - pagination keeps the proxy and stops quietly on failure, so a flaky proxy returns fewer posts than `maxPostsPerChannel` instead of an error.

| Input / feature | Supported | Notes |
|---|---|---|
| Public channel username | ✅ | `channels` — required; `durov` or `https://t.me/durov` both work |
| **Private channels** | ❌ | reads the public `t.me/s/` preview — anything requiring an invite or login is out of reach |
| Groups and direct messages | ❌ | channels only |
| Post volume | ⚠️ | `maxPostsPerChannel`; older posts are loaded by pagination |
| View counts and engagement | ✅ | included per post |
| Subscriber count | ✅ | from the channel summary |
| Telegram API key | ❌ | not needed — no key, no login, pure HTTP |
| Member list | ❌ | Telegram does not expose it publicly |

### ❓ FAQ

**Q: Can I scrape private Telegram channels?**
A: No. This actor only works with public channels that have a public preview at t.me/s/. Private channels and groups are not accessible without authentication.

**Q: Why are some view counts showing as 0?**
A: View counts are extracted from the HTML and parsed from human-readable formats (e.g., "4.8M", "12.5K"). Very new posts or channels with hidden view counts may return 0. The raw `viewsText` field is also included for reference.

**Q: What is the engagement rate and how is it calculated?**
A: The engagement rate in the channel summary is calculated as average views divided by subscriber count. A rate of 0.3 means posts are seen by 30% of subscribers on average.

**Q: How far back can I scrape posts?**
A: The actor paginates through the public preview pages using the before= parameter. You can go back up to 500 posts per channel. The actual depth depends on the channel's history and Telegram's preview page availability.

**Q: Do I need a Telegram API key or bot token?**
A: No. The actor uses the public t.me/s/ preview pages which are accessible via standard HTTP requests. No API credentials are needed.

### 💰 Pricing

This actor uses **Pay Per Event (PPE)** pricing:

| Metric | Cost |
|--------|------|
| post-scraped | $0.03 per post |

Example: scraping 3 channels x 50 posts each = 153 items (150 posts + 3 summaries) = $4.59

### 🔗 Related Actors

- [YouTube Fast Scraper](https://apify.com/viralanalyzer/youtube-fast-scraper) — YouTube video metrics
- [TikTok Viral Scanner](https://apify.com/viralanalyzer/tiktok-viral-scanner) — TikTok profile data
- [Instagram Reels Scraper](https://apify.com/viralanalyzer/instagram-reels-scraper) — Instagram metrics
- [Twitter/X Scraper](https://apify.com/viralanalyzer/twitter-scraper) — Twitter post extraction

### 📝 Changelog

#### v1.1 (2026-09-24)

- A username that is not a readable public channel (personal account, private, or non-existent — `t.me/s/<name>` redirects to a contact page) now emits a `channel_diagnostic` item instead of a `channel_summary` full of zeros, and it is **not charged**
- Unmeasured metrics (`channelSubscribers`, `avgViews`, `medianViews`, `maxViews`, `engagementRate`) are returned as `null` instead of `0`

#### v1.0

- Public channel post extraction via t.me/s/ preview pages
- Subscriber count and channel metadata extraction
- Post pagination via before= parameter
- Media type detection (photo, video, document, sticker, poll)
- Forwarded post attribution
- Channel summary with engagement analytics (avg/median/max views, engagement rate)
- Flexible input: accepts usernames, @handles, and full URLs
- Anti-placeholder guardrails for data integrity
- Rate limit handling with automatic retries
- PPE billing integration

***

<a name="português"></a>

## 📡 Telegram Channel Scraper — Posts, Visualizações, Inscritos & Analytics de Engajamento

> **$0.03 por post** · 📡 canais públicos · ⚡ sem chave de API ou bot token
> 🔗 [Ver na Apify Store](https://apify.com/viralanalyzer/telegram-channel-scraper) | [🇺🇸 English](#-telegram-channel-scraper--posts-views-subscribers--engagement-analytics) | 🇧🇷 Português

Extraia **posts, contagem de visualizações, número de inscritos e métricas de engajamento** de canais públicos do Telegram. Usa as páginas de preview públicas t.me/s/ — HTTP puro com parsing Cheerio, sem chave de API ou bot token do Telegram.

**Para quem é:** analistas de mídias sociais, pesquisadores de cripto & comunidades, investigadores OSINT e times de growth que precisam de métricas de canais públicos sem chave de API ou bot token.

▶️ Clique em **Testar grátis** — sua primeira execução retorna dados reais em segundos.

### ✨ Funcionalidades

- **Scraping multi-canal** — Analise até 50 canais públicos do Telegram por execução
- **Extração de posts** — Texto completo, visualizações, data, tipo de mídia, fonte encaminhada
- **Contagem de inscritos** — Número de inscritos/membros do canal
- **Resumo analítico do canal** — Média de views, mediana, máximo, taxa de engajamento, proporção de mídia
- **Detecção de mídia** — Classifica conteúdo de foto, vídeo, documento, sticker e enquete
- **Atribuição de posts encaminhados** — Identifica o canal original para posts encaminhados
- **Paginação** — Carrega posts mais antigos automaticamente via parâmetro before=
- **Entrada flexível** — Aceita usernames, @handles ou URLs completas do t.me
- **Guardrails anti-placeholder** — Todo resultado validado contra padrões falsos
- **HTTP puro** — Usa got-scraping + Cheerio, sem browser

### 📥 Entrada

| Parâmetro | Tipo | Obrigatório | Padrão | Descrição |
|---|---|---|---|---|
| `channels` | string\[] | Sim | — | Usernames ou URLs de canais do Telegram. Aceita "durov", "@durov", "https://t.me/durov" ou "https://t.me/s/durov" (1-50 canais) |
| `maxPostsPerChannel` | inteiro | Não | 50 | Número máximo de posts por canal (1-500) |
| `proxyConfiguration` | objeto | Não | — | Configuração de proxy. Pode ser necessário se o Telegram bloquear seu IP |

#### Exemplo de Entrada

```json
{
  "channels": [
    "durov",
    "https://t.me/telegram",
    "@bbcnews"
  ],
  "maxPostsPerChannel": 100
}
```

### 📤 Saída

Cada execução produz **channel_summary** (um por canal) e **post** (um por post). Quando o username não é um canal público legível (conta pessoal, canal privado ou username inexistente — `t.me/s/<name>` redireciona para a página de contato), a execução emite um item **channel_diagnostic** com `_dataQuality: "diagnostic"` e `_blockReason: "not_a_public_channel"`, e **esse item não é cobrado**. Métrica que a página não expôs vem `null`, nunca um `0` inventado.

#### Campos do Post

| Campo | Tipo | Descrição |
|---|---|---|
| `type` | string | Sempre "post" |
| `postId` | número | ID do post no Telegram (numérico) |
| `postUrl` | string | Link direto para o post (https://t.me/username/postId) |
| `text` | string | Conteúdo textual completo do post |
| `views` | número | Contagem de visualizações (parseado de sufixos K/M) |
| `viewsText` | string | Texto bruto de views como exibido (ex: "12.5K") |
| `mediaType` | string | Tipo de conteúdo: none, photo, video, document, sticker ou poll |
| `mediaUrl` | string | URL da mídia (disponível para fotos) |
| `hasReply` | boolean | Se o post tem resposta |
| `forwardedFrom` | string | Nome do canal original se encaminhado, vazio caso contrário |
| `publishedAt` | string | Data de publicação do post (ISO 8601) |
| `channelName` | string | Nome de exibição do canal |
| `channelUsername` | string | Username do canal |
| `channelSubscribers` | número | Contagem de inscritos do canal |
| `platform` | string | Sempre "telegram" |
| `scrapedAt` | string | Timestamp ISO 8601 da coleta |

#### Campos do Resumo do Canal

| Campo | Tipo | Descrição |
|---|---|---|
| `type` | string | Sempre "channel_summary" |
| `channelName` | string | Nome de exibição do canal |
| `channelUsername` | string | Username do canal |
| `channelSubscribers` | número | null | Total de inscritos; `null` quando a página não expôs (nunca um 0 inventado) |
| `channelDescription` | string | Bio/descrição do canal |
| `channelPhotoUrl` | string | URL da foto de perfil do canal |
| `postCount` | número | Número de posts analisados |
| `avgViews` | número | null | Média de visualizações por post; `null` quando nenhum post foi lido |
| `medianViews` | número | Mediana de visualizações por post |
| `maxViews` | número | Maior contagem de views entre os posts analisados |
| `engagementRate` | número | Razão média de views / inscritos (escala 0-1) |
| `postsWithMedia` | número | Quantidade de posts contendo mídia |
| `postsForwarded` | número | Quantidade de posts encaminhados de outros canais |
| `topPostText` | string | Texto do post mais visualizado (primeiros 200 caracteres) |
| `topPostViews` | número | Views do post mais visualizado |
| `platform` | string | Sempre "telegram" |
| `scrapedAt` | string | Timestamp ISO 8601 da coleta |

#### Exemplo de Saída

```json
{
  "type": "post",
  "postId": 1042,
  "postUrl": "https://t.me/durov/1042",
  "text": "Telegram now has 950 million monthly active users. We hope to pass the one billion mark soon.",
  "views": 4832100,
  "viewsText": "4.8M",
  "mediaType": "photo",
  "mediaUrl": "https://cdn4.telegram-cdn.org/file/abc123.jpg",
  "hasReply": false,
  "forwardedFrom": "",
  "publishedAt": "2026-02-15T18:30:00+00:00",
  "channelName": "Pavel Durov",
  "channelUsername": "durov",
  "channelSubscribers": 12450000,
  "platform": "telegram",
  "scrapedAt": "2026-03-06T12:00:00.000Z"
}
```

### 📋 Casos de Uso

- **Analytics de Canal** — Meça taxas de engajamento, tendências de views e performance de conteúdo
- **Monitoramento de Concorrentes** — Acompanhe canais de concorrentes e estratégias de postagem
- **Pesquisa de Conteúdo** — Descubra posts virais e formatos de conteúdo de alta performance
- **Monitoramento de Mídia** — Acompanhe canais de notícias e detecte matérias em destaque
- **Análise de Influenciadores** — Avalie alcance, engajamento e tamanho da audiência
- **Inteligência de Mercado** — Monitore canais do setor para tendências e anúncios

### ❓ Perguntas Frequentes

**P: Posso extrair dados de canais privados do Telegram?**
R: Não. Este actor funciona apenas com canais públicos que possuem preview público em t.me/s/. Canais e grupos privados não são acessíveis sem autenticação.

**P: Por que algumas contagens de visualização aparecem como 0?**
R: As contagens de views são extraídas do HTML e parseadas de formatos legíveis (ex: "4.8M", "12.5K"). Posts muito recentes ou canais com views ocultas podem retornar 0. O campo bruto `viewsText` também é incluído para referência.

**P: O que é a taxa de engajamento e como é calculada?**
R: A taxa de engajamento no resumo do canal é calculada como média de visualizações dividida pela contagem de inscritos. Uma taxa de 0.3 significa que os posts são vistos por 30% dos inscritos em média.

**P: Até onde posso voltar nos posts de um canal?**
R: O actor pagina pelas páginas de preview públicas usando o parâmetro before=. Você pode voltar até 500 posts por canal. A profundidade real depende do histórico do canal e da disponibilidade da página de preview do Telegram.

**P: Preciso de uma chave de API ou bot token do Telegram?**
R: Não. O actor usa as páginas de preview públicas t.me/s/ que são acessíveis via requisições HTTP padrão. Nenhuma credencial de API é necessária.

### 💰 Preços

Este actor usa precificação **Pay Per Event (PPE)**:

| Métrica | Custo |
|---------|-------|
| post-scraped | $0.03 por post |

Exemplo: extrair 3 canais x 50 posts cada = 153 itens (150 posts + 3 resumos) = $4.59

### 🔗 Actors Relacionados

- [YouTube Fast Scraper](https://apify.com/viralanalyzer/youtube-fast-scraper) — Métricas do YouTube
- [TikTok Viral Scanner](https://apify.com/viralanalyzer/tiktok-viral-scanner) — Dados do TikTok
- [Instagram Reels Scraper](https://apify.com/viralanalyzer/instagram-reels-scraper) — Métricas do Instagram
- [Twitter/X Scraper](https://apify.com/viralanalyzer/twitter-scraper) — Extração de posts do Twitter

### 📝 Changelog

#### v1.1 (2026-09-24)

- Um username que não é canal público legível (conta pessoal, privado ou inexistente — `t.me/s/<name>` redireciona para a página de contato) agora emite um item `channel_diagnostic` em vez de um `channel_summary` cheio de zeros, e **não é cobrado**
- Métricas não medidas (`channelSubscribers`, `avgViews`, `medianViews`, `maxViews`, `engagementRate`) vêm `null` em vez de `0`

#### v1.0

- Extração de posts de canais públicos via preview t.me/s/
- Contagem de inscritos e metadados do canal
- Paginação de posts via parâmetro before=
- Detecção de tipo de mídia (foto, vídeo, documento, sticker, enquete)
- Atribuição de posts encaminhados
- Resumo do canal com analytics de engajamento (média/mediana/max views, taxa de engajamento)
- Entrada flexível: aceita usernames, @handles e URLs completas
- Guardrails anti-placeholder para integridade de dados
- Tratamento de rate limit com retentativas automáticas
- Integração com cobrança PPE

***

💡 **Need AI analysis on top of this data — sentiment, trend detection and a dashboard, with no API keys to manage?**
[ViralAnalyzer](https://viralanalyzer.com.br) runs this actor + 42 more data sources with built-in AI. JSON + insights in one call.

# Actor input Schema

## `channels` (type: `array`):

Telegram channel usernames (e.g., 'durov') or full URLs (e.g., 'https://t.me/durov'). Only public channels are supported.

## `maxPostsPerChannel` (type: `integer`):

Maximum number of posts to extract per channel. Uses pagination to load older posts.

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

Proxy settings. May be needed if Telegram blocks your IP.

## Actor input object example

```json
{
  "channels": [
    "durov"
  ],
  "maxPostsPerChannel": 5
}
```

# Actor output Schema

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

Dataset containing all scraped results. Each item follows the dataset schema.

# 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 = {
    "channels": [
        "durov"
    ],
    "maxPostsPerChannel": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("viralanalyzer/telegram-channel-scraper").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 = {
    "channels": ["durov"],
    "maxPostsPerChannel": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("viralanalyzer/telegram-channel-scraper").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 '{
  "channels": [
    "durov"
  ],
  "maxPostsPerChannel": 5
}' |
apify call viralanalyzer/telegram-channel-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,viralanalyzer/telegram-channel-scraper"
        }
    }
}
```

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/DUQGXW0OXkmviN1s2/builds/damix1fqUqMBM2hKp/openapi.json