# Product Hunt Scraper (with Email Enrichment) (`khadinakbar/producthunt-scraper-pro`) Actor

Extract product names, upvotes, makers, taglines, and website URLs from ProductHunt MCP-ready. $2.00/1K.

- **URL**: https://apify.com/khadinakbar/producthunt-scraper-pro.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, MCP servers, Open source
- **Stats:** 69 total users, 11 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Product Hunt Lead Generator — Products, Websites & Verified Emails

Turn Product Hunt launches into reviewable company-lead records for product, growth, research, and sales teams. Give the Actor a daily range, weekly/monthly/yearly period, search, topic, direct post, or dated leaderboard URL; each dataset row returns the product, verified website, up to three ranked emails, exact EmailListVerify status, discovery provenance, and lead score.

### Use this Actor when

Use this Actor when Product Hunt is the discovery source and you need structured product rows with reviewed website and email provenance.

- Product Hunt is the source list and you need one normalized row per published product.
- You need the real product website, not only Product Hunt's redirect URL.
- You want public product-site and maker-homepage emails checked before a paid contact-finder fallback.
- You need verification statuses and provenance to review contacts before downstream use.

Avoid this Actor when you need private contact data, complete email coverage, consent or outreach automation, a general-purpose crawler for arbitrary websites, or Product Hunt API use that is not permitted by the access and commercial terms attached to your account.

### Best fit and connected workflows

This Actor fits workflows that start with Product Hunt discovery and end with a usable lead list or product research table. It is a good route when you want:

- Product Hunt launch monitoring by daily, weekly, monthly, or yearly views
- keyword-based discovery from Product Hunt search
- topic-based routing from a Product Hunt topic slug
- direct enrichment from a known post or leaderboard URL
- verified external websites and ranked public email contacts in one dataset
- use through Apify MCP for agent-driven Product Hunt research and lead qualification

When you need a Product Hunt record plus website provenance, this Actor keeps the workflow in one place. It also supports internal agent workflows through Apify MCP, so an AI agent can request products, inspect the dataset, and continue downstream processing with the returned rows.

### Focused standalone workflow

Product Hunt Lead Generator — Products, Websites & Verified Emails is designed as a focused standalone workflow.

### Practical scenario

Maya, a sales ops analyst, starts with a weekly Product Hunt leaderboard and a list of products relevant to developer tools. She runs the Actor with `mode` set to `leaderboard`, `leaderboardPeriod` set to `weekly`, and email enrichment enabled. The Actor returns records with `product_name`, `website_url`, `emails`, `verified_emails`, `lead_status`, and `lead_tier`. Maya uses the verified email fields to route qualified products into her outreach queue and uses `website_resolution_source` and `lead_signals` to review where each contact came from before exporting the dataset.

### Input fields

| Field | Type | Description |
| --- | --- | --- |
| `mode` | string | Scraping mode: `leaderboard`, `search`, `topic`, or `urls`. |
| `leaderboardPeriod` | string | Used with `leaderboard`: `daily`, `weekly`, `monthly`, or `yearly`. |
| `searchQuery` | string | Keyword used in search mode. |
| `topic` | string | Product Hunt topic slug used in topic mode. |
| `startUrls` | array | Specific Product Hunt post URLs or leaderboard URLs used in `urls` mode. |
| `maxResults` | integer | Maximum number of products to return. |
| `excludeProductHuntUrls` | array | Product Hunt launch URLs to skip before enrichment, for cost-efficient continuation after a prior capped run. |
| `productHuntResumeCursor` | string | Optional opaque cursor from `RUN_SUMMARY.nextProductHuntCursor`; resumes the same query directly after a capped page. |
| `includeAllProducts` | boolean | Includes featured and non-featured published products when enabled. |
| `maxConcurrency` | integer | Maximum concurrent enrichment jobs. |
| `enrichEmails` | boolean | Enables website-based email discovery. |
| `resolveWebsites` | boolean | Resolves and verifies external product websites. |
| `maxWebsitePages` | integer | Maximum verified website pages assessed per product, up to 5. |
| `maxEmailsPerProduct` | integer | Maximum public emails returned per product, up to 3. |
| `verifyEmails` | boolean | Verifies selected public emails with EmailListVerify. |
| `findContacts` | boolean | Uses the managed contact finder when public pages return fewer deliverable emails. |
| `websiteUrlOverrides` | array | Approved mapping from a Product Hunt item to an external website. |
| `startDate` | string | Start date for daily leaderboard mode, in `YYYY-MM-DD`. |
| `endDate` | string | End date for daily leaderboard mode, in `YYYY-MM-DD`. |
| `lookbackDays` | integer | Rolling recent window when `startDate` is omitted. |
| `outputMode` | string | `full`, `lean`, or `leads`. |

