# Product Hunt Scraper (Cheap) (`data_api/product-hunt-scraper-cheap`) Actor

Product Hunt Scraper that collects product names, ratings, and launch data from producthunt.com, so you can track startups and research competitors without manual work.

- **URL**: https://apify.com/data\_api/product-hunt-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Launch Scraper

![Product Hunt Launch Scraper](cover.jpg)

Tracking what launches on Product Hunt by hand is slow going. You scroll a topic, copy a name, hunt for the rating, check the upvotes, then start over on the next product. This scraper does it in one run. Hand it a topic slug or a product link and it returns every product as a clean row: the title, the tagline, the rating, the follower count, and the latest launch with its upvotes and date. Feed it one URL or a whole list of topics and pull the data straight into a sheet.

### What you get

One row per product, with a steady shape so your columns line up when you load the results. Three kinds of data come back for each launch:

- **Product basics** — `productTitle`, `shortPitch`, `aboutText`, `makerWebsite`, `productHuntUrl`, `logoImage`
- **Traction signals** — `ratingScore`, `ratingsTotal`, `followerTotal`, `launchTotal`, `featuredFlag`, `topicNames`, `labelTags`
- **Latest launch** — `recentLaunchSlug`, `recentLaunchDate`, `recentLaunchVotes`, `recentLaunchComments`

Each row also carries the `inputUrl` it came from and a `collectedAt` timestamp.

### Quick start

1. Click **Try for free** and open the input form.
2. Paste Product Hunt links into **Launch URLs**, or list topic handles under **Topic slugs** — you can do both.
3. Set a **Results limit** to cap how many products come back per input.
4. Press **Start**, then download the results as JSON, CSV, Excel, or XML once the run finishes.

![How it works](how-it-works.jpg)

### Use cases

- **Founders and indie makers** — watch what ships in your category and study how rival launches are doing
- **Investors and scouts** — surface early traction signals across a topic before a product hits the mainstream
- **Marketers** — find products with momentum to pitch partnerships, integrations, or coverage
- **Trend research** — track which topics are heating up and which launches pull the most upvotes
- **Sales teams** — build lead lists of new tools and the websites behind them
- **Content and newsletters** — assemble a weekly roundup of fresh launches without manual browsing

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `launchUrls` | array of strings | One of `launchUrls` or `topicSlugs` | Product Hunt links to scrape. Mix topic pages, product pages, and launch posts freely. |
| `topicSlugs` | array of strings | One of `launchUrls` or `topicSlugs` | Topic handles to crawl, taken from the topic page address, such as `design-tools` or `fintech`. |
| `resultsLimit` | integer | No | Cap on products returned per input. Topic pages page through automatically. Default `50`. |
| `timeoutSeconds` | integer | No | Seconds to wait on each request before it times out. Default `45`. |

#### Example input

```json
{
    "launchUrls": [
        "https://www.producthunt.com/topics/developer-tools",
        "https://www.producthunt.com/posts/notion-calendar"
    ],
    "topicSlugs": [
        "design-tools",
        "no-code",
        "fintech"
    ],
    "resultsLimit": 50,
    "timeoutSeconds": 45
}
````

### Output

Each product becomes one row. Topic links expand into many rows, while a single product or post link returns one. Empty values are dropped from the record rather than padded, so check for a key before you read it.

#### Example output

```json
{
    "launchId": "123456",
    "productTitle": "Notion Calendar",
    "shortPitch": "Time and your work, together at last",
    "aboutText": "A calendar built for the way modern teams plan their days, with Notion docs linked right into each event.",
    "makerWebsite": "https://www.notion.so/product/calendar",
    "productHuntUrl": "https://www.producthunt.com/products/notion-calendar",
    "logoImage": "https://ph-files.imgix.net/abc-123.png?auto=format",
    "ratingScore": 4.7,
    "ratingsTotal": 218,
    "followerTotal": 5430,
    "launchTotal": 6,
    "topicNames": ["Productivity", "Calendar", "SaaS"],
    "labelTags": ["productivity", "calendar"],
    "featuredFlag": true,
    "recentLaunchSlug": "notion-calendar",
    "recentLaunchDate": "2026-05-14",
    "recentLaunchVotes": 1842,
    "recentLaunchComments": 96,
    "inputUrl": "https://www.producthunt.com/topics/developer-tools",
    "collectedAt": "2026-06-29T12:00:00.000000+00:00"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `launchId` | string | Product Hunt identifier for the product |
| `productTitle` | string | Name the product goes by on Product Hunt |
| `shortPitch` | string | One-line tagline for the product |
| `aboutText` | string | Longer write-up shown on product and launch pages |
| `makerWebsite` | string | The product's own website outside Product Hunt |
| `productHuntUrl` | string | Link to the product page on Product Hunt |
| `logoImage` | string | Direct link to the product logo image |
| `ratingScore` | number | Mean review score from 0 to 5 |
| `ratingsTotal` | integer | How many reviews the product has gathered |
| `followerTotal` | integer | Count of people following the product |
| `launchTotal` | integer | How many times the product has launched |
| `topicNames` | array | Topics the product is filed under |
| `labelTags` | array | Tag strings attached to the product |
| `featuredFlag` | boolean | True when marked as a top product |
| `recentLaunchSlug` | string | URL slug of the newest launch post |
| `recentLaunchDate` | string | ISO date the newest launch went live |
| `recentLaunchVotes` | integer | Upvote tally on the newest launch |
| `recentLaunchComments` | integer | Comment count on the newest launch |
| `inputUrl` | string | The input link that produced this row |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |

### Tips for best results

- **Start with one topic.** Run a single slug first to confirm the fields fit your pipeline, then add the rest.
- **Use `resultsLimit` to stay cheap.** Topic pages paginate on their own, so a low limit keeps a quick test from crawling deep.
- **Mix inputs in one run.** Topic slugs and direct product links work together, so you can scan a category and pull specific products in the same job.
- **Topic and product links return different depth.** Product and post pages include the full `aboutText`; topic listings give the core fields for many products at once.
- **Raise `timeoutSeconds`** if you see requests time out on slower runs.

### How can I use Product Hunt launch data?

**How can I use the Product Hunt Launch Scraper to track new products in my category?**
List the topic slugs that match your niche under **Topic slugs** and set a results limit. Each run returns the products in that topic with their ratings, follower counts, and latest launch stats, so you can watch what ships week to week without scrolling the site by hand.

**How can I scrape Product Hunt upvotes and launch dates for trend research?**
Every row carries `recentLaunchVotes`, `recentLaunchDate`, and `recentLaunchComments` from the product's newest launch. Pull a batch of topics, sort by upvotes, and you have a ready dataset for spotting which launches and categories are gaining traction.

**How can I export Product Hunt product data to a spreadsheet?**
Run the scraper, then download the dataset as CSV or Excel straight from the run. You get a flat table of product names, taglines, websites, ratings, and launch numbers, ready to drop into a CRM, a lead list, or a research sheet.

**How do I pull data from a single Product Hunt launch?**
Paste the product or post URL into **Launch URLs**. The scraper returns one row with the full description, website, rating, and the latest launch details for that product.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `launchUrls` (type: `array`):

Product Hunt links to pull data from. You can mix topic pages, product pages, and individual launch posts in the same list.

## `topicSlugs` (type: `array`):

Topic handles to crawl, one per line. Use the slug from the topic page address, for example design-tools, no-code, or fintech.

## `resultsLimit` (type: `integer`):

Cap on how many products to return for each input. With 2 topics and a limit of 25 you get up to 50 rows total. Topic pages hold 15 products each, and the scraper pages through them for you.

## `timeoutSeconds` (type: `integer`):

How long to wait on a single request before giving up.

## Actor input object example

```json
{
  "launchUrls": [
    "https://www.producthunt.com/topics/developer-tools",
    "https://www.producthunt.com/posts/notion-calendar"
  ],
  "topicSlugs": [
    "design-tools",
    "no-code",
    "fintech"
  ],
  "resultsLimit": 15,
  "timeoutSeconds": 45
}
```

# 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 = {
    "launchUrls": [
        "https://www.producthunt.com/topics/developer-tools"
    ],
    "topicSlugs": [
        "saas"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/product-hunt-scraper-cheap").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 = {
    "launchUrls": ["https://www.producthunt.com/topics/developer-tools"],
    "topicSlugs": ["saas"],
}

# Run the Actor and wait for it to finish
run = client.actor("data_api/product-hunt-scraper-cheap").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "launchUrls": [
    "https://www.producthunt.com/topics/developer-tools"
  ],
  "topicSlugs": [
    "saas"
  ]
}' |
apify call data_api/product-hunt-scraper-cheap --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=data_api/product-hunt-scraper-cheap",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Product Hunt Scraper (Cheap)",
        "description": "Product Hunt Scraper that collects product names, ratings, and launch data from producthunt.com, so you can track startups and research competitors without manual work.",
        "version": "0.0",
        "x-build-id": "IbEpdDHLoLcVlBbC1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~product-hunt-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-product-hunt-scraper-cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/data_api~product-hunt-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-product-hunt-scraper-cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/data_api~product-hunt-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-product-hunt-scraper-cheap",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "launchUrls": {
                        "title": "Launch URLs",
                        "type": "array",
                        "description": "Product Hunt links to pull data from. You can mix topic pages, product pages, and individual launch posts in the same list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "topicSlugs": {
                        "title": "Topic slugs",
                        "type": "array",
                        "description": "Topic handles to crawl, one per line. Use the slug from the topic page address, for example design-tools, no-code, or fintech.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsLimit": {
                        "title": "Results limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on how many products to return for each input. With 2 topics and a limit of 25 you get up to 50 rows total. Topic pages hold 15 products each, and the scraper pages through them for you.",
                        "default": 15
                    },
                    "timeoutSeconds": {
                        "title": "Timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How long to wait on a single request before giving up.",
                        "default": 45
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
