The best Hacker News APIs in 2026, tested and priced per 1,000 story reads

Every Hacker News integration is four reads. Fetch a story, fetch its comment thread, search by keyword, look up a user. The official API has done three of those for free since 2014, so a paid option has to earn its place on something the free routes get wrong.

I sent the same input set through six routes on 2026-09-04: three stories (the 2007 Dropbox launch post with 71 comments, an IBM thread with 223, and a GPT-6 thread with 1,935), three keyword searches, and three user profiles. Two routes are free and need no key, one is the node-hn-api wrapper, two are hosted scrapers I hold trial keys for (Bright Data never got past account setup), and one is AnyAPI, which sells four Hacker News endpoints by the request.

The short version: the free routes win every read except a scheduled export with nested replies, and the thing worth knowing before you spend anything is which paid route can't return a full thread.

The best Hacker News APIs

• Official Hacker News API for live story and profile reads
• Algolia HN Search API for keyword search and whole comment threads
• node-hn-api for Node projects that want typed fetchers over the official API
• Apify Hacker News Scraper for scheduled exports with nested comments
• Bright Data for teams already on Bright Data who want a custom-built scraper
• AnyAPI for story, search, and profile reads in a multi-source app

What makes a good Hacker News API?

I'm assuming you're building a monitor, a digest, or a research tool, and that you read Hacker News rather than post to it. You have a list of stories or keywords, a job that runs on a schedule, and a database. Here's what I graded on.

• The whole thread. A story with 1,935 comments has 231 top-level ones. If a route stops there, your sentiment score or your digest is built on a tenth of the discussion.
• Requests per thread. The official API hands you comment ids and makes you fetch each one. That's fine at 71 comments and a different job at 2,000, so I counted requests and timed the walk sequentially and with 16 workers.
• Search that's actually the source's ranking. Three routes offer keyword search. I sent the same three queries through each and compared the top results.
• A price per 1,000 story reads you can compute before the job runs. Every paid option bills in a different unit, so each one is normalized to a thousand story records, with the comment price beside it.
• A key you can get. Two of the six need no key at all. For the rest I used the trial key I was given and nothing more.

I didn't grade uptime, ranking quality, or anything on the write side.

The best Hacker News APIs at a glance

Official Hacker News API (best for live story and profile reads)

Official Hacker News API pros:

• No key, no signup, and the README's own words are "There is currently no rate limit"
• A story read came back in about a fifth of a second with score, descendants, and the ordered kids array
• 2,028 requests at 16 concurrent workers finished with zero errors and zero throttling

Official Hacker News API cons:

• One request per comment, so a 1,935-comment thread is a six-minute walk sequentially
• No search of any kind
• A user record carries the entire submitted list, 84,239 ids for dang, which is why user reads took about twice as long as story reads

This is where every Hacker News build starts, and for live reads it's where most of them should stay. The item endpoint returns the story's by, score, time, title, url, descendants, and a kids array of comment ids in ranked order. The official API has no rate limit and it held at 16 concurrent workers, which is the thing the README says and the thing most client libraries refuse to believe: GoHN, for one, throttles itself to one request a second by default and calls ten an absolute maximum.

curl -sS https://hacker-news.firebaseio.com/v0/item/8863.json

The cost is the walk. Each comment is its own item, so reading a thread means loading the story, loading every id in its kids array, then every id in theirs. The Dropbox thread took 73 requests and about 13 seconds sequentially; the GPT-6 thread took 2,028 requests and just over six minutes. With 16 workers the same walk took 24 seconds. The README calls the API a dump of in-memory data structures and says it wasn't the ideal public API, just the one they could release in the time they had, and that's a fair description of what building on it feels like: everything is there, and you assemble it.

Two more things to know. Counting comments means traversing the tree, and the descendants field on the story is the shortcut for that. And there's no search, which is why a 2017 thread has someone building a SQLite full-text index from a Firebase dump. Search is what the next option is for.

Official Hacker News API pricing: $0 API fee.

Algolia HN Search API (best for keyword search and whole comment threads)

Algolia HN Search API pros:

• The items endpoint returned the whole nested thread in one call: 71, 224, and 1,929 comments at depths 5, 8, and 13, matching the official walk comment for comment
• Keyword search in about a third of a second, with tags for story, comment, author, and story id, and numeric filters on points, comment count, and date
• 10,000 requests an hour per IP, stated in the docs, and no key

Algolia HN Search API cons:

• The full 1,929-comment tree is about a megabyte, so cache it rather than fetch it on every request
• User reads return about, karma, and username only, no submitted list
• At the moment I checked, its newest indexed comment was six ids behind the official maxitem

Algolia hands you the whole thread in one call. GET the items endpoint with a story id and you get the story with a children array, each child with its own children, all the way down. The Dropbox thread came back in about 0.4 seconds, the GPT-6 thread in about a second. That's the same 1,929 live comments the official API needed 2,028 requests to assemble, and it's the read I'd build any thread-level feature on.

curl -sS 'https://hn.algolia.com/api/v1/search?query=postgres&tags=story&hitsPerPage=10'
curl -sS https://hn.algolia.com/api/v1/items/8863

Search is the other reason to be here. A hit carries objectID, title, url, author, points, num_comments, created_at, and story_id, and the query language does the filtering you'd otherwise do in code: tags=story, tags=author_pg, tags=story_8863 for one thread's comments, and numericFilters=points>100. Three queries reported 14,741, 1,095, and 27,189 hits, and each page took about a third of a second. Back at the 2014 launch the limit quoted in the announcement thread was 1,000 requests an hour; the docs now say 10,000, which is plenty for anything short of a full-site crawl.

One practical note: the docs page is a JavaScript app, so a plain fetch of it returns nothing. Open it in a browser.

Algolia HN Search API pricing: $0 API fee, 10,000 requests an hour per IP.

node-hn-api (best for Node projects that want typed fetchers over the official API)

node-hn-api pros:

• Version 4.0.1, published 2025-10-07, with zero runtime dependencies
• fetchItem, fetchUser, and the six list fetchers, and the fastest story reads in the run at about 0.09 seconds
• A per-level Promise.all walk read the 1,929-comment thread in under two seconds

node-hn-api cons:

• No search and nothing that walks a thread for you; a comment is just an item with type comment
• The repository the package name suggests, chasefleming/node-hn-api, is a different and archived project

This is the official API with the URLs written for you. npm install node-hn-api pulls one package and no dependencies, and every function maps to one endpoint: fetchItem for a story or a comment, fetchUser for a profile, fetchTopStories and friends for the lists. Reads through it were quicker than my raw Firebase calls in this run, which says more about the two HTTP clients than the wrapper.

You still own the walk. The package returns the kids array and stops, so the loop that fetches each level is yours to write, and it's a good place to put the concurrency, because the 2,028-request walk with all of a level in flight at once finished in 1.8 seconds. If you're in Node and you only need live reads, this is the least code between you and the data. If you need search or a thread in one call, it can't help, because the API under it can't.

node-hn-api pricing: $0 API fee. A package install and your own compute.

Apify Hacker News Scraper (best for scheduled exports with nested comments)

Apify Hacker News Scraper pros:

• The trial token worked, and comment runs returned nested replies with parent and depth fields, ready to land in a dataset on a schedule
• The 1,935-comment thread came back in one run for 31 cents
• The listed per-story and per-profile events billed zero times in my nine runs; the run start and the comment events were the whole bill

Apify Hacker News Scraper cons:

• No story-by-id input, so reading one thread means a search run with a story tag and a word from the title
• 59 seconds for the big thread, and search took three to five seconds for 10 stories
• maxCommentDepth tops out at 10, and the actor returned more comment records than the story's own count on all three threads

The actor is a hosted worker with a schedule and a download button, and that's what you're paying for. Every search item carried source: algolia, and the top three titles for all three queries were the same ones Algolia and AnyAPI returned. Every search route on this page is Algolia's ranking under a different bill, so pick this one for the packaging: keyword, tag, and section inputs, a cap on items, a comment depth, and a dataset that fills up while you sleep.

Comments are the strongest part. Ask for them and each story arrives with a nested comments array, each comment carrying its parent, its depth, and its own replies. The Dropbox thread took about eight seconds, the IBM thread about seven, and the GPT-6 thread about a minute. Depth is capped at 10 by the input schema, and the actor returned 72, 243, and 2,017 comment records against story counts of 71, 223, and 1,935, so dedupe on id before you count.

Billing is per event, and the events that billed weren't the ones the page leads with. Search and profile runs charged one actor start at $0.01 and nothing else, even though the page lists $0.0004 per story and $0.0003 per profile. Comment runs charged $0.00015 a comment, 23, 194, and 1,968 events for the three threads. At 10 stories a run that's $1.00 per 1,000 stories observed; raise maxItems and the run start amortizes.

Apify Hacker News Scraper pricing: $0.00040 per story, $0.00015 per comment, $0.00030 per profile listed, plus $0.01 per run start; first 50 events per run free. My three 10-story search runs billed $0.01 each, and the three comment runs billed $0.01345, $0.0391, and $0.3052.

Bright Data (best for teams already on Bright Data who want a custom-built scraper)

Bright Data pros:

• 5,000 free records a month, the largest free allowance on this page
• Pay as you go at $1.50 per 1,000 after that, no plan

Bright Data cons:

• There's no Hacker News dataset to trigger; the datasets list returned 1,755 datasets and none for Hacker News
• The Hacker News pages quote the price in page loads and the pricing page quotes the same tiers in records
• My trial account's status call said it can't make requests because no zone exists, so nothing here is measured

Bright Data has no Hacker News endpoint to call on day one; it builds you a scraper. The product pages describe stories, scores, and discussion threads, but the scrapers library lists LinkedIn, Instagram, TikTok, Amazon, Facebook, X, YouTube, Reddit, ChatGPT, Google Search, and Google Maps, and Hacker News isn't among them. What the pages route you to is Scraper Studio, which builds a custom scraper from a URL and a prompt in 5 to 25 minutes and hands back a collector id you then trigger. That's a different product from a fixed API, and it's the right one only if your team already lives in Bright Data.

Read the unit before you size the bill. The Hacker News product page says 5K page loads a month free and the datasets page says $1.5 per 1K page loads, while the Web Scraper pricing page calls the same free tier 5,000 records. A page load of a thread and a comment record aren't the same thing, and nothing I found says which one a comment counts as.

Bright Data pricing: 5,000 records a month free, then $1.50 per 1,000 pay as you go; a $499 a month Scale plan includes 384,000 records and bills $1.30 per 1,000 beyond that.

AnyAPI (best for story, search, and profile reads in a multi-source app)

AnyAPI pros:

• Search returned 30 results a call with author, comments, createdUtc, id, points, title, and url populated on 30 of 30, at about 0.6 seconds
• One flat price for all four endpoints, $0.0015 a request, and a rejected request costs nothing
• The same envelope as every other AnyAPI source, so it drops into code already reading them through one key

AnyAPI cons:

• story_comments returned 32 of 71, 75 of 223, and 199 of 1,935 comments, every one a top-level comment, with no replies and no parameter to ask for them
• Story reads took about three times the official API's, and the story record doesn't echo its own id
• Profile returns bio, karma, and username, and nothing about what the user posted

AnyAPI's comments endpoint stops at the top level. It accepts an id and nothing else that changes the result, and what comes back is a flat array in which every comment's parentId is the story. On the Dropbox thread that was 32 of the 33 top-level comments and none of the 38 replies under them. On the GPT-6 thread it was 199 of 231 top-level comments and none of the roughly 1,700 replies. The story endpoint reports the full count right beside it, 71 and 1,935, so the gap is visible in the same two calls. If threads are your job, read them from Algolia.

curl -sS -X POST https://api.getanyapi.com/v1/run/hackernews.story_comments -H "Authorization: Bearer $ANYAPI_API_KEY" -H 'Content-Type: application/json' -d '{"id":"8863"}'

The other three endpoints do what their pages say. Search takes a query and optional tags and returns 30 results with every field filled; the ranking matched Algolia's top results for all three queries, and at 30 results a call the price works out to about 5 cents per 1,000 results. Story returns title, url, author, points, comment count, and created time in about half a second. Profile takes a handle and returns karma and bio. Sending a field the endpoint doesn't know, a limit on search or a username on profile, comes back as a free validation error with the schema in the body, which is a nicer way to learn the contract than the docs page.

Where this earns its place is an app that already reads several sources through one AnyAPI key and one prepaid wallet and wants Hacker News stories, search hits, and profiles in the same shape beside them. At $1.50 per 1,000 story reads it's about one and a half times Apify's observed rate and the official API is free and faster, so for a Hacker News-only build I'd use the free routes. And until story_comments returns replies, I wouldn't send it a thread.

AnyAPI pricing: $0.0015 per request on all four endpoints, $1.50 per 1,000, prepaid, no plan. New accounts start with about 100 free requests. My 36 measured calls billed $0.054.

Which Hacker News API should you use?

• You need live scores, stories, and profiles and you're fine assembling threads yourself: Official Hacker News API, with concurrency.
• You need keyword search, tag or date filters, or a whole thread in one call: Algolia HN Search API.
• You're in Node and want the official endpoints as functions: node-hn-api, and write the walk yourself.
• You want a scheduled job that lands nested comments in a dataset without running a worker: Apify Hacker News Scraper, and dedupe on id.
• Your team is already on Bright Data and wants a custom scraper built for you: Bright Data, after you confirm which unit a comment bills as.
• You're already on AnyAPI for other sources and want stories, search, and profiles in the same shape and on the same bill: AnyAPI, and read threads from Algolia.

The limits of this comparison

• Three stories, three queries, and three users, each read three times from one machine on 2026-09-04. That's a response-shape and rough-speed test, not an uptime or throughput benchmark, and every latency includes my network.
• The timers aren't equal. Apify's figures include actor startup and dataset delivery, the wrapper's include Node's fetch, and AnyAPI's include the gateway; the official and Algolia figures are a bare HTTP round trip.
• Bright Data was never measured: the trial account had no zone and the catalog had no Hacker News dataset, so its section is its pricing pages and one status call.
• The Apify actor returned more comment records than each story's own count, and its listed per-story and per-profile events never billed in my runs. I can report both from the run objects and can't explain either.
• AnyAPI's story_comments cap is inferred from three responses and the endpoint's schema, which has no limit or cursor field. Every one of the 36 AnyAPI calls returned replayed false, so none of the repeats came from a cache.
• Historical snapshots weren't tested. BigQuery's public Hacker News dataset is the usual route for that, and the first 1 TiB of queries a month is free.
• Prices and docs checked on 2026-09-04. The free routes exclude whatever your own infrastructure costs to run them.

The Polymarket API comparison and the Substack API comparison run the same test on two other platforms where the free route is the right answer more often than the paid ones, and the API catalog lists what else bills through the same wallet if you're wiring up more than one source.

Use data responsibly and follow AnyAPI's Acceptable Use Policy.