Product Hunt Scraper API: Official API vs Scraping

If you're searching for a Product Hunt scraper API, you're usually after one of three things: launch data for market research, maker profiles for outreach, or a live feed of new products in your niche. The right answer differs for each — and the biggest surprise for most teams is what the official API doesn't include. This guide maps the entire 2026 landscape: the official GraphQL API, scraper APIs, and no-code options, compared on data coverage, rate limits, cost, and maintenance, with the code and workflows to make each one work.

Product Hunt is unusually valuable as a data source because of what a launch represents. A product on the front page means a founder with budget, momentum, and a public admission of exactly what they're building and who it's for. For anyone selling to startups — dev tools, infrastructure, agencies, investors sourcing deals — that's a stream of qualified, time-stamped intent. The question is only how to get it out cleanly, and that's where the API-versus-scraping decision starts to matter.

Before comparing tools, it's worth being precise about the two fundamentally different jobs people lump under "Product Hunt scraper." The first is data collection — launches, votes, topics, trends — a research job the platform actively supports through its API. The second is contact extraction — turning makers into emails you can reach — which the platform does not support at all, by design. Almost every frustration with Product Hunt scraping traces back to using a tool built for one job to do the other. The rest of this guide keeps the two jobs separate, because the right tool for each is genuinely different.

Option 1: The official Product Hunt API

Product Hunt ships a public GraphQL API (v2) with OAuth authentication. It's the cleanest starting point and it's free to use.

What it returns:

• Posts — name, tagline, description, votes, comments count, launch date, topics, media, and the product's redirect URL.
• Makers and hunters — username, name, headline, profile URL, follower counts, and the products they're associated with.
• Topics and collections — for filtering launches by niche (AI, developer tools, fintech, and so on).
• Your own account data — votes, collections, notifications.

A typical query to pull today's launches looks like this:

query TodaysPosts {
  posts(order: RANKING, first: 20) {
    edges {
      node {
        name
        tagline
        votesCount
        website
        makers { name username headline }
        topics { edges { node { name } } }
      }
    }
  }
}

Clean, structured, and reliable. But note what's missing from that makers block.

What it does not return:

• Email addresses. No maker emails, ever — this is the hard stop for outreach use cases, and no clever query works around it, because the data simply isn't in the schema.
• Historical bulk exports. Pagination is cursor-based and rate-limited; backfilling years of launches takes days of careful paging.
• Some profile fields shown on the website — external links on maker profiles are inconsistent or absent through the API even when they're visible on the site.

Rate limits are the real constraint. The API uses a complexity-based scheme: each query costs points based on how much it asks for, and you get a budget per 15-minute window. In practice that's a few hundred meaningful requests per window — comfortable for a dashboard that polls periodically, painful for bulk collection where you're paging through thousands of nodes.

Verdict: perfect for research, trend tracking, and building integrations against your own account. A dead end if your goal is contacting makers, because the emails were never there to extract.

Option 2: Scraper APIs over the Product Hunt website

When the official API's fields or limits don't fit, the next tier is scraping the website itself — either with your own crawler or a general-purpose scraper API that handles proxies and JavaScript rendering for you.

What scraping adds over the API:

• External links on maker profiles — personal sites, X handles, LinkedIn URLs — the raw material for email enrichment. This is the single biggest reason to scrape instead of using the API.
• Full launch pages including complete comment threads and reviewer sentiment, useful for competitive research.
• No OAuth complexity quota — your throughput is limited by proxy budget rather than a points system.

What it costs you: Product Hunt is a client-rendered React app, so a plain HTTP fetch returns a nearly-empty shell. You need headless browsers (Playwright or Puppeteer) or a rendering proxy that executes JavaScript, plus ongoing maintenance every time the markup shifts. Budget $1–3 per 1,000 pages through commercial scraper APIs before you've extracted a single email, and add engineering time for the parsers.

A realistic architecture if you build this yourself:

1. Use the official API (free) to discover relevant posts and maker usernames — this avoids scraping discovery pages.
2. Scrape each maker's public profile page for the external link the API omits.
3. Crawl that external link for a contact email.
4. Verify each email.

