# StartupFast Scraper - Startup and Product Directory (`benthepythondev/startupfast-startups-scraper`) Actor

Scrape StartupFast projects by category and export startup name, website, tagline, logo, categories, upvotes, comments, source rank and listing URL.

- **URL**: https://apify.com/benthepythondev/startupfast-startups-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Business, Marketing, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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/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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## StartupFast Scraper - Startup and Product Directory

Scrape public startup and product listings from StartupFast by category. The Actor exports each project's name, own website, tagline, logo, category labels, upvotes, comment count, source rank, and StartupFast listing URL. It is designed for market research, startup discovery, prospecting, launch monitoring, and category-level competitor analysis without requiring an account or API key.

### Why use this Actor?

Startup directories are useful because founders describe their products in compact, comparable language and link directly to the product website. That makes the data relevant for researchers, accelerators, agencies, investors, partnership teams, SEO analysts, and B2B sales workflows. Copying directory cards manually is slow, and category overlap creates duplicate records. This Actor paginates the public directory and merges the same project across multiple requested categories into one structured row.

Typical uses include:

- discovering newly launched AI, SaaS, developer, ecommerce, or marketing products;
- building a prospect list with direct startup websites;
- monitoring category entrants over time;
- comparing taglines and positioning in a niche;
- finding products with visible community engagement;
- enriching startup databases and CRM records;
- identifying potential partnerships, integrations, or acquisition targets;
- creating category dashboards for an accelerator or research team.

### Input

Enter one or more StartupFast category slugs and choose a sort order. Category slugs are the values visible in StartupFast category URLs, such as `ai`, `saas`, `marketing-tools`, `developer-tools`, `ecommerce`, `finance-tech`, `productivity`, and `open-source`.

```json
{
  "categorySlugs": ["ai", "saas"],
  "sort": "recent",
  "maxResultsPerCategory": 20,
  "maxPagesPerCategory": 5
}
````

#### Input fields

| Field | Description |
|---|---|
| `categorySlugs` | One or more public StartupFast category slugs. |
| `sort` | `recent`, `upvotes`, or `alphabetical`. |
| `maxResultsPerCategory` | Maximum source projects processed for each category. |
| `maxPagesPerCategory` | Hard pagination limit; currently 10 cards are returned per page. |

The default input is deliberately small and current, which keeps scheduled Tasks and Apify's daily automated test fast. The Actor accepts up to 25 categories and enforces a maximum page count so an accidental large input cannot create an unbounded run.

### Output fields

Each default-dataset item represents one unique StartupFast project. The output includes:

- `id` and `slug` from the public listing URL;
- `name` without the visual ranking prefix;
- `tagline` shown on the category card;
- `project_url` on StartupFast;
- the product's external `website_url`;
- `logo_url`;
- human-readable `categories` and source `category_slugs`;
- public `upvotes` and `comments` counts;
- `source_rank` within the source page;
- `matched_categories` and `category_ranks` when a project appears in more than one requested category;
- final unique-result `rank`, source URL, and scrape timestamp.

Example result:

```json
{
  "id": "tunestems",
  "name": "TuneStems",
  "tagline": "AI stem splitter for clean practice tracks, lessons, remix planning, and browser-based audio separation.",
  "project_url": "https://www.startupfa.st/projects/tunestems",
  "website_url": "https://tunestems.com/",
  "categories": ["Artificial Intelligence", "Machine Learning", "SaaS"],
  "upvotes": 0,
  "comments": 0,
  "matched_categories": ["ai"]
}
```

### Cross-category deduplication

A startup may be listed under several categories. The Actor uses the public project slug as its stable key. When the same project appears again, it does not create another billed dataset item. Instead, the Actor appends the source category to `matched_categories` and records the category-specific position in `category_ranks`. This makes multi-category runs useful for lead qualification: a product found under both `ai` and `saas` remains one lead with both signals attached.

### Lead generation workflow

The direct website is the most valuable field for prospecting. A practical workflow is:

1. scrape recent projects from commercially relevant categories;
2. filter out products already in your CRM;
3. pass `website_url` values to a website contact or company-enrichment Actor;
4. qualify by category, positioning, launch recency, and engagement;
5. add only relevant prospects to a compliant outreach sequence.

Directory presence is not consent to unsolicited contact. Apply the laws and platform rules that govern your region and channel, respect opt-outs, and keep outreach relevant.

### Scheduling and integrations

Save the input as an Apify Task and schedule it weekly or daily with `sort` set to `recent`. Consume results through the dataset API, a webhook, Google Sheets, Make, Zapier, n8n, or your own code. Retaining past datasets lets you identify newly appearing slugs without rescanning or manually comparing pages.

For a category-positioning study, use `upvotes` sorting and collect the first several pages. For a monitoring workflow, one or two recent pages per category are usually enough and keep the run inexpensive.

### Pricing

This Actor uses pay-per-event pricing: a small run-start event and a result event for each unique project saved to the default dataset. Duplicate projects across selected categories are merged before storage, so they are not billed twice within the same run.

### Reliability and data scope

The Actor reads StartupFast's public server-rendered category cards using Chrome-compatible HTTP requests. It does not open a browser, sign in, bypass private pages, or depend on an external paid API. Requests use retries, short delays, and strict page limits. If StartupFast changes its card markup, open an Actor issue with the run ID and affected category so the parser can be adjusted.

The output reflects public card data at run time. It does not claim that votes are unique users, that directory content is independently verified, or that a project is active. Visit the product website before making commercial or investment decisions.

### FAQ

#### Do I need a StartupFast account?

No. The Actor reads public category pages.

#### Can I scrape more than one category?

Yes. Add multiple slugs. Duplicate projects are merged and preserve every matched category.

#### Which sort modes work?

Recent, upvotes, and alphabetical sorting are supported because they are exposed by the public directory.

#### Does the Actor visit every startup website?

No. It exports the external website URL shown by StartupFast. Avoiding detail-site crawling keeps the Actor fast, predictable, and low cost.

#### Can I get emails from the results?

This Actor does not invent or infer contact details. Use the exported website URLs with a dedicated website-contact workflow where lawful and appropriate.

#### Can I export CSV or Excel?

Yes. Every Apify dataset can be downloaded as JSON, CSV, Excel, XML, RSS, or read through the API.

#### How fresh is the data?

Each run fetches the current public pages. Use a recurring Task to maintain a change history.

#### How do I report a broken category?

Open an issue on the Actor page and include the category slug and run ID. If the Actor saved you time, please leave a Store review; reviews help other users evaluate it and help prioritize maintenance.

### You might also like

- [Startup Directory Scrapers](https://apify.com/store?search=startup%20directory)
- [B2B Lead Generation Actors](https://apify.com/store?search=lead%20generation)
- [Website Contact Extractors](https://apify.com/store?search=website%20contact%20extractor)

**Keywords:** StartupFast scraper, startup directory scraper, startup leads, SaaS directory, product launch scraper, startup website list, AI tools directory, founder lead generation, startup market research, startup API

# Actor input Schema

## `categorySlugs` (type: `array`):

StartupFast category slugs such as ai, saas, marketing-tools, developer-tools, or ecommerce.

## `sort` (type: `string`):

Sort each category by recent launches, upvotes, or name.

## `maxResultsPerCategory` (type: `integer`):

Maximum source projects processed for each category.

## `maxPagesPerCategory` (type: `integer`):

Pagination safety limit. StartupFast currently returns 10 projects per page.

## Actor input object example

```json
{
  "categorySlugs": [
    "ai",
    "saas"
  ],
  "sort": "recent",
  "maxResultsPerCategory": 20,
  "maxPagesPerCategory": 5
}
```

# Actor output Schema

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

No description

# 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 = {
    "categorySlugs": [
        "ai",
        "saas"
    ],
    "sort": "recent",
    "maxResultsPerCategory": 20,
    "maxPagesPerCategory": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/startupfast-startups-scraper").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 = {
    "categorySlugs": [
        "ai",
        "saas",
    ],
    "sort": "recent",
    "maxResultsPerCategory": 20,
    "maxPagesPerCategory": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/startupfast-startups-scraper").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 '{
  "categorySlugs": [
    "ai",
    "saas"
  ],
  "sort": "recent",
  "maxResultsPerCategory": 20,
  "maxPagesPerCategory": 5
}' |
apify call benthepythondev/startupfast-startups-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "StartupFast Scraper - Startup and Product Directory",
        "description": "Scrape StartupFast projects by category and export startup name, website, tagline, logo, categories, upvotes, comments, source rank and listing URL.",
        "version": "1.0",
        "x-build-id": "O0i70w1HPqH1wAw6U"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~startupfast-startups-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-startupfast-startups-scraper",
                "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/benthepythondev~startupfast-startups-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-startupfast-startups-scraper",
                "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/benthepythondev~startupfast-startups-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-startupfast-startups-scraper",
                "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": [
                    "categorySlugs"
                ],
                "properties": {
                    "categorySlugs": {
                        "title": "Startup categories",
                        "type": "array",
                        "description": "StartupFast category slugs such as ai, saas, marketing-tools, developer-tools, or ecommerce.",
                        "default": [
                            "ai"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "recent",
                            "upvotes",
                            "alphabetical"
                        ],
                        "type": "string",
                        "description": "Sort each category by recent launches, upvotes, or name.",
                        "default": "recent"
                    },
                    "maxResultsPerCategory": {
                        "title": "Maximum startups per category",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum source projects processed for each category.",
                        "default": 20
                    },
                    "maxPagesPerCategory": {
                        "title": "Maximum pages per category",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Pagination safety limit. StartupFast currently returns 10 projects per page.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
