# Product Launch Tracker (`datapilot/product-launch-tracker`) Actor

Product Launch Tracker Scraper collects recently launched products from News using the Algolia API. It extracts product name, launch date, category, description, website, upvotes, comments, and thumbnail. Outputs structured JSON for startup discovery, trend tracking, and research.

- **URL**: https://apify.com/datapilot/product-launch-tracker.md
- **Developed by:** [Data Pilot](https://apify.com/datapilot) (community)
- **Categories:** AI, News
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$8.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 Launch Tracker

### Overview

The **Product Launch Tracker** is an Apify Actor that tracks and extracts product launch data from [Hacker News](https://news.ycombinator.com) using the Algolia HN API. Provide a search query and the actor returns structured product launch records including product name, launch date, category, description, upvotes, comments, and thumbnail. Whether you're monitoring competitor product launches, conducting market research, or building a product launch database, this actor delivers accurate product launch data efficiently.

With proxy support and smart category inference, the Product Launch Tracker automatically classifies each product launch into relevant categories like AI, SaaS, DevTools, Finance, and more.

---

### Features

- **Product Launch Search** – Searches Hacker News stories for product launches matching your query.
- **Auto Category Detection** – Automatically infers product launch category (AI, SaaS, DevTools, Productivity, Finance, Health, Design, Mobile, Web, etc.) from title and description.
- **Thumbnail Generation** – Generates favicon thumbnails for each product launch website via Google's favicon service.
- **Pagination Support** – Automatically paginates through all available results to meet your `max_results` target.
- **Proxy Support** – Optionally uses Apify residential proxies to avoid IP blocking.
- **Rate-Limit Friendly** – Adds a small delay between API requests to respect Hacker News rate limits.
- **Error Handling** – Logs errors and continues processing remaining product launch data.
- **Dataset Integration** – Automatically pushes all product launch records to your Apify dataset for easy export.

---

### How It Works

1. **Input** – Provide a search query and maximum number of results.
2. **API Search** – The actor queries the Hacker News Algolia API (`search_by_date`) for stories matching the query.
3. **Category Inference** – Each product launch is automatically classified based on keywords in the title and description.
4. **Thumbnail** – A favicon thumbnail URL is generated from the product launch website domain.
5. **Build Output** – Structures all data into a clean record and pushes it to the dataset.
6. **Repeat** – Paginates through results until `max_results` is reached.

---

### Input

| Field                | Type    | Default    | Description                                                              |
|----------------------|---------|------------|--------------------------------------------------------------------------|
| `query`              | String  | `"launch"` | Search keyword for product launch discovery (e.g., `"AI tool launch"`). |
| `max_results`        | Integer | `20`       | Maximum number of product launch records to return.                      |
| `proxyConfiguration` | Object  | `{}`       | Apify proxy configuration (e.g., `{ "proxyGroups": ["RESIDENTIAL"] }`). |

**Example input:**

```json
{
  "query": "product launch",
  "max_results": 50,
  "proxyConfiguration": {
    "proxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
````

***

### Output

Each product launch is pushed as a separate dataset record with the following fields:

| Field          | Type    | Description                                                            |
|----------------|---------|------------------------------------------------------------------------|
| `product_name` | string  | Name/title of the product launch.                                      |
| `company`      | string  | Company name (empty by default — not available via HN API).            |
| `launch_date`  | string  | Product launch date (`YYYY-MM-DD`).                                    |
| `category`     | string  | Inferred product launch category (e.g., `"AI"`, `"SaaS"`, `"DevTools"`). |
| `description`  | string  | Product launch description or story text.                              |
| `website`      | string  | Product launch website URL.                                            |
| `source`       | string  | Data source (always `"Hacker News"`).                                  |
| `upvotes`      | integer | Number of upvotes on the product launch story.                         |
| `comments`     | integer | Number of comments on the product launch story.                        |
| `ph_url`       | string  | Direct link to the Hacker News product launch story.                   |
| `thumbnail`    | string  | Favicon thumbnail URL generated from the product launch website.       |

**Example output:**

```json
{
  "product_name": "Launch HN: Buildspace – Build and launch your own AI product",
  "company": "",
  "launch_date": "2024-03-15",
  "category": "AI",
  "description": "We built a platform to help developers ship AI products faster...",
  "website": "https://buildspace.so",
  "source": "Hacker News",
  "upvotes": 320,
  "comments": 87,
  "ph_url": "https://news.ycombinator.com/item?id=39876543",
  "thumbnail": "https://www.google.com/s2/favicons?domain=buildspace.so&sz=128"
}
```

***

### Inferred Product Launch Categories

The actor automatically classifies each product launch into one of the following categories based on keywords:

| Category     | Keywords Used                                          |
|--------------|--------------------------------------------------------|
| AI           | ai, llm, gpt, machine learning, chatbot, assistant     |
| SaaS         | saas, subscription, platform                           |
| DevTools     | devtool, developer, api, cli, sdk, open source         |
| Productivity | productivity, calendar, notes, todo, workflow          |
| Finance      | fintech, bank, payments, invoice, accounting           |
| Health       | health, medical, doctor, patient, fitness              |
| Design       | design, figma, ui, ux, prototype                       |
| Mobile       | ios, android, app                                      |
| Web          | website, web app, browser                              |
| Tech         | tech, software, platform                               |
| Other        | *(fallback if no keywords match)*                      |

***

### Use Cases

- **Product Launch Monitoring** – Track new product launches in your industry in real time.
- **Competitor Intelligence** – Monitor competitor product launches and feature announcements.
- **Market Research** – Analyze product launch trends across categories like AI, SaaS, and DevTools.
- **Investment Research** – Discover early-stage product launches gaining traction on Hacker News.
- **Content Aggregation** – Aggregate product launch stories for newsletters, blogs, or reports.
- **Data Science** – Build product launch datasets for trend analysis and machine learning.

***

### Quick Start

1. **Open on Apify** – Visit the actor page and click **Try for free**.
2. **Set Input** – Enter your search keyword in the `query` field (e.g., `"AI launch"`, `"SaaS"`).
3. **Set Limit** – Adjust `max_results` to control how many product launch records to fetch.
4. **Enable Proxy (Optional)** – Configure proxy groups if needed.
5. **Run the Actor** – Start the run and monitor progress in the logs.
6. **Download Results** – Export the product launch dataset as JSON, CSV, or Excel.

***

### Technical Stack

- **Data Source** – [Hacker News Algolia API](https://hn.algolia.com/api) (free, public)
- **HTTP Client** – `requests` with SSL verification via `certifi`
- **Category Inference** – Keyword-based rule engine
- **Thumbnail** – Google Favicon API
- **Proxy** – Apify Proxy (residential or datacenter)
- **Platform** – Apify Actor — serverless, scalable, integrated with Dataset and Key-Value Store

***

### Related Tools

| Actor | Description |
|-------|-------------|
| [Amazon Book Scraper](https://apify.com/store) | Scrapes book listings, prices, ratings, and metadata from Amazon book pages. |
| [Goodreads Scraper](https://apify.com/store) | Extracts book ratings, reviews, and metadata from Goodreads. |
| [Book Metadata Scraper](https://apify.com/store) | Extracts rich book metadata from the Open Library database. |
| [SEC EDGAR Scraper](https://apify.com/store) | Retrieves company filings (10-K, 10-Q, 8-K) from SEC EDGAR. |
| [SEC Filings Scraper](https://apify.com/store) | Extracts SEC filings data for public companies by ticker symbol. |
| [Ultimate Video Info Fetcher](https://apify.com/store) | Extracts rich video metadata from any yt-dlp supported URL. |
| [Amazon Product Scraper](https://apify.com/store) | Downloads and extracts media content from Amazon product URLs. |

***

### Changelog

**v1.0.0 – Initial Release**

- Product launch search via Hacker News Algolia API
- Auto category inference from title and description
- Favicon thumbnail generation per product launch
- Pagination support for large result sets
- Proxy configuration support
- Rate-limit friendly delays
- Dataset integration with error handling

***

### Pricing

- **Free** for basic usage on Apify (up to certain compute limits).
- **Paid plans** available for higher volume, priority support, and longer runs.
- Proxy credits consumed if residential proxies are enabled.

***

### Support & Feedback

- **Issues & Ideas** – Open a ticket on the Apify Actor issue tracker.
- **Documentation** – Visit [Apify Docs](https://docs.apify.com) for platform guides.
- **API Notes** – This actor uses the public Hacker News Algolia API. Please use responsibly and avoid excessive request rates.

***

> **Disclaimer:** This actor accesses publicly available data from the Hacker News API. Please ensure your usage complies with Hacker News and Algolia's terms of service. This actor is intended for research and informational purposes only.

# Actor input Schema

## `query` (type: `string`):

Keyword to search on Hacker News (e.g., launch, show hn).

## `max_results` (type: `integer`):

Number of products to fetch.

## `proxyConfiguration` (type: `object`):

Proxy settings for requests.

## Actor input object example

```json
{
  "query": "launch",
  "max_results": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "query": "launch",
    "max_results": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("datapilot/product-launch-tracker").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 = {
    "query": "launch",
    "max_results": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("datapilot/product-launch-tracker").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 '{
  "query": "launch",
  "max_results": 20
}' |
apify call datapilot/product-launch-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Product Launch Tracker",
        "description": "Product Launch Tracker Scraper collects recently launched products from News using the Algolia API. It extracts product name, launch date, category, description, website, upvotes, comments, and thumbnail. Outputs structured JSON for startup discovery, trend tracking, and research.",
        "version": "0.0",
        "x-build-id": "FsUddBGqXC5nyDuin"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datapilot~product-launch-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datapilot-product-launch-tracker",
                "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/datapilot~product-launch-tracker/runs": {
            "post": {
                "operationId": "runs-sync-datapilot-product-launch-tracker",
                "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/datapilot~product-launch-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-datapilot-product-launch-tracker",
                "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",
                "required": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to search on Hacker News (e.g., launch, show hn).",
                        "default": "launch"
                    },
                    "max_results": {
                        "title": "Max Results",
                        "type": "integer",
                        "description": "Number of products to fetch.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for requests.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