Notice that even the "scraping" path leans on the official API for the part it's good at. Fighting the API for discovery when it's free and structured is wasted effort; scrape only for the fields it withholds.

Verdict: the flexible middle path — but you're building profile scraping, link-following, email extraction, and verification yourself, and maintaining all of it against a site that changes.

Option 3: A purpose-built Product Hunt scraper (no code)

Purpose-built tools collapse the whole pipeline — discovery, profile scraping, email enrichment, verification, deduplication — into one step. With Outsoci's Product Hunt scraper, you enter a keyword ("AI writing", "developer tools", "fintech") and get back a CSV of makers and founders in that niche with verified email addresses, deduplicated and export-ready.

The trade-off is scope: you get the lead-gen slice done extremely well, not a general-purpose data feed. If you need every historical vote count for a market-sizing model, the official API is your tool. If you need a contactable list of founders who launched in your category, a purpose-built scraper gets you there without an engineering project.

Pricing is per-result — 1,000 credits for $9/month, where a scraped lead costs one credit — so a 200-founder list runs a couple of dollars instead of a sprint. The $1 trial includes 100 credits, enough to validate whether your category has enough contactable makers before you commit.

Verdict: the shortest path if your end goal is a contactable list of makers rather than raw launch data.

Head-to-head comparison

	Official PH API	DIY / scraper API	Outsoci
Launch & vote data	✅ Best source	✅	⚠️ Lead-focused
Maker profiles	✅ Basic fields	✅ Full page	✅
Maker emails	❌ Never	🔧 Build it yourself	✅ Verified, built-in
External profile links	⚠️ Inconsistent	✅	✅
Rate limits	Strict complexity quota	Your proxy budget	Credit-based
Setup	OAuth + GraphQL	Crawler + parsers	None
Maintenance	Low	High (UI changes)	None
Cost	Free	$1–3 / 1k pages + eng time	From $9/mo

Use cases and which option fits

Different goals point to different tools. Matching them up front saves you from building the wrong thing.

Market and competitive research

You want launch volume by category, vote trends, taglines, and who's hunting what. The official API is ideal — free, structured, and the data (votes, topics, dates) is exactly what it's built to serve. Poll daily, store to your own database, and you have a research feed with near-zero maintenance. No scraping needed.

Founder and maker outreach

You want to email the people behind relevant launches. The official API can't help (no emails), so you need scraping plus enrichment — either DIY or a purpose-built tool. The decision is build-versus-buy: if you'll run this monthly and value your engineering time, a managed scraper wins; if you have idle crawler infrastructure and niche requirements, DIY can make sense.

Investor and deal sourcing

You want early signal on traction plus a way to reach founders. This is a hybrid: official API for the traction signal (vote velocity, comment counts), enrichment for the contact. Combining them beats either alone.

Building a product directory or aggregator

You want to mirror large swaths of Product Hunt data into your own product. Be careful here — Product Hunt's terms restrict wholesale replication of its data, and this is the use case most likely to draw a cease-and-desist. The API's rate limits are partly designed to prevent exactly this. Talk to them about a partnership before building.

A worked example: sourcing dev-tool founders

Concrete beats abstract, so here's the hybrid pipeline run end to end for a company selling CI/CD infrastructure to early-stage dev-tool startups.

Goal: reach the founders of developer-tool products that launched in the last 90 days with real traction.

• Discover (official API, free): query posts in the developer-tools and open-source topics, ordered by ranking, paging back 90 days. Store name, tagline, vote count, launch date, and maker usernames. This costs a trickle of API quota and zero dollars.
• Shortlist (your own filter): keep launches above ~200 votes — the traction threshold that implies budget and momentum. Say that leaves 60 products.
• Get the missing field (scrape): for each of the 60, scrape the maker profile pages for the external link the API doesn't reliably return. ~50 have one.
• Enrich (crawl): follow each link, crawl the contact and about pages for an email. ~35 surface one.
• Verify + dedupe: validate the 35, lose a handful to invalid addresses, dedupe against your CRM. ~30 net-new, highly-qualified founders remain.

Thirty founders who just launched a dev tool, sorted by traction, with verified emails — that's a warm, time-sensitive list you can reference specifically ("saw your launch hit #3 last Tuesday") instead of a generic blast. The API did the discovery it's good at; scraping filled the one gap it leaves; enrichment and verification turned profiles into a campaign. Every stage played to its strength.

If you'd rather not build the scrape-and-enrich half, Outsoci's Product Hunt scraper does exactly that from a keyword, and you keep using the official API for the research feed. The two aren't mutually exclusive — most teams that take Product Hunt seriously run both.

A practical hybrid workflow

Teams that need both research data and outreach lists usually combine tiers into one pipeline:

1. Track launches with the official API. Pull daily posts in your topics, store votes and taglines. Free and stable.
2. Shortlist the relevant products. Filter by traction (vote velocity in the first hours is a strong signal), topic, or keywords in the tagline.
3. Run the shortlist through a lead scraper. Turn each product's maker profiles into verified emails with a tool like Outsoci, or your own enrichment pipeline.
4. Verify before sending. Even "public" emails decay; verification keeps bounce rates under control and protects your sending domain. We covered the full outreach process in How to scrape Product Hunt.

This keeps your API quota usage tiny (you only page through your own topics), your scraping costs proportional to the shortlist rather than the whole site, and your research feed independent of any scraper's uptime.

Costs compared over a real month

Say you want to reach makers from ~500 relevant launches a month. Here's roughly how the three paths compare:

• Official API only: $0, but you get zero emails — it can't do this job at any price.
• DIY scraper + enrichment: ~$5–15 in proxies and verification API calls, plus the real cost — several days of initial engineering and ongoing maintenance whenever Product Hunt ships a UI change. Cheap in dollars, expensive in time.
• Purpose-built tool: ~500 credits, which at $9/1,000 credits is roughly $4.50, with zero setup or maintenance. The $1 trial covers your first 100 to test the fit.

For most teams the deciding factor isn't the per-lead cost — all three are cheap — it's whether you want to own and maintain a scraping stack. If lead gen is core to your business and you'll customize heavily, build it. If it's one channel among many, buy it and spend the engineering time elsewhere.

Key takeaways

• Separate the two jobs: data collection (launches, votes, topics) is what the official API is built for; contact extraction (maker emails) is what it deliberately won't do.
• The official GraphQL API is free and ideal for research and trend tracking — but returns zero emails at any tier.
• For outreach, you need scraping plus enrichment: follow maker profile links to their sites, crawl for emails, verify. Build it yourself or use a purpose-built tool.
• The strongest workflow is hybrid: discover with the free API, enrich the shortlist with a scraper — keeping quota use and cost low.
• All paths are cheap per lead; the real decision is whether you want to own and maintain a scraping stack.

FAQ

Does Product Hunt have an official scraping API? Product Hunt has an official GraphQL API for posts, makers, and topics — but it prohibits large-scale replication of its data and returns no email addresses. "Scraper APIs" are third-party services that extract data from the public website instead.

Can I get maker emails from the Product Hunt API? No. No tier of the official API exposes emails. Emails come from following makers' external links (personal sites, socials) and enriching from there — which is what dedicated tools automate.

Is scraping Product Hunt legal? Collecting publicly displayed data is broadly defensible; the sensitive parts are respecting rate limits, not wholesale-replicating their dataset, and handling personal data (emails) lawfully once collected. See our guide on whether email scraping is legal.

What's the cheapest way to scrape Product Hunt at small scale? For pure launch data: the official API, free. For a contactable founder list under ~100 leads: a purpose-built scraper's trial tier (Outsoci's $1 trial includes 100 credits) will be cheaper than an afternoon of engineering.

Can I scrape Product Hunt in real time? The official API is the right tool for a live feed — poll it on a schedule. Scraping the site in real time is possible but wasteful; use the API for freshness and scraping only for the enrichment fields the API lacks.

How do I avoid getting blocked scraping Product Hunt? Do discovery through the free official API rather than crawling listing pages, render JavaScript for the pages you do scrape, rotate IPs, and keep request rates modest. Better yet, only scrape the maker profiles you've already shortlisted so your volume stays low.

Does the API include comments and reviews? Yes — comment counts and comment content are available through the API, which makes it the better tool than scraping for sentiment analysis on a launch.