# Hacker News Search — Stories, Comments & Live Front Page (`yadroo/hackernews-search`) Actor

Search all of Hacker News (stories, comments, Ask/Show/Launch HN, polls, jobs) by keyword with points, comments, date, author, domain and story filters, or pull the live top/new/best/ask/show/jobs lists. Optional nested comment trees and author profiles.

- **URL**: https://apify.com/yadroo/hackernews-search.md
- **Developed by:** [Samat Makatov](https://apify.com/yadroo) (community)
- **Categories:** News, Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 1,000 result items

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

## Hacker News Search — stories, comments, live lists (Algolia + official API)

Search all of Hacker News since 2006 — stories, comments, Ask HN, Show HN, Launch HN, polls, job posts — by
keyword with points / comments / date / author / domain filters, or pull the live **top / new / best / ask / show / jobs**
lists exactly as the HN pages rank them. Optionally attach each story's discussion as a nested comment tree and the
author's profile (karma, account age). Built for AI agents, brand monitors and researchers: clean JSON with plain-text
bodies. **No API key, no proxy, no browser.**

### Use cases

- **Brand & competitor monitoring** — every story and comment mentioning your product (or a competitor) in the last N days, with points and discussion threads, on a schedule.
- **Launch research** — pull all `Show HN` / `Launch HN` posts on a topic, sorted by points, to see what resonated and how people reacted (comments included).
- **Content & PR intelligence** — which stories from a domain (`arxiv.org`, `github.com`, your blog) hit HN, when, and how big they got.
- **Lead / expert discovery** — find people who comment knowledgeably about a technology; include their profile (karma, account age, bio) to qualify them.
- **Trend tracking for agents** — a daily snapshot of the live front page / best list with a points floor, deduped by URL, trimmed to the fields you need.
- **Hiring signals** — YC job posts (`kind: job`, searchable history, or live `jobs`) filtered by stack keywords.

### Input

| Field | Type | Default | Notes / allowed values |
|---|---|---|---|
| `query` | string | — | Keywords. Algolia syntax: `"exact phrase"`, `-excluded`. Empty = list by date with the filters only. |
| `queries` | string\[] | `[]` | Extra queries processed in the same run (batch monitoring). Each item carries its `query`. `maxItems` is the total. |
| `kind` | enum | `story` | Search (Algolia): `story`, `comment`, `ask_hn`, `show_hn`, `launch_hn`, `poll`, `job`, `front_page`, `newest`, `any`. Live lists (Firebase): `top`, `new`, `best`, `ask`, `show`, `jobs`. See reference. |
| `sort` | enum | `relevance` | `relevance` (text match → points → comments; falls back to `date` when no query), `date` (newest first), `points`, `comments`. Points/comments are sorted client-side: the actor fetches the whole reachable pool (up to 1,000 hits, 5 requests) and returns the top `maxItems`. |
| `searchIn` | enum | `all` | `all`, `title`, `url`, `text`, `title_text`, `author` → Algolia `restrictSearchableAttributes`. `all` also matches story text, URLs and (for `kind: comment`/`any`) comment text — right for mention monitoring, noisy for topic lists: use `title` for "stories about X". |
| `typoTolerance` | bool | `false` | Let Algolia match misspellings. Off by default because it turns short terms into noise ("LLM" → "Limbo", "Limits", "GLM"; "Kafka" → "Kakapos"); turn on to also catch misspelled mentions. |
| `minPoints` | int | `0` | Algolia numeric filter `points>=`. Ignored for comments (they have no points). |
| `minComments` | int | `0` | Algolia numeric filter `num_comments>=`. |
| `sinceDays` | int | `0` | Last N days; `0` = all time. Overridden by `dateFrom`. |
| `dateFrom` / `dateTo` | date | — | `YYYY-MM-DD` or ISO 8601 UTC, inclusive. |
| `author` | string | — | Bare username (`pg`) → tag `author_pg`. |
| `storyId` | string | — | Restrict to one thread → tag `story_<id>` (use with `kind: comment`). |
| `domain` | string | — | Keep items whose URL is on this domain or a subdomain (client-side). With an empty `query` it becomes the URL query, so "all submissions of a site" is one call. |
| `maxItems` | int | `50` | 1–5000, total across queries. Algolia serves at most **1000 hits per query**; live lists hold 200–500 ids. Legacy alias `limit` still works. |
| `includeComments` | bool | `false` | Attach nested `comments` per story (1 extra request per story that has comments). |
| `maxCommentsPerStory` | int | `20` | 1–500, breadth-first (top-level replies first). |
| `commentsDepth` | int | `2` | 1–10 reply levels. |
| `includeAuthorProfile` | bool | `false` | Attach `authorProfile` (karma, createdAt, about, submittedCount) — 1 request per distinct author, cached in the run. |
| `textMaxLength` | int | `2000` | 100–50000 chars for `text` and comment texts. |
| `dedupeByUrl` | bool | `false` | One item per external URL (scheme/www/trailing slash ignored). |
| `fields` | string\[] | `[]` | Whitelist of output fields (`id` always kept). |

Filters are ANDed. Live Firebase kinds ignore `query`, `author`, `storyId`, dates and `searchIn` (they are not searchable) and apply `minPoints` / `minComments` / `domain` client-side — the run logs a warning when an input is ignored.

### Reference

#### `kind` values

| kind | Source | What you get | Filters |
|---|---|---|---|
| `story` | Algolia tag `story` | Stories (link + text posts), all time | all |
| `comment` | Algolia tag `comment` | Comments with parent story context | all except `minPoints`/`minComments` |
| `ask_hn` / `show_hn` / `launch_hn` | Algolia tags | Ask HN / Show HN / Launch HN (YC launches) posts | all |
| `poll` | Algolia tag `poll` | Polls (options are type `pollopt`) | all |
| `job` | Algolia tag `job` | YC job-board posts, full history | all |
| `front_page` | Algolia tag `front_page` | ~30 stories currently on the front page | all |
| `newest` | Algolia `search_by_date`, tag `story` | Alias for `story` + `sort: date` | all |
| `any` | Algolia, no type tag | Stories, comments, polls, jobs together | all |
| `top` | Firebase `topstories` | Live HN front page ranking, up to 500 | `minPoints`, `minComments`, `domain` |
| `new` | Firebase `newstories` | Live newest, up to 500 | same |
| `best` | Firebase `beststories` | Live "best" ranking, up to 200 | same |
| `ask` / `show` / `jobs` | Firebase `askstories` / `showstories` / `jobstories` | Live Ask HN / Show HN / jobs lists | same |

#### Algolia tags used under the hood (`tags` output field)

`story`, `comment`, `poll`, `pollopt`, `job`, `show_hn`, `ask_hn`, `launch_hn`, `front_page`, `author_<username>`, `story_<id>`.
Tags are ANDed with commas; the actor builds them from `kind`, `author` and `storyId`.

#### Algolia numeric filters

`points`, `num_comments`, `created_at_i` (unix seconds) with `<`, `<=`, `=`, `>=`, `>`; built from `minPoints`, `minComments`, `sinceDays` / `dateFrom` / `dateTo`.

#### `searchIn` → `restrictSearchableAttributes`

| searchIn | attributes |
|---|---|
| `all` | title, url, story\_text, comment\_text, author (Algolia default) |
| `title` | `title` |
| `url` | `url` |
| `text` | `comment_text`, `story_text` |
| `title_text` | `title`, `story_text`, `comment_text` |
| `author` | `author` |

**Topic vs mention searches.** The default `searchIn: "all"` finds every item where the word appears anywhere — including self-post text and URLs — which is what brand monitoring needs (`kind: "any"` adds comments). For "the best stories about X" lists, set `searchIn: "title"`: e.g. `LLM` stories of one week sorted by points returned 191 hits with `all` (among them a post about migrating prompts to Ollama and a "Pelican-bicycle alternatives" Show HN that mention LLMs only in their text) vs 140 with `title`, all with LLM in the headline.

### Examples

**Brand monitoring, last 30 days, stories with traction plus their discussion**

```json
{ "queries": ["apify", "crawlee"], "kind": "story", "sinceDays": 30, "minPoints": 5, "sort": "points", "includeComments": true, "maxCommentsPerStory": 10, "commentsDepth": 2, "maxItems": 100 }
```

**What did people say about a topic? (comments, newest first)**

```json
{ "query": "\"vector database\"", "kind": "comment", "sinceDays": 90, "sort": "date", "maxItems": 200 }
```

**All Show HN launches about a category, ranked by points, with founder profiles**

```json
{ "query": "MCP server", "kind": "show_hn", "dateFrom": "2026-01-01", "sort": "points", "includeAuthorProfile": true, "maxItems": 50 }
```

**Every HN hit from a domain this quarter (PR report)**

```json
{ "domain": "arxiv.org", "dateFrom": "2026-07-01", "dateTo": "2026-09-30", "minPoints": 50, "sort": "points", "dedupeByUrl": true, "maxItems": 300 }
```

**Daily snapshot of the live top list, compact fields**

```json
{ "kind": "top", "minPoints": 100, "maxItems": 30, "fields": ["title", "url", "domain", "points", "numComments", "createdAt", "hnUrl"] }
```

**Whole thread of one story as flat comments (searchable)**

```json
{ "kind": "comment", "storyId": "4058874", "query": "scraping", "maxItems": 100 }
```

### Output

One dataset item per story / comment. Example (trimmed):

```json
{
  "id": "46513489",
  "type": "story",
  "kind": "story",
  "query": "apify",
  "title": "Show HN: mcpc – Universal command-line client for Model Context Protocol",
  "url": "https://github.com/apify/mcpc",
  "domain": "github.com",
  "hnUrl": "https://news.ycombinator.com/item?id=46513489",
  "points": 50,
  "numComments": 5,
  "author": "jancurn",
  "createdAt": "2026-01-06T14:03:11Z",
  "text": null,
  "storyId": "46513489",
  "storyTitle": null,
  "storyUrl": null,
  "parentId": null,
  "tags": ["story", "author_jancurn", "story_46513489", "show_hn"],
  "comments": [
    { "id": "46513489", "author": "stinny", "createdAt": "2026-01-06T15:29:16.000Z", "text": "Pretty sweet tool…", "hnUrl": "https://news.ycombinator.com/item?id=46513489",
      "children": [ { "id": "46514078", "author": "jancurn", "text": "Thank you! …", "children": [] } ] }
  ],
  "authorProfile": { "username": "jancurn", "karma": 748, "createdAt": "2011-10-31T16:07:06.000Z", "about": "Jan Čurn — Founder & CEO @ Apify …", "submittedCount": 121, "hnUrl": "https://news.ycombinator.com/user?id=jancurn" },
  "source": "algolia",
  "sourceUrl": "https://hn.algolia.com/api/v1/search?query=apify&tags=story&numericFilters=points%3E%3D5%2Ccreated_at_i%3E%3D…&hitsPerPage=100&page=0",
  "fetchedAt": "2026-09-12T23:32:10.512Z"
}
```

| Field | Type | Meaning |
|---|---|---|
| `id` | string | HN item id (stable; `hnUrl` = `news.ycombinator.com/item?id=<id>`) |
| `type` | string | `story`, `comment`, `poll`, `pollopt`, `job` |
| `kind`, `query` | string | Input that produced the item (`query` null for live lists) |
| `title`, `url`, `domain` | string|null | Submission title, external URL, hostname without `www.` |
| `points`, `numComments` | int|null | Score and comment count (comments: `points` null) |
| `author`, `createdAt` | string | Username, ISO 8601 UTC |
| `text` | string|null | Story/comment body as plain text: HTML stripped, entities decoded, paragraphs kept, links as `label (href)`, truncated to `textMaxLength` |
| `storyId`, `storyTitle`, `storyUrl`, `parentId` | string|null | Thread context (for stories `storyId` = `id`; the rest only on comments) |
| `tags` | string\[] | Algolia tags (see reference) |
| `comments` | array | Only with `includeComments`: nested `{id, author, createdAt, text, hnUrl, children[]}` |
| `authorProfile` | object|null | Only with `includeAuthorProfile`: `{username, karma, createdAt, about, submittedCount, hnUrl}` |
| `source`, `sourceUrl` | string | `algolia` or `firebase` and the exact API request |
| `fetchedAt` | string | Fetch timestamp |

Dataset views: **Overview** (stories) and **Comments**.

### Use it from code / agents

curl (Apify API, run synchronously and get the dataset):

```bash
curl -X POST "https://api.apify.com/v2/acts/yadroo~hackernews-search/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'content-type: application/json' \
  -d '{"query":"apify","kind":"story","sinceDays":30,"minPoints":5,"maxItems":50}'
```

JavaScript (`apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('yadroo/hackernews-search').call({ query: 'apify', kind: 'story', sinceDays: 30, minPoints: 5, includeComments: true });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Python (`apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient(token)
run = client.actor("yadroo/hackernews-search").call(run_input={"kind": "top", "minPoints": 100, "maxItems": 30})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

MCP: add `https://mcp.apify.com` to your agent (Claude, Cursor, custom) and call the tool `yadroo/hackernews-search` with the same JSON input.

### Pricing

Pay per event: **$0.001 per run start + $0.0005 per item** (story or comment; nested `comments` and `authorProfile` are part of the item, not billed separately).

Typical runs: a 30-day brand check with 40 hits ≈ $0.021; a 500-item topic export ≈ $0.251; a daily top-30 snapshot ≈ $0.016.

### Limits & FAQ

- **Rate limits.** HN Algolia allows ~10,000 requests/hour per IP; the actor pages 200 hits per request with a short pause and retries 429/5xx with backoff, so normal runs never get close. The Firebase API has no published limit; item fetches run 8 in parallel.
- **1000-hit cap.** Algolia refuses to page past 1000 hits for one query. The actor caps per query and logs a warning with the true match count — split by `dateFrom`/`dateTo` windows or several `queries` to go deeper.
- **Freshness.** Algolia indexes new items within minutes; points/comment counts are updated periodically, so very fresh stories may show lower numbers than the live site. Live `top/new/best/ask/show/jobs` kinds read the official API in real time.
- **Sorting by points/comments** is done client-side: up to 1,000 matching hits are fetched per query and the top `maxItems` returned. Algolia never serves more than 1,000 hits, so for a global "top of all time" on a broad query narrow with `minPoints` or a date range.
- **Search precision.** Matching is word-based with prefix and plural matching (`LLM` finds "LLMs"); typo matching is off unless `typoTolerance: true`. `searchIn: "all"` (default) matches text and URLs too — see the note under **Reference** for topic lists.
- **Comments and points.** HN does not expose comment scores; `points` is `null` for comments and `minPoints` is ignored for `kind: comment`.
- **Errors.** Invalid input (unknown kind/sort, bad dates, `dateFrom` after `dateTo`) fails immediately with a clear message before any request. Per-item enrichment failures (comments, profiles) are logged and leave `comments: []` / `authorProfile: null`; if the source is unreachable and nothing was collected, the run fails instead of looping.
- **Deleted / dead items** are skipped; deleted comments are dropped from `comments`.
- **Roadmap.** Poll options (`pollopt`) inline with polls; user-submission listing (`author` + empty query already covers most of it).

Sources: [HN Search API by Algolia](https://hn.algolia.com/api), [official Hacker News API](https://github.com/HackerNews/API). Content belongs to its authors / Y Combinator.

***

Made by **Yadroo** — more data actors for agents: [stackexchange-search](https://apify.com/yadroo/stackexchange-search) · [github-repo-intel](https://apify.com/yadroo/github-repo-intel) · [google-news-search](https://apify.com/yadroo/google-news-search) · [rss-to-json](https://apify.com/yadroo/rss-to-json) · [crypto-news](https://apify.com/yadroo/crypto-news)

# Actor input Schema

## `query` (type: `string`):

Keywords to search. Algolia syntax: wrap a phrase in double quotes for exact match ("vector database"), prefix a word with - to exclude it (python -django). Leave empty to list items by date (kind=story → newest stories matching the filters).

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

Additional search terms processed one after another in the same run — e.g. several brand names or competitors to monitor. Each output item carries the `query` that found it. maxItems is a total across all queries.

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

Which HN item type / list to pull. `story`, `comment`, `ask_hn`, `show_hn`, `launch_hn`, `poll`, `job`, `front_page`, `newest`, `any` search the Algolia index and support every filter below. `top`, `new`, `best`, `ask`, `show`, `jobs` are the live ranked lists from the official Firebase API (same order as the HN pages) — query, author, storyId, dates and searchIn are ignored for them.

## `sort` (type: `string`):

`relevance` and `date` are native Algolia sort orders (relevance falls back to date when there is no query). `points` and `comments` are applied client-side to the fetched result set (up to maxItems, max 1000 per query) — combine with dateFrom/sinceDays or minPoints to make the set meaningful. For live Firebase lists the default is the list's own ranking.

## `searchIn` (type: `string`):

Restricts which attributes Algolia matches the query against (restrictSearchableAttributes). `all` also matches story text, URLs and comment text — right for brand/mention monitoring, noisy for topic lists: use `title` for "stories about X". `url` is handy for finding every submission of a site: query="github.com/apify", searchIn="url".

## `typoTolerance` (type: `boolean`):

Let Algolia match misspellings (one typo per word). Off by default: with it on, "LLM" also matches "Limbo", "Limits" and "GLM", "Kafka" matches "Kakapos". Turn on to catch misspelled mentions.

## `minPoints` (type: `integer`):

Keep items with at least this many points. Comments have no points on HN — ignored for kind=comment.

## `minComments` (type: `integer`):

Keep stories with at least this many comments (Algolia num\_comments). Ignored for kind=comment.

## `sinceDays` (type: `integer`):

Only items created in the last N days. 0 = all time. Ignored when dateFrom is set.

## `dateFrom` (type: `string`):

Earliest creation date, YYYY-MM-DD or ISO 8601 (UTC). Overrides sinceDays.

## `dateTo` (type: `string`):

Latest creation date (inclusive; a bare date means end of that day UTC), YYYY-MM-DD or ISO 8601.

## `author` (type: `string`):

Only items by this HN username (bare, e.g. `pg`, not `author_pg`). Combine with an empty query and sort=date to list everything a user posted.

## `storyId` (type: `string`):

HN item id, e.g. 4058874. With kind=comment returns the comments of that thread (searchable by query). Alternative to includeComments when you want flat, paginated comments of a single story.

## `domain` (type: `string`):

Keep only items whose URL is on this domain or its subdomains, e.g. `apify.com` or `arxiv.org`. If query is empty the domain is also used as the Algolia URL query, so listing all submissions of a site is one call.

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

Total items to output across all queries. Algolia serves at most 1000 hits per query; live lists hold 200–500 ids. (Legacy name `limit` is still accepted.)

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

Deprecated alias of maxItems, kept for backward compatibility. maxItems wins when both are set.

## `includeComments` (type: `boolean`):

Attach the discussion of each story as a nested `comments` tree (author, date, plain text, children). Costs one extra request per story with comments; use maxCommentsPerStory/commentsDepth to bound the payload.

## `maxCommentsPerStory` (type: `integer`):

Total comments kept per story when includeComments is on (breadth-first: top-level replies first, then their children).

## `commentsDepth` (type: `integer`):

How many reply levels to keep in `comments` (1 = only direct replies to the story).

## `includeAuthorProfile` (type: `boolean`):

Attach `authorProfile` (karma, account creation date, about, number of submissions) from the official HN API. One request per distinct author (cached within the run).

## `textMaxLength` (type: `integer`):

Truncation length (characters) for `text` and comment texts after HTML is converted to plain text.

## `dedupeByUrl` (type: `boolean`):

Output each external URL only once (first hit wins; scheme, www. and trailing slash are ignored). Useful when the same article was submitted several times.

## `fields` (type: `array`):

Keep only these fields in each item (id is always kept). Leave empty for the full item. Known fields: id, type, kind, query, title, url, domain, hnUrl, points, numComments, author, createdAt, text, storyId, storyTitle, storyUrl, parentId, tags, comments, authorProfile, source, sourceUrl, fetchedAt.

## Actor input object example

```json
{
  "query": "web scraping",
  "queries": [],
  "kind": "story",
  "sort": "relevance",
  "searchIn": "all",
  "typoTolerance": false,
  "minPoints": 0,
  "minComments": 0,
  "sinceDays": 0,
  "maxItems": 50,
  "includeComments": false,
  "maxCommentsPerStory": 20,
  "commentsDepth": 2,
  "includeAuthorProfile": false,
  "textMaxLength": 2000,
  "dedupeByUrl": false,
  "fields": []
}
```

# Actor output Schema

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

No description

# 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 = {
    "query": "web scraping",
    "queries": [],
    "fields": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("yadroo/hackernews-search").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 = {
    "query": "web scraping",
    "queries": [],
    "fields": [],
}

# Run the Actor and wait for it to finish
run = client.actor("yadroo/hackernews-search").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 '{
  "query": "web scraping",
  "queries": [],
  "fields": []
}' |
apify call yadroo/hackernews-search --silent --output-dataset

```

## MCP server setup

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

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/A5ueTupkbUCEISqYj/builds/3H706eTx7Phek5fx0/openapi.json