# AppHitlist App Intelligence (`mmdincer/apphitlist-app-intelligence`) Actor

Chart movers, modeled monthly revenue and downloads, Meta ad runtime and complaint themes from AppHitlist. Uses the owner's key, not the customer's. Figures are AppHitlist estimates, not Apple's. Not affiliated with Apple or Meta.

- **URL**: https://apify.com/mmdincer/apphitlist-app-intelligence.md
- **Developed by:** [Muhammet Mustafa Dincer](https://apify.com/mmdincer) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 is AppHitlist App Intelligence?

**AppHitlist App Intelligence** returns App Store research from [AppHitlist](https://apphitlist.com): which apps climbed or entered a daily chart, which new apps already earn money, which apps earn the most, what one app looks like, which Meta ads have been running, and what 1-star and 2-star reviews complain about.

Apify customers do not create an AppHitlist account. The Actor calls AppHitlist with **the owner's key**, stored as the Apify secret `APPHITLIST_API_KEY`. There is no public REST API. The only programmatic path is the remote MCP server at `https://apphitlist.com/api/mcp` (streamable HTTP).

When that key is Pro, rows carry one monthly figure (`latestRevenueUsd`, `latestDownloads`) instead of a range, and the ads and complaint operations are included. When the key is Free, revenue and downloads come back as ranges, and ads and complaints come back as `subscription_required`.

### Before the first run

Muhammet must set **`APPHITLIST_API_KEY`** in the Apify Console for this Actor (**Settings → Environment variables**) and mark it as a **secret**, before running or publishing.

- The value is an AppHitlist key from the **owner's** account. Keys start with `ahl_`.
- Customers never paste a key. The input has no key field. A key in the input is rejected.
- The Actor does not log the key, does not write it to the dataset, and does not call AppHitlist until the secret is set.
- Do not publish while the secret is missing. Every run fails closed with a message that names the Console setting.

### Quick answer: when should you pick this Actor?

**Pick this Actor** when you want AppHitlist's chart movement, modeled revenue and downloads, Meta ad runtime or low-star complaint themes as dataset rows, billed on Apify, without your own AppHitlist login.

**Pick something else** when you want a cheap copy of the public App Store page (name, icon, public chart position, reviews). Those are a different product. This Actor does not scrape Apple, and it does not return keyword ranks.

**A useful first input** is chart movers for `us` / `grossing` with `limit` 20. Twenty stored rows on the Free plan are $3.00 plus the $0.01 start.

### At a glance

| | |
|---|---|
| **Does** | Chart movers (36 countries, grossing / free / paid), new apps already earning, top earners, search, one app, longest-running Meta ads, ads for one app, complaint themes. |
| **Input** | One `operation`, plus the fields that operation uses. No API key. |
| **Output** | One dataset row per app, movement, ad or theme. Error rows for calls that failed. `RUN_SUMMARY` in the key-value store. |
| **Needs** | The owner's `APPHITLIST_API_KEY` secret in the Apify Console. |
| **Account** | Customers use the owner's AppHitlist account. A Pro key returns exact figures and unlocks ads and complaints. |
| **Pricing** | Pay per event. Free plan: $0.01 to start and $0.15 per stored row. |
| **Does not** | Take the customer's AppHitlist key, scrape the App Store, or return Apple's official revenue. |

### Key terms

- **Operation:** which of the nine AppHitlist tools this run calls. One run does one operation. Several countries, apps or queries are several calls of that same tool.
- **Exact figures:** `latestRevenueUsd` and `latestDownloads`, one monthly number each. Returned when the stored key is Pro. `revenuePresentation` is `exact`.
- **Ranges:** `revenueRange` and `downloadsRange`, bands such as `$10K–$25K` or `5K–10K`. Returned when the stored key is Free. A null range means the app is below the lowest band, or no figure is shown. `revenuePresentation` is `range`.
- **subscription_required:** the stored key is Free and the operation needs Pro. The row says so. Later calls in that run are not sent.
- **Chart mover:** an app that climbed (`chart_riser`: rank, previous rank, places climbed) or entered the list (`chart_new_entry`).
- **Estimate:** revenue and download numbers come from AppHitlist's own model. They are directional. They are not Apple's reported sales or downloads.
- **Ad Library:** Meta ads are the public Facebook and Instagram ads AppHitlist has indexed. Coverage is the EU/UK coverage AppHitlist documents for the Ad Library. `daysRunning` is how long the ad has been active, not a spend or a result.

### What you can use it for

#### Who moved on today's grossing chart

`operation: "find_chart_movers"`, `countries: ["us"]`, `chart: "grossing"`, `days: 1`. Add `category: "Finance"` for that list, or `days: 7` for a week. Up to 8 countries in one run. Category charts exist for every list in us, gb and de; many other countries have grossing and free; the rest have grossing only. An unavailable chart is an error row with `chart_not_available`, the hint, and `latestChartDate`.

#### New apps that already earn

`find_new_winning_apps` with an optional category. These are apps released in the last 6 months at $10K or more a month, highest first. Games are left out unless `category` is `Games`.

#### The top of a category

`find_top_earning_apps` with `category: "Health & Fitness"`. Pro rows add price and ratings.

#### One app, its ads, its complaints

`search_apps` when you only have a name. Then `get_app` with the numeric id or the App Store URL. Pro app details add price, currency, ratings, the in-app purchase flag, the store URL, the start of the description, and a 30-day `rankSummary`. `get_app_ads` and `get_app_complaints` need Pro.

#### What a category complains about

`get_category_complaints` with `category: "Finance"`. Optional `kind`: `product`, `billing` or `price`. `reviewCount` counts 1 and 2 star reviews that mention the theme, not all reviews.

### How it works

1. The Actor reads `APPHITLIST_API_KEY` from the environment. If it is missing, or it does not start with `ahl_`, the run stops before any request. The value is not logged.
2. It opens one MCP session on `https://apphitlist.com/api/mcp` (`initialize`, then `notifications/initialized`, then `tools/call`). Redirects off `apphitlist.com` are refused, so the key is not sent anywhere else.
3. Each country, app or query is one `tools/call`. Calls in flight default to 2, and a shared pace starts a call at most once every 1.1 seconds (under Pro's 60 calls a minute). HTTP 429 and a "Rate limit reached" tool result wait (Retry-After, or the time in the message, otherwise 5s, 10s, 20s) and retry that call up to three times.
4. The JSON text inside the tool result is flattened into dataset rows. The MCP envelope is not stored. Unknown objects become an error row that names the top-level keys, not the raw payload.
5. Each stored app, riser, new entry, ad or theme is one `intelligence-record` charge, via `Actor.charge`, after which only the accepted rows are saved. `pushData` is called without an event name, so a row is not billed twice. Error rows are free.
6. A rejected key, the Free monthly cap (20 calls), `subscription_required`, or a category AppHitlist does not recognise stops calls that have not been sent. One unknown app, one missing chart, or one rate limit does not cancel the other items.
7. A spending limit is checked before a call. If it cannot cover one more row, AppHitlist is not called for that item. Rows fetched but refused by the limit are not written.

### Input

| Field | Type | Default | Meaning |
|---|---|---|---|
| `operation` | enum | `find_chart_movers` | One of the nine tools. |
| `countries` | list | `us` | Chart movers. Up to 8 of the 36 countries. `uk` → `gb`. |
| `chart` | `grossing` | `free` | `paid` | `grossing` | Chart movers. |
| `date` | `YYYY-MM-DD` | latest day | Chart movers, UTC. |
| `days` | integer 1–28 | 1 | Chart movers. 1 is day over day, 7 is week over week. |
| `category` | string | empty | Optional list filter. Required for category complaints. |
| `apps` | list | empty | URL, numeric id or name. Up to 20. Required for app details, app ads and app complaints. |
| `queries` | list | empty | Search text, 2–80 characters. Up to 10. |
| `kind` | `product` | `billing` | `price` | empty | Category complaints only. |
| `limit` | integer | per operation | Caps above. Chart movers apply it to risers and new entries separately. |
| `concurrency` | integer 1–4 | 2 | In-flight calls. The 1.1s pace still applies. |

There is no key field.

#### Operations and limits

| Operation | Required | Limit |
|---|---|---|
| `find_chart_movers` | country (default `us`) | 1–50, default 20, per side of the result |
| `find_new_winning_apps` | — | 1–50, default 20 |
| `find_top_earning_apps` | — | 1–50, default 20 |
| `search_apps` | `queries` | 1–10, default 5 |
| `get_app` | `apps` | — |
| `find_longest_running_ads` | — | 1–20, default 10 |
| `get_app_ads` | `apps` | 1–20, default 10 |
| `get_app_complaints` | `apps` | — |
| `get_category_complaints` | `category` | 1–30, default 15 |

Countries: us, gb, de, fr, ca, au, jp, kr, br, tr, es, it, mx, tw, nl, se, ch, sg, hk, ae, sa, no, dk, pl, ru, in, id, th, nz, ie, at, be, za, il, cl, co.

The form prefills `limit` 20. Search accepts at most 10, so a search left at 20 uses the search default of 5. Set the limit yourself when you want a different number inside that operation's range.

### Output

Filter the dataset on `recordType`. Views: **Apps**, **Chart movers**, **Ads**, **Complaints**, **Errors**.

`assets/sample-run-data.json` is an illustration, not a live run. Revenue numbers there are made up.

#### App rows (`recordType: "app"`)

From new winners, top earners, search and app details. Fields include `appId`, `name`, `publisher`, `category`, `releasedAt`, `profileUrl`, and either `revenueRange` / `downloadsRange` or `latestRevenueUsd` / `latestDownloads`. `revenuePresentation` says which. Pro may also include `price`, `currency`, `rating`, `ratingCount`, `hasInAppPurchases`, `storeUrl`, `description` (500 characters) and `rankSummary` (JSON text of the 30-day rank summary).

`figuresAreEstimates` is true. Read the figures as AppHitlist's model.

#### Chart rows

`chart_riser` has `rank`, `previousRank` and `change` (places climbed). `chart_new_entry` has `rank`. Both carry the app fields, `country`, `chart`, `chartCategory`, `chartDate`, `comparedWith`, `days`, `listSize` and `chartWarning` when AppHitlist sent one. A warning means there was nothing to compare with, or a new entry may only be new to the catalog.

#### Ad rows (`recordType: "ad"`)

`title`, `body`, `format`, `cta`, `linkUrl`, `platforms`, `startedAt`, `endedAt`, `daysRunning`, `copies`, and the app when it was included. `totalAds` is set for ads of one app. These rows are not revenue estimates. They are public Ad Library creatives with a runtime. They do not include spend or results.

#### Complaint rows (`recordType: "complaint_theme"`)

`theme`, `themeSummary`, `complaintKind`, `reviewCount`, and for a category `appCount`, `exampleApps` and `appsAnalyzed`. `reviewCount` is low-star mentions, not all reviews.

#### Error rows (`recordType: "error"`)

| `errorCode` | Meaning |
|---|---|
| `subscription_required` | The stored key is Free. This operation needs Pro. |
| `free_quota_exhausted` | The Free key has used its 20 calls this UTC month. |
| `unauthorized` | The stored key was rejected. Fix the Console secret. |
| `app_not_found` | No app for that URL, id or name. |
| `category_not_found` | `categories` lists names to retry. Later calls in the run are not sent. |
| `chart_not_available` | `hint` and `latestChartDate` say what to change. Other countries still run. |
| `rate_limited` | Still over the pace after retries. |
| `charge_limit` | The spending limit could not cover another row, so the call was not sent or the extra rows were not stored. |

#### Key-value store

`RUN_SUMMARY` holds the operation, calls planned and made, rows delivered, rows held back, `revenuePresentation` (`exact` if any row had exact figures), `sourceNote` (AppHitlist's note, when it sent one), warnings, and `finishedReason`.

`finishedReason` is `completed`, `empty` (a real empty answer), `item_errors`, `subscription_required`, `free_quota_exhausted`, `unauthorized`, `charge_limit`, `failed` or `aborted`.

### Pricing

Pay per event. US dollars. Apify's margin is 20%. This is not a rental.

| Event | Free | Bronze | Silver | Gold | Platinum and Diamond | When |
|---|---|---|---|---|---|---|
| Actor start | $0.01 | $0.01 | $0.01 | $0.01 | $0.01 | Once per run (one event per GB of memory, minimum one) |
| Intelligence record | $0.15 | $0.13 | $0.12 | $0.11 | $0.10 | One stored app, riser, new entry, ad or theme |

The charge in the code is `Actor.charge({ eventName: 'intelligence-record', count })`. Only accepted rows are then stored. `pushData` has no event name.

Not charged: error rows, an empty list, a call skipped because the key was rejected or the Free cap was hit, a Pro-only refusal, and rows the spending limit refused. A charge result of zero events is a spending limit only when `eventChargeLimitReached` is true. A run that is not on pay-per-event still stores the rows it received.

#### Why this price

Public App Store actors on the Apify Store sell a page scrape: about $0.002 to $0.003 per app (charts, metadata) and about $0.0001 per review. A public-signal revenue estimator on the Store charges about $0.02 to turn rank and ratings into a band. Those are not this dataset.

This Actor sells AppHitlist's own monthly revenue and download model (an exact USD figure on Pro, not a band scraped from the chart), plus chart movement, Ad Library runtime and complaint themes. AppHitlist Pro is $19.99 a month for interactive use of that same model. Sensor Tower and data.ai sell this class of figure as a subscription, not as a fraction-of-a-cent scrape.

$0.15 a row on the Free plan is about 130 rows for the price of one Pro month. One category of 20 apps is $3.00 plus the $0.01 start. A heavy chart pull is the expensive path on purpose: chart movers charge risers and new entries separately, so one country at the default limit can be up to 40 rows ($6.00), and 8 countries can be up to 320 rows ($48.00). Occasional programmatic reads cost a few dollars. Replacing an unlimited Pro login with bulk export costs more than Pro.

The start fee is $0.01 rather than the fraction of a cent used for a public-page scrape, because every run spends the owner's AppHitlist quota. Prices are proposed in `pricing-ppe.json`. They are not set on the platform until someone applies them.

Store prices above were public list prices on 5 November 2026.

### Comparison

| | This Actor | automation-lab App Store scraper | seibs.co revenue estimator | sourabhbgp App Store scraper | AppHitlist Pro |
|---|---|---|---|---|---|
| What you get | AppHitlist model, chart movement, ads, complaints | Public app, chart and review pages | Public metadata plus a modeled band | Public apps, charts, reviews | The same model, in the product |
| Revenue | Exact USD on a Pro key, else a range | No | About $0.02 for a low/mid/high band | No | Exact USD |
| Ads and complaints | Yes, Pro key | No | No | Reviews, not these themes | Yes |
| Who logs in | Nobody. The owner's key. | Nobody | Nobody | Nobody | The subscriber |
| Price signal | $0.15 per stored row on Free | About $0.003 per app | About $0.02 per estimate | About $0.002 per row | $19.99 / month |

### Data notes

Revenue and downloads are **AppHitlist's model**. Treat them as directional estimates. Do not describe them as Apple's official numbers, as the developer's reported revenue, or as an audited figure. A Free key's range is a band. Do not turn a band into a midpoint.

Meta ads come from the **public Meta Ad Library**, with the EU/UK coverage AppHitlist documents. A long `daysRunning` means the ad is still active, which usually means it pays for itself. It is not a measurement of spend or installs.

The Actor is not affiliated with Apple or Meta.

### FAQ

**The run failed immediately and nothing was called.**
`APPHITLIST_API_KEY` is missing or does not look like an AppHitlist key. Set the owner's key in the Apify Console and mark it secret.

**I passed my own AppHitlist key in the input.**
That field is rejected. Customers use the owner's account. Do not put a key in the input.

**Revenue is a range, not a number.**
The stored key is Free. Pro returns `latestRevenueUsd` and `latestDownloads`. Ranges stay ranges.

**The error code is subscription_required.**
The stored key is Free and this operation (ads or complaints) needs Pro. The call was not retried.

**The first chart country failed and the others did not run.**
A missing category stops the rest of the run, because every call would use that same category. A missing chart does not: other countries still run. `chart_not_available` includes the hint.

**Will this hit a monthly cap?**
Pro: no monthly cap, 60 calls a minute. The Actor stays under that pace and backs off on 429. Free: 20 calls a month. The stored key is expected to be Pro. A Free key that has used its 20 calls stops the run with `free_quota_exhausted`.

**Are the sample numbers real?**
No. `assets/sample-run-data.json` is an illustration.

### Local tests

From `actors/apphitlist-app-intelligence` after `npm install`:

```bash
npm test
```

A live call needs `APPHITLIST_API_KEY` in the environment. The tests do not call AppHitlist.

# Changelog

This Actor's version history is a separate document: https://apify.com/mmdincer/apphitlist-app-intelligence/changelog.md

# Actor input Schema

## `operation` (type: `string`):

<b>Chart movers</b> lists apps that climbed or entered a daily App Store chart. <b>New winning apps</b> lists apps released in the last 6 months that already earn $10K or more a month (games are left out unless the category is Games). <b>Top earning apps</b> lists the highest monthly revenue. <b>Search apps</b> finds an app or developer by name. <b>App details</b> reads one app by URL, numeric id or name. <b>Longest-running ads</b> and <b>Ads for one app</b> read active Meta ads. <b>Complaints for one app</b> and <b>Complaints in a category</b> read themes from 1 and 2 star reviews. Ads and complaints need a Pro key.

## `countries` (type: `array`):

Used by <b>Chart movers</b>. Up to 8 of the 36 App Store countries. Each country is one call. <code>uk</code> is read as <code>gb</code>. Empty means the United States. Category charts are not available in every country: us, gb and de have grossing, free and paid; many others have grossing and free; the rest have grossing only.

## `chart` (type: `string`):

Which daily list. <b>Grossing</b> is top grossing (revenue). <b>Free</b> is top free. <b>Paid</b> is top paid.

## `date` (type: `string`):

Chart day as YYYY-MM-DD (UTC). Leave empty for the latest day. Raw daily lists are kept for about 35 to 60 days.

## `days` (type: `integer`):

Compare with the newest chart at least this many days earlier. 1 is day over day. 7 is week over week. From 1 to 28.

## `category` (type: `string`):

Optional for chart movers, new winners, top earners and longest-running ads. Required for category complaints. A name such as Health & Fitness or Finance, a short name such as fitness, or a numeric genre id. Leave empty for the overall list. New winning apps leave games out unless this is Games. 1 to 60 characters.

## `apps` (type: `array`):

One App Store URL, numeric id or app name per line. Used by app details, ads for one app, and complaints for one app. A name resolves to the best search match. Up to 20. Each app is one call.

## `queries` (type: `array`):

Used by <b>Search apps</b>. One app or developer name per line, 2 to 80 characters. Up to 10. Each query is one call.

## `kind` (type: `string`):

Used by <b>Complaints in a category</b>. Leave empty for every kind. Otherwise only product, billing or price complaints.

## `limit` (type: `integer`):

How many rows to ask for on each call. Chart movers apply this to risers and, separately, to new entries (1–50, default 20). New winners and top earners: 1–50, default 20. Search: 1–10, default 5. Ads: 1–20, default 10. Category complaints: 1–30, default 15. App details and complaints for one app ignore this. You pay for each row that is stored.

## `concurrency` (type: `integer`):

How many AppHitlist calls may be in flight at once (1 to 4, default 2). The Actor still starts a call at most about once every 1.1 seconds, under the Pro cap of 60 calls a minute. A 429 waits and retries that call. One failed call does not stop the others, except a rejected key, the Free monthly cap, a Free key on a Pro-only tool, or a category AppHitlist does not recognise.

## Actor input object example

```json
{
  "operation": "find_chart_movers",
  "countries": [
    "us"
  ],
  "chart": "grossing",
  "date": "2026-11-04",
  "days": 1,
  "category": "Health & Fitness",
  "apps": [
    "https://apps.apple.com/us/app/id111111111"
  ],
  "queries": [
    "example fitness"
  ],
  "limit": 20,
  "concurrency": 2
}
```

# Actor output Schema

## `apps` (type: `string`):

Apps from new winners, top earners, search or app details. Filter on recordType app.

## `charts` (type: `string`):

Risers and new entries. Filter on recordType chart_riser or chart_new_entry.

## `ads` (type: `string`):

Active Meta ads, longest running first. Filter on recordType ad.

## `complaints` (type: `string`):

Complaint themes from 1 and 2 star reviews. Filter on recordType complaint_theme.

## `errors` (type: `string`):

Calls that failed or were not sent. Filter on recordType error. These rows are not charged.

## `summary` (type: `string`):

Calls made, rows delivered, whether revenue came back as an exact figure or a range, and why the run stopped.

# 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 = {
    "operation": "find_chart_movers",
    "countries": [
        "us"
    ],
    "chart": "grossing",
    "days": 1,
    "limit": 20,
    "concurrency": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("mmdincer/apphitlist-app-intelligence").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 = {
    "operation": "find_chart_movers",
    "countries": ["us"],
    "chart": "grossing",
    "days": 1,
    "limit": 20,
    "concurrency": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("mmdincer/apphitlist-app-intelligence").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 '{
  "operation": "find_chart_movers",
  "countries": [
    "us"
  ],
  "chart": "grossing",
  "days": 1,
  "limit": 20,
  "concurrency": 2
}' |
apify call mmdincer/apphitlist-app-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mmdincer/apphitlist-app-intelligence"
        }
    }
}
```

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/XbRJ6xdGMeU5tbQtb/builds/GyhJLDk6BqgAA8nqf/openapi.json