#### Focused JSON input example

```json
{
  "mode": "leaderboard",
  "leaderboardPeriod": "daily",
  "startDate": "a source-provided date",
  "endDate": "a source-provided date",
  "maxResults": 50,
  "includeAllProducts": true,
  "resolveWebsites": true,
  "enrichEmails": true,
  "maxWebsitePages": 5,
  "maxEmailsPerProduct": 3,
  "verifyEmails": true,
  "findContacts": true,
  "outputMode": "leads"
}
```

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `product_name` | string | public Product Hunt product name. |
| `tagline` | string or null | Short Product Hunt tagline. |
| `description` | string or null | Full Product Hunt description. |
| `upvote_count` | integer or null | Total upvotes. |
| `comment_count` | integer or null | Total comments. |
| `reviews_count` | integer or null | Number of reviews. |
| `reviews_rating` | number or null | Average rating. |
| `daily_rank` | integer or null | Daily leaderboard rank. |
| `weekly_rank` | integer or null | Weekly leaderboard rank. |
| `monthly_rank` | integer or null | Monthly leaderboard rank. |
| `yearly_rank` | integer or null | Yearly leaderboard rank. |
| `launch_date` | string or null | Product Hunt launch date. |
| `product_hunt_url` | string or null | Canonical Product Hunt post URL. |
| `website_url` | string or null | Verified external website. |
| `product_hunt_website_url` | string or null | Original Product Hunt website field, kept for provenance. |
| `website_resolution_source` | string | How the website was resolved. |
| `website_resolution_status` | string | Website resolution status. |
| `website_resolution_confidence` | integer | Confidence score from 0 to 100. |
| `website_resolution_signals` | array | Evidence used to accept the website. |
| `company_domain` | string or null | Normalized domain used for email ranking. |
| `emails` | array | Ranked contact emails found for the product. |
| `verified_emails` | array | Emails verified as deliverable. |
| `risky_emails` | array | Emails that were returned with a non-ok verification status. |
| `rejected_emails` | array | Emails excluded from the final lead list. |
| `email_verifications` | array | Exact EmailListVerify result objects. |
| `email_verification_requested` | boolean | Indicates whether verification was requested for the run. |
| `email_source` | string | `page_scrape`, `maker_website`, `emaillistverify_contact_finder`, `mixed`, or `none`. |
| `email_result` | string | Email enrichment result summary. |
| `email_coverage` | string | Crawl coverage summary. |
| `email_terminal_reason` | string | Bounded reason for the email result. |
| `email_pages_visited` | integer | Number of verified external pages assessed. |
| `email_page_urls` | array | Same-origin website pages assessed for email extraction. |
| `maker_email_pages_visited` | integer | Number of public Product Hunt maker homepages assessed after the product-site pass. |
| `maker_email_page_urls` | array | Public maker homepages assessed for gap-filling email discovery. |
| `contact_discovery_requested` | boolean | Indicates whether managed contact discovery was eligible. |
| `contact_discovery_attempts` | integer | Number of bounded contact-finder requests made. |
| `contact_discovery_credits` | integer | Contact-finder credit ceiling used. |
| `lead_status` | string | Lead classification. |
| `lead_score` | integer | Deterministic qualification score. |
| `lead_tier` | string | Lead tier derived from score. |
| `lead_signals` | array | Plain-language signals explaining the lead score. |
| `enrichment_warnings` | array | Safe per-record warnings. |
| `topics` | array | Product Hunt category tags. |
| `thumbnail_url` | string or null | Product Hunt thumbnail URL. |
| `makers` | array | Maker records from the public API. |
| `featured` | boolean | Whether the product was featured on Product Hunt. |
| `scraped_at` | string | ISO timestamp of extraction. |

#### Illustrative JSON output record

```json
{
  "product_name": "Notion AI",
  "tagline": "AI-powered writing for everyone",
  "upvote_count": 1284,
  "launch_date": "a source-provided date",
  "product_hunt_url": "https://www.producthunt.com/posts/notion-ai",
  "website_url": "https://notion.so/",
  "website_resolution_source": "dataforseo_organic",
  "website_resolution_status": "verified_external",
  "website_resolution_confidence": 91,
  "company_domain": "notion.so",
  "emails": ["hello@notion.so", "support@notion.so"],
  "verified_emails": ["hello@notion.so"],
  "risky_emails": ["support@notion.so"],
  "email_verifications": [
    {
      "email": "hello@notion.so",
      "provider": "emaillistverify",
      "status": "ok",
      "source": "public_website",
      "confidence": null,
      "checkedAt": "2026-08-24T14:30:00.000Z"
    }
  ],
  "email_source": "mixed",
  "email_result": "emails_found",
  "email_coverage": "complete",
  "email_pages_visited": 3,
  "lead_status": "verified_contact",
  "lead_score": 84,
  "lead_tier": "A",
  "topics": ["Productivity", "Artificial Intelligence", "Writing"],
  "featured": true,
  "scraped_at": "2026-03-28T14:30:00.000Z"
}
```

### How it works

The Actor routes Product Hunt inputs through the public Product Hunt API. Bounded daily, weekly, monthly, and yearly timelines paginate newest-first because creation time is stable while vote totals can change during a long run; vote and rank fields remain in every result. For website enrichment, it first uses an available external ProductLink or approved override, then resolves redirects, evaluates listed maker sites, follows likely product links published on those maker sites, and checks identity-confirmed vendor pages for protected foundation-model launches before using DataForSEO or SerpApi as bounded search fallbacks. Search starts with the full launch name and may use one conservative core-brand query when a compound launch name does not resolve; documented transient DataForSEO failures may consume that second attempt as a retry instead. Before consuming the scarce free SerpApi fallback, the resolver also tests a bounded set of obvious brand-domain hypotheses. Known launch directories and software catalogs are rejected, while official Claude, Gemini, and GPT model launches are restricted to their vendors' domains to prevent lookalike-site contamination. Each candidate website is accepted only after its homepage or exact official product page passes identity checks; ambiguous one-word product names also need purpose/tagline evidence.

After website resolution, the Actor assesses up to five same-origin public product pages, starting with the homepage and then directly linked contact, about, team, privacy, or terms pages. Static and browser-rendered navigation are merged so JavaScript-injected footer links do not hide an eligible page. Extraction covers visible/plain addresses, `mailto:` links, JSON-LD, percent-encoded links, common `[at]` / `[dot]` and JavaScript-escaped forms, and Cloudflare-protected public email attributes. It keeps a bounded reserve of up to six ranked product-site candidates, then verifies them in order only until three usable addresses are secured. This avoids ending the crawl after three raw addresses when some later fail verification, while avoiding unnecessary verification calls once the output is full. Verification transport, HTTP 429, and HTTP 5xx failures receive one bounded retry; invalid or disabled addresses do not. If deliverable slots remain, it checks up to two public maker homepages listed by Product Hunt for published contact addresses, verifies those candidates, and only then uses managed Contact Finder. The final row is ranked and capped at three contacts.

The record is then written to the default dataset with provenance, lead status, lead score, lead tier, and per-record warnings.

### Pricing and platform usage

This Actor uses Apify Pay per event pricing plus Apify platform usage.

- Each product row successfully stored in the default dataset costs **$0.002**.
- Each selected email returned in that stored row costs **$0.04**.
- Actor start costs **$0.00005 per GB of allocated memory**, with at least one start event.
- Platform compute, storage, and any configured Apify resources are separate from event charges.
- For current pricing details, use the live Pricing tab on the Actor page.

Worked example: at the default 4 GB memory, a run that stores 20 result rows and returns 5 emails costs about **$0.2402 in Actor events**: 20 × $0.002 + 5 × $0.04 + 4 × $0.00005, plus Apify platform usage. Fewer returned emails cost less. Upstream discovery is ordered to try Product Hunt evidence and public pages before usage-billed fallbacks.

### Use with AI agents (MCP)

This Actor is usable through Apify MCP as a tool for Product Hunt discovery and lead enrichment. The tool can accept a Product Hunt mode, resolve websites, return email-rich lead rows, and expose dataset records for follow-up agent steps.

**Actor identity:** `khadinakbar/producthunt-scraper-pro`

> Find Product Hunt products from the weekly leaderboard, resolve the company websites, and return only records with verified emails. Use the dataset rows to summarize the top leads and their source provenance.

The returned output is best interpreted as row-level evidence. `website_resolution_source` and `website_resolution_signals` explain how the website was accepted, `email_verifications` captures exact provider statuses, and `lead_status` plus `lead_tier` provide a deterministic summary for downstream agent filtering. Pagination is governed by `maxResults`, and cost scales with the number of stored product rows and selected emails. For agent workflows, `lean` output mode can reduce context size while preserving product name, tagline, website, upvotes, rank, emails, and topics.

### Apify API example

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const input = {
  mode: "topic",
  topic: "developer-tools",
  maxResults: 10,
  resolveWebsites: true,
  enrichEmails: true,
  verifyEmails: true,
  findContacts: true,
  outputMode: "leads",
};

const run = await client.actor("khadinakbar/producthunt-scraper-pro").call(input);

const datasetItems = await client.dataset(run.defaultDatasetId).listItems();
for (const item of datasetItems.items) {
  console.log(item.product_name, item.website_url, item.verified_emails);
}
```

### Best results and outcome guidance

Use the narrowest input that matches the task:

- Use `leaderboard` for ranked Product Hunt discovery by time period.
- Use `search` when you already have a keyword theme.
- Use `topic` when you know the Product Hunt topic slug.
- Use `urls` when you have specific posts or leaderboard URLs.
- Use `leads` output mode when your next step is outreach or CRM import.

If you want a compact lead list, keep website resolution and email verification enabled. If you want broader product research, use `full` or `lean` and inspect the ranking and topic fields. For daily leaderboard ranges, `startDate` and `endDate` provide a clear date window in one run.

### Design note

I found that the live contract returns up to three ranked emails per product, while the output schema keeps separate arrays for `verified_emails`, `risky_emails`, and `rejected_emails`. That structure makes it straightforward to distinguish contact quality from raw discovery.

### FAQ

#### Can I use this Actor for Product Hunt daily leaderboard tracking?

Yes. Use `mode: "leaderboard"` with `leaderboardPeriod: "daily"`, then set `startDate` and `endDate` for a date window or `lookbackDays` for a rolling recent window.

#### Can I pass a Product Hunt post URL directly?

Yes. Use `mode: "urls"` and add the post or leaderboard URL to `startUrls`.

#### Does this Actor return only featured Product Hunt products?

It can return featured and non-featured products. Keep `includeAllProducts` enabled for broader coverage, or disable it for featured-only results.

#### How should I connect this to an outreach workflow?

Use the `leads` output mode, then filter by `lead_status`, `lead_tier`, and `verified_emails` before exporting to your CRM or enrichment pipeline.

#### Can an AI agent consume the output directly?

Yes. The Actor is MCP-ready, and `lean` or `leads` output mode can keep the dataset compact enough for agent-based follow-up.

### Limitations and troubleshooting

- Email coverage may be incomplete. Many product sites publish no business address, and some block automated browsers or render contact details behind forms.
- The five-page limit applies to the verified product website: homepage first, followed only by contact, about, team, privacy, or terms links actually published on that homepage. Up to two Product Hunt maker homepages may be checked separately for a public contact when product-site slots remain.
- A Product Hunt redirect, maker link, or search result is not accepted merely because its name looks similar. Failed identity checks remain unresolved; use `websiteUrlOverrides` only when you have reviewed the correct external site.
- `PARTIAL` means useful rows were stored but at least one website, provider call, or charge-limit branch did not complete. Inspect `RUN_SUMMARY`, `website_resolution_status`, and `enrichment_warnings` before retrying.
- If `RUN_SUMMARY.resultLimitReached` is true, rerun with the same mode, filters, and date range; pass `RUN_SUMMARY.nextProductHuntCursor` as `productHuntResumeCursor` and the prior dataset's `product_hunt_url` values as `excludeProductHuntUrls`. The cursor jumps directly past the capped page. Long runs also update `RUN_CHECKPOINT`; after an interruption, use its `productHuntResumeCursor` together with stored launch URLs to resume from the latest safely completed page. For older runs without a cursor, exclusions still work: the Actor pages past them with lightweight Product Hunt index queries, without website/email enrichment, then switches to full-page queries at the first unseen launch.
- If verification or managed contact discovery reports a provider-credit warning, keep the public-page results, replenish the owner-managed pay-as-you-go balance if appropriate, and rerun only the affected products.
- Verification reports likely deliverability at check time. It does not prove ownership, relevance, consent, or permission to contact someone.

### Validation snapshot

On 2026-09-06, the v1.4 source passed 52 deterministic tests, including stable timeline ordering, the six-candidate verification reserve, transient provider retry, encoded-email recovery, merged static/rendered page planning, and safe cursor checkpoint selection. Exact-build cloud evidence and terminal `RUN_SUMMARY` readback remain the release gate.

### Responsible use

Product Hunt is a trademark of its owner. This independent Actor is not affiliated with, associated with, or endorsed by Product Hunt.

Use Product Hunt data only under the access and commercial terms that apply to your account. Respect destination-site terms, robots directives where applicable, privacy and anti-spam laws, lawful-basis requirements, suppression lists, and opt-outs. Verification indicates deliverability, not consent to contact.

# Actor input Schema

## `mode` (type: `string`):

How to find products. Use 'leaderboard' for top-ranked products by time period. Use 'search' when the user provides a keyword. Use 'topic' for a ProductHunt topic slug. Use 'urls' for specific ProductHunt URLs.

## `leaderboardPeriod` (type: `string`):

Only used when mode='leaderboard'. Choose 'daily', 'weekly', 'monthly', or 'yearly'.

## `searchQuery` (type: `string`):

Used when mode='search'. Filters products returned by Product Hunt's current official API window against name, tagline, description, and topics (for example 'AI writing tools').

## `topic` (type: `string`):

Used when mode='topic'. The ProductHunt topic URL slug (e.g. 'artificial-intelligence', 'developer-tools', 'productivity').

## `startUrls` (type: `array`):

Used when mode='urls'. Accepts specific Product Hunt post/product-launch URLs and dated leaderboard URLs (for example /leaderboard/monthly/2026/7). Each URL is resolved through the official Product Hunt API, not by scraping Product Hunt pages.

## `maxResults` (type: `integer`):

Maximum number of products to return. Default is 100.

## `excludeProductHuntUrls` (type: `array`):

Optional resumable-run list. Products whose Product Hunt post or product-launch URL appears here are skipped before website or email enrichment and do not consume maxResults. Use URLs from an earlier dataset when a large week, month, or year reaches its result limit.

## `productHuntResumeCursor` (type: `string`):

Optional opaque cursor from RUN\_SUMMARY.nextProductHuntCursor. Use it with the same mode, filters, date range, and exclusions to continue directly after a capped page without re-indexing all prior Product Hunt pages.

## `includeAllProducts` (type: `boolean`):

Enabled by default so date ranges and leaderboard URLs include featured and non-featured Product Hunt posts up to maxResults. Disable to request featured posts only.

## `maxConcurrency` (type: `integer`):

Maximum concurrent product-enrichment jobs. Default is 3 to keep browser and website traffic bounded.

## `enrichEmails` (type: `boolean`):

When enabled (the default), enriches each verified product website. It visits the homepage and up to four same-site contact, about, team, privacy, or terms pages linked from that homepage, then checks up to two public maker homepages and can use the managed contact finder if deliverable-email slots remain.

## `resolveWebsites` (type: `boolean`):

Recommended and enabled by default. Resolves Product Hunt redirect-only links through redirect metadata, official maker sites and their product links, bounded domain hypotheses, then owner-managed search providers. Every candidate must pass product-identity and ownership checks before it is accepted.

## `maxWebsitePages` (type: `integer`):

Bounded public-site crawl limit. Default and maximum are 5 total pages: homepage plus up to four directly linked allowed pages.

## `maxEmailsPerProduct` (type: `integer`):

Returns and bills for up to this many ranked public email addresses associated with the product or its listed makers. Default and maximum are 3.

## `verifyEmails` (type: `boolean`):

Enabled by default. Verifies every selected public email with the Actor's managed EmailListVerify integration. Each result includes the exact provider status; invalid, disposable, and spam-trap results are never presented as verified emails.

## `findContacts` (type: `boolean`):

Enabled by default. After product-site and maker-homepage public discovery, use the managed EmailListVerify Contact Finder with a Product Hunt maker name first, then a domain-only fallback only if deliverable-email slots remain. Provider calls and credit ceilings remain bounded per product.

## `websiteUrlOverrides` (type: `array`):

Optional approved mapping for a Product Hunt product. Each item accepts productHuntUrl, productSlug, productName, or productId plus websiteUrl. A valid override takes priority over managed automatic website resolution.

## `startDate` (type: `string`):

For leaderboard daily mode: query a specific date. Leave blank for today. Use with endDate to scrape a date range in one run (e.g. startDate=2026-03-01, endDate=2026-03-07 → full week).

## `endDate` (type: `string`):

Optional end date for multi-day scraping in one run. Only used in daily leaderboard mode. Example: startDate=2026-03-01, endDate=2026-03-07 returns all products launched across that 7-day window.

## `lookbackDays` (type: `integer`):

Alternative to startDate: scrape the last N days from today. E.g. lookbackDays=7 pulls the last week. Ignored when startDate is provided.

## `outputMode` (type: `string`):

Controls what gets returned. 'full' = all fields (default). 'lean' = minimal fields optimized for LLM/AI agent context windows (name, tagline, website, upvotes, rank, emails, topics). 'leads' = full fields but only products where at least 1 email was found — perfect for outreach lists.

## Actor input object example

```json
{
  "mode": "leaderboard",
  "leaderboardPeriod": "daily",
  "startUrls": [
    {
      "url": "https://www.producthunt.com/leaderboard/monthly/2026/7"
    }
  ],
  "maxResults": 100,
  "includeAllProducts": true,
  "maxConcurrency": 3,
  "enrichEmails": true,
  "resolveWebsites": true,
  "maxWebsitePages": 5,
  "maxEmailsPerProduct": 3,
  "verifyEmails": true,
  "findContacts": true,
  "lookbackDays": 1,
  "outputMode": "full"
}
```

# Actor output Schema

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

All Product Hunt lead records. Each item contains product metadata, website URL/source/confidence, company domain, emails, verified\_emails, risky\_emails, exact verification records, crawl coverage, contact-finder usage, lead status/score/tier, makers, topics, and rankings.

## `output` (type: `string`):

Machine-readable outcome, item counts, named charge counts, and run warnings.

## `runSummary` (type: `string`):

Detailed run diagnostics covering website resolution, email verification, maker fallback, contact discovery, lead tiers, and charges.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.producthunt.com/leaderboard/monthly/2026/7"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/producthunt-scraper-pro").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 = { "startUrls": [{ "url": "https://www.producthunt.com/leaderboard/monthly/2026/7" }] }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/producthunt-scraper-pro").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 '{
  "startUrls": [
    {
      "url": "https://www.producthunt.com/leaderboard/monthly/2026/7"
    }
  ]
}' |
apify call khadinakbar/producthunt-scraper-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/producthunt-scraper-pro"
        }
    }
}

```

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/DTljt4BJQ9K6xJp14/builds/O72NTZjr8Wg2ZO9CZ/openapi.json