Product Hunt API

A Product Hunt API that returns the launches on a leaderboard — a day, an ISO week or a month — with rank, name, tagline, the score shown on the upvote button and the score on launch day, comment count, topics, the launch and product URLs and the thumbnail. No API key, no token, no rate-limited GraphQL: the page’s own cache, read on the TLS tier.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Get my free API key See the request

$0.001 per delivered launch · $2 free every month · Failed runs never billed

POST /v1/scraper/collectors/producthunt_posts/run

$ curl $QD/producthunt_posts/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"period": "daily", "date": "2026-09-01", "max_results": 20}'
{ "status": "done", "count": 20,
  "results": [
    {
      "leaderboard": "…",
      "id": "…",
      "name": "…",
      "tagline": "…" } ],
  "cost": 0.02 }
# 20 launchs × $0.001 · nothing delivered, nothing charged

Product Hunt API: period and date in, a residential exit in the middle, delivered rows with rank, leaderboard and id on the right, $0.001 per launch. — You send period and date; the run goes out through a residential exit and comes back as launches with rank, leaderboard and id — 18 fields on every row — and you are billed $0.001 for each launch actually delivered, nothing for a run that delivers none.

$0.001 / launch2,000 launchs on the free $2 every month

Semantic inputperiod, date, max_results — no URL lists

Up to 200launchs per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Try it

Product Hunt launches, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

What a Product Hunt API does

Product Hunt server-renders its home feed with the hydrated GraphQL cache inline, and the leaderboard lives in that cache with every field this collector delivers — score, comments, topics, thumbnail, ranks, timestamps — none of which the visible markup states; the rendered page shows names and taglines only. The keyword search page is readable but its cache entry carries no score, comments or topics, and the category pages answer a plain fetch with a challenge, which is why the input is a period rather than a keyword: the leaderboard is the only surface that states the full row.

Three traps produce wrong rows rather than none, and all three are handled. Advertisements share the feed array and carry a name and a tagline like a launch — a typical day is twenty entries, seventeen launches and three ads — so only true posts are delivered and the dropped ads are counted in the notes. The score is latestScore, the current activity score that keeps moving after launch day; there is no vote count on the page, so score_on_launch_day is delivered beside it rather than instead of it. And ranks are strings, absent on some nodes, read as such.

Limits, in plain numbers

Everything that bounds one run of this collector. No hidden throttles.

Max per run

200 launchs

Price

$0.001 / launch

Per 1,000

$1.00

Failed runs

Free zero rows, zero charge

Free every month

$2 no card

Rate limit

60 req/min on the free tier

What one launch looks like

Every delivered launch carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer · nullable	Position on the requested leaderboard; null when Product Hunt states no rank for the launch.
`leaderboard`	string	The leaderboard this row came from — 2026-09-01, 2026-W36 or 2026-09.
`id`	string	Product Hunt launch (post) id — stable, and the de-duplication key.
`name`	string	Launch name.
`tagline`	string · nullable	One-line tagline.
`score`	integer · nullable	The number shown on the launch's upvote button. Product Hunt states this is the current active score — votes plus discussion and overall activity — not a raw vote tally, and it keeps rising after launch day.
`score_on_launch_day`	integer · nullable	The same score frozen at the end of the launch day, so two runs days apart stay comparable.
`comments`	integer · nullable	Comment count on the launch.
`topics`	string[] · nullable	Topic names Product Hunt tagged the launch with.
`topic_slugs`	string[] · nullable	The same topics as URL slugs, for /topics/<slug>.
`url`	string · nullable	The launch page — /products/<product_slug>?launch=<slug>, the form Product Hunt's own links use.
`product_url`	string · nullable	The product's page, without the launch selected.
`thumbnail`	string · nullable	Launch thumbnail on Product Hunt's image CDN.
`slug`	string · nullable	Launch slug — not the same as the product slug, and not routable on its own.
`product_slug`	string · nullable	Product slug, the segment that addresses the page.
`featured_at`	string · nullable	When the launch was featured (ISO 8601, Product Hunt's -07:00 offset).
`created_at`	string · nullable	When the launch was created (ISO 8601).
`score_hidden`	boolean	Product Hunt hides the score on this launch's card; the value is still stated and delivered.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`period`	string	no	Which leaderboard to read: the day, the ISO week or the month containing the date. One of: `daily`, `weekly`, `monthly`.
`date`	string	no	Any date inside the period, as YYYY-MM-DD. Defaults to today in Product Hunt's own timezone (America/Los_Angeles), where the launch day opens at 00:01.
`max_results`	integer	no	How many launches to deliver at most (1–200). You pay only for delivered launches.
`country`	string	no	ISO 3166-1 alpha-2 code — proxy exit geo and Google locale (gl). Omit for the default pool.

Pricing

Product Hunt API pricing

$0.001 per delivered launch. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 2,000 launchs before you spend anything.

$0.001per delivered launch$1 per 1,000 delivered launchs

2,000 launchson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/producthunt_posts/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/producthunt_posts/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"period":"daily","date":"2026-09-01","max_results":20}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/producthunt_posts/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "period": "daily",
        "date": "2026-09-01",
        "max_results": 20
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/producthunt_posts/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"period":"daily","date":"2026-09-01","max_results":20}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the producthunt_posts collector with period="daily" and date="2026-09-01"

What people build with the Product Hunt API

Three shapes of work this endpoint was designed around.

Launch tracking

Yesterday’s leaderboard every morning, keyed by post id, with score and comment count to watch which launches keep climbing.

Market and competitor scanning

Topics per launch, so a category — AI, developer tools, productivity — can be filtered over weeks and months.

Deal and partnership sourcing

Product URL and launch URL per row, ready for enrichment with the company-data collector.

Product Hunt API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Access	An API token, a dashboard and rate limits	The public page, no key
Ads in the feed	Delivered as launches	Dropped and counted
Score	“Votes” that do not exist on the page	`score` and `score_on_launch_day`, both as stated
Fields	Names and taglines from the markup	Score, comments, topics, thumbnail from the cache

What people search for

Live autocomplete demand around Product Hunt launches, pulled with our own Keyword ideas collector.

Product Hunt API: the POST to /v1/scraper/collectors/producthunt_posts/run with period and date on the left, and the JSON envelope on the right with 20 launches and usage.cost_usd $0.02. — The same call you would paste into a terminal: a Bearer key, period, date and country in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many launches arrived and usage.cost_usd is $0.02, which is 20 × $0.001. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the Product Hunt API.

Something else? Ask us →

Why a period and not a keyword?

Because only the leaderboard states the full row. The search page’s cache carries no score, comments or topics, and the category pages challenge a plain fetch. Filter by topics on the rows for a keyword-like view.

Does it need a Product Hunt API key?

No. Product Hunt’s official API needs a token and enforces rate limits; this reads the public leaderboard page.

Is score the same as upvotes?

It is the score shown on the upvote button — Product Hunt’s current activity score, which keeps moving after launch. The launch-day score is delivered alongside it, so you have both.

How far back can I go?

Any day, ISO week or month Product Hunt has a leaderboard page for: pass period and date.

Is there a free Product Hunt API?

Every account gets $2 of credit every month with no card, which is about 2,000 delivered launchs on this endpoint at $0.001 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.001. A run capped at 200 launchs — the maximum for this collector — costs $0.2 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the Product Hunt API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Get my free API key