# Product Hunt CRM Lead Scorer (`rotvuvo/product-hunt-crm-lead-scorer`) Actor

Normalize mixed Product Hunt launch rows into deduped, scored, CRM-ready startup leads.

- **URL**: https://apify.com/rotvuvo/product-hunt-crm-lead-scorer.md
- **Developed by:** [Wit Nomad](https://apify.com/rotvuvo) (community)
- **Categories:** Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 CRM Lead Scorer

Turn messy Product Hunt launch rows into clean, deduplicated, scored startup leads that are ready for a CRM, spreadsheet, sales workflow, agency prospecting list, or VC/market research pipeline.

This Actor is not a Product Hunt page scraper. It is the cleanup and qualification layer after scraping or manual collection: one row per identifiable company, stable dedupe keys when rows include a Product Hunt URL, domain, slug, or product name, normalized contact/social evidence, transparent lead scoring, and flat export-friendly fields.

### What it does

- Accepts Product Hunt-like launch rows in `items` mode.
- Normalizes common field variants such as `name`, `title`, `product.name`, `website`, `websiteUrl`, `votes`, `votesCount`, and `makers`.
- Deduplicates by canonical Product Hunt post slug first, then by normalized domain and product slug.
- Produces flat CRM-ready output fields.
- Adds deterministic `leadScore`, `scoreReasons`, `icpFit`, `warnings`, and an `outreachHook`.
- Keeps scoring transparent so you can audit why a lead was ranked high or low.

### Who it is for

Use this Actor if you already have Product Hunt data from:

- another Apify Product Hunt scraper,
- a CSV/JSON export,
- manual research,
- an internal research workflow,
- or a no-code automation that collects launch rows.

Typical use cases:

- sales teams ranking newly launched SaaS/startup leads,
- agencies finding recently launched companies to contact,
- VCs and scouts triaging Product Hunt launches,
- growth teams preparing spreadsheet or CRM imports,
- builders cleaning output from raw scrapers before enrichment.

### Input

Current supported input mode: `items`.

```json
{
  "mode": "items",
  "maxItems": 500,
  "items": [
    {
      "name": "LaunchDeck",
      "productHuntUrl": "https://www.producthunt.com/posts/launchdeck",
      "websiteUrl": "https://launchdeck.io",
      "tagline": "AI follow-up engine for lean sales teams",
      "topics": ["Sales", "Artificial Intelligence", "CRM"],
      "upvotes": 420,
      "commentsCount": 37,
      "makerNames": ["Ada Lee", "Sam Ho"],
      "publicEmail": "hello@launchdeck.io",
      "emailSourceUrl": "https://launchdeck.io/contact"
    }
  ]
}
````

`items` must be an array of Product Hunt-like objects. The Actor is intentionally tolerant of common field names, so exact source shape can vary.

### Output

Each output item is one normalized lead:

```json
{
  "dedupeKey": "ph:launchdeck",
  "productName": "LaunchDeck",
  "productHuntUrl": "https://www.producthunt.com/posts/launchdeck",
  "productSlug": "launchdeck",
  "tagline": "AI follow-up engine for lean sales teams",
  "topics": ["Sales", "Artificial Intelligence", "CRM"],
  "upvotes": 420,
  "commentsCount": 37,
  "websiteUrl": "https://launchdeck.io/",
  "domain": "launchdeck.io",
  "makerNames": ["Ada Lee", "Sam Ho"],
  "publicEmail": "hello@launchdeck.io",
  "emailConfidence": "high",
  "leadScore": 90,
  "scoreReasons": ["domain:+20", "direct_email:+20", "maker:+10", "traction:+20", "icp_match:+20"],
  "icpFit": "high",
  "outreachHook": "LaunchDeck: AI follow-up engine for lean sales teams stood out with 420 Product Hunt upvotes.",
  "warnings": [],
  "evidenceUrls": [
    "https://www.producthunt.com/posts/launchdeck",
    "https://launchdeck.io/",
    "https://launchdeck.io/contact"
  ]
}
```

### Output fields

- `dedupeKey`
- `productName`
- `productHuntUrl`
- `productSlug`
- `launchDate`
- `tagline`
- `description`
- `topics`
- `upvotes`
- `commentsCount`
- `websiteUrl`
- `domain`
- `makerNames`
- `makerPhUrls`
- `xUrl`
- `linkedinCompanyUrl`
- `githubUrl`
- `discordUrl`
- `contactPageUrl`
- `publicEmail`
- `emailSourceUrl`
- `emailConfidence`
- `leadScore`
- `scoreReasons`
- `icpFit`
- `outreachHook`
- `warnings`
- `evidenceUrls`
- `scrapedAt`

### Scoring

Scoring is deterministic and explainable:

- `domain:+20`
- `direct_email:+20` or `contact_page:+12`
- `social:+10`
- `maker:+10`
- traction from upvotes/comments up to `+20`
- ICP keyword/category match up to `+20`
- penalties for missing domain/contact/maker signals

The score is clamped to `0..100`. Use `scoreReasons` and `warnings` to audit the result before importing leads into outreach tools.

### Local development

From this Actor folder:

```bash
npm test
node src/main.js \
  --input ../../samples/product-hunt/product-hunt-crm-lead-scorer-input.json \
  --output ../../samples/product-hunt/product-hunt-crm-lead-scorer-output.json \
  --scraped-at 2026-07-05T00:00:00.000Z
```

### Limitations

- This Actor does not scrape Product Hunt pages directly. Bring Product Hunt-like rows from another scraper/export/workflow.
- URL mode is not exposed yet; unsupported modes are rejected instead of silently returning empty output.
- Public or enriched emails are not guaranteed verified. Always review email evidence before outreach.
- The scoring model is deterministic and lightweight, not a machine-learning model.
- No external website enrichment is performed in this version.

### Cost and permissions

- The Actor reads the provided Actor input and writes normalized rows to the default dataset; it does not request account-wide data access.
- It performs no browser crawling and no external HTTP scraping in the current version.
- Runtime is expected to be lightweight because it processes provided rows only.

### Best results

For best results, include as many of these fields as possible in each input row:

- Product Hunt URL or slug
- product name
- website URL
- tagline or description
- topics/categories
- upvotes and comments count
- maker names or maker profile URLs
- public email or contact page URL
- social/profile URLs

# Actor input Schema

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

Input mode. This version supports pasted Product Hunt-like items.

## `items` (type: `array`):

Rows from Product Hunt scrapers, JSON/CSV exports, or manually collected Product Hunt-like launch data.

## `maxItems` (type: `integer`):

Maximum input rows to process.

## Actor input object example

```json
{
  "mode": "items",
  "maxItems": 500
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("rotvuvo/product-hunt-crm-lead-scorer").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("rotvuvo/product-hunt-crm-lead-scorer").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 '{}' |
apify call rotvuvo/product-hunt-crm-lead-scorer --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Product Hunt CRM Lead Scorer",
        "description": "Normalize mixed Product Hunt launch rows into deduped, scored, CRM-ready startup leads.",
        "version": "0.2",
        "x-build-id": "SqTflgnvq7bsrt8RY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rotvuvo~product-hunt-crm-lead-scorer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rotvuvo-product-hunt-crm-lead-scorer",
                "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/rotvuvo~product-hunt-crm-lead-scorer/runs": {
            "post": {
                "operationId": "runs-sync-rotvuvo-product-hunt-crm-lead-scorer",
                "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/rotvuvo~product-hunt-crm-lead-scorer/run-sync": {
            "post": {
                "operationId": "run-sync-rotvuvo-product-hunt-crm-lead-scorer",
                "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": [
                    "mode",
                    "items"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "items"
                        ],
                        "type": "string",
                        "description": "Input mode. This version supports pasted Product Hunt-like items.",
                        "default": "items"
                    },
                    "items": {
                        "title": "Product Hunt rows",
                        "type": "array",
                        "description": "Rows from Product Hunt scrapers, JSON/CSV exports, or manually collected Product Hunt-like launch data.",
                        "items": {
                            "type": "object"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum rows",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum input rows to process.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
