# BetaList Startup Directory Scraper (`crawlerbros/betalist-scraper`) Actor

Scrape BetaList - the startup discovery directory. Get the latest launches feed, run full-text search, or browse by category & tag. Extracts name, tagline, logo, launch date, and featured status.

- **URL**: https://apify.com/crawlerbros/betalist-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, News, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

# README

## BetaList Startup Directory Scraper

Scrape [BetaList](https://betalist.com) — the startup discovery directory where founders launch new products to an early-adopter audience. Pull the latest daily launches feed, run full-text search across the entire directory, browse by category & tag, browse by region, browse every startup a specific maker submitted, or pull a curated monthly/yearly/themed collection. Get startup name, tagline, logo, launch date, and featured/boosted status in a clean, ready-to-use dataset — no coding required.

### What this actor does

BetaList lists thousands of early-stage startups across 22 categories and 300+ tags (AI, SaaS, e-commerce, fintech, health, dev tools, and more). This actor gives you six ways to pull that data:

- **Latest launches** — the reverse-chronological homepage feed, grouped by launch day
- **Search** — full-text search across startup name, tagline, and description
- **Browse by category & tag** — pull every startup listed under a specific topic (e.g. `AI > Chatbot`, `Commerce > E-commerce`)
- **Browse by region** — pull every startup located in a continent (e.g. `Europe`) or country (e.g. `France`)
- **Browse by maker** — pull every startup a specific maker submitted, plus that maker's own profile (name, bio, avatar, social link)
- **Browse a curated collection** — pull a monthly/yearly retrospective (e.g. "Startups of 2020") or themed roundup (e.g. "Work From Home")

Every record includes an omit-empty, ready-to-export shape — fields that can't be populated for a given mode are simply left out rather than sent as `null`.

By default (`fetchDetails: true`), the actor also opens each startup's own detail page to pull its **full description**, **product screenshot gallery**, **real external website URL**, **maker profile(s)**, its **complete topic list**, **location(s)**, and a list of **related startups** — data that isn't on the listing pages at all. Turn `fetchDetails` off for a faster, listing-only scrape.

### Output per startup

| Field | Type | Description |
|---|---|---|
| `name` | string | Startup name |
| `tagline` | string | One-line pitch / short description |
| `description` | string | Full-length description from the startup's detail page (`fetchDetails: true`) |
| `screenshots` | array of strings | Product screenshot gallery image URLs from the startup's detail page (`fetchDetails: true`) |
| `slug` | string | BetaList URL slug (e.g. `reventir`) |
| `sourceUrl` | string | Canonical BetaList page for the startup |
| `websiteUrl` | string | The startup's real external website, resolved from BetaList's own redirect link (`fetchDetails: true`) |
| `imageUrl` | string | Logo image URL |
| `isBoosted` | boolean | `true` if BetaList has marked the listing as BOOSTED (paid featured placement) |
| `launchDate` | string | ISO date (`YYYY-MM-DD`) the startup was launched. Always present in **Latest launches** mode; present in every mode when `fetchDetails: true` |
| `makers` | array of objects | Maker(s)/founder(s) who submitted the startup — `username`, `profileUrl`, and `name` when shown (`fetchDetails: true`) |
| `topics` | array of objects | The complete topic list BetaList assigned to the startup — each with `category`, `tag`, `categoryLabel`, `tagLabel` (`fetchDetails: true`) |
| `locations` | array of objects | The region(s)/countries BetaList associates with the startup — each with `region`, `regionLabel` (`fetchDetails: true`) |
| `relatedStartups` | array of objects | BetaList's own "Discover startups similar to X" recommendations from the detail page — each with `slug`, `name`, `tagline`, `sourceUrl`, `imageUrl`, `isBoosted` (`fetchDetails: true`) |
| `category` | string | Category slug of the browsed topic — only present in **Browse by category & tag** mode |
| `categoryLabel` | string | Human-readable category name of the browsed topic |
| `tag` | string | Tag slug of the browsed topic — only present in **Browse by category & tag** mode |
| `tagLabel` | string | Human-readable tag name of the browsed topic |
| `browsedRegion` | string | Region slug that was browsed — only present in **Browse by region** mode |
| `browsedRegionLabel` | string | Human-readable region name that was browsed |
| `browsedCollection` | string | Collection slug that was browsed — only present in **Browse a curated collection** mode |
| `browsedCollectionLabel` | string | Human-readable collection name (e.g. `Startups of 2020`) |
| `browsedMakerUsername` | string | The maker's BetaList handle — only present in **Browse by maker** mode |
| `browsedMakerName` | string | The maker's display name |
| `browsedMakerAvatarUrl` | string | The maker's profile avatar image URL |
| `browsedMakerBio` | string | The maker's profile bio, if they set one |
| `browsedMakerSocialUrl` | string | The maker's linked social profile (e.g. X/Twitter), if shown |
| `browsedMakerStartupCount` | integer | Total number of startups BetaList credits to this maker |
| `recordType` | string | Always `"startup"` |
| `scrapedAt` | string | UTC ISO timestamp of when the record was scraped |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `latest` | `latest`, `search`, `category_tag_browse`, `region_browse`, `maker_browse`, or `collection_browse` |
| `searchQuery` | string | `ai` | Free-text query (mode=`search`) — matched against name, tagline, and description |
| `categoryTag` | select | `ai/artificial-intelligence` | Category > tag combination to browse (mode=`category_tag_browse`) — 734 options covering every topic BetaList supports |
| `region` | select | `north-america` | Continent or country to browse (mode=`region_browse`) |
| `collection` | select | `startups-of-2020` | Curated collection to browse (mode=`collection_browse`) — monthly/yearly retrospectives plus themed roundups |
| `makerUsername` | string | `olucurious` | BetaList maker handle to browse (mode=`maker_browse`), with or without the leading `@` |
| `boostedOnly` | boolean | `false` | Only keep startups marked BOOSTED (featured/paid placement) |
| `fetchDetails` | boolean | `true` | Also fetch each startup's detail page for `description`, `screenshots`, `websiteUrl`, `makers`, `topics`, `locations`, `relatedStartups`, and a reliable `launchDate` in every mode. Costs 2 extra requests per startup — turn off for a faster listing-only scrape |
| `keyword` | string | – | Case-insensitive substring filter applied to `name` + `tagline`, on top of the selected mode's results |
| `launchDateFrom` | string | – | Drop startups launched before this date (`YYYY-MM-DD`). Reliable in every mode with `fetchDetails: true` |
| `launchDateTo` | string | – | Drop startups launched after this date (`YYYY-MM-DD`). Reliable in every mode with `fetchDetails: true` |
| `maxItems` | integer | `50` | Hard cap on the number of records returned (1–2000). Collections and maker profiles are single-page listings on BetaList, so `maker_browse`/`collection_browse` return at most everything on that one page regardless of this cap |
| `proxyConfiguration` | object | Apify proxy (AUTO) | Optional. BetaList serves plain HTML with no bot-detection observed, so a proxy isn't required — this just lets you distribute requests across the free Apify datacenter pool if you wish |

#### Example: latest launches, boosted only

```json
{
  "mode": "latest",
  "maxItems": 50,
  "boostedOnly": true
}
```

#### Example: full-text search

```json
{
  "mode": "search",
  "searchQuery": "developer tools",
  "maxItems": 100
}
```

#### Example: browse a category & tag

```json
{
  "mode": "category_tag_browse",
  "categoryTag": "ai/chatbot",
  "maxItems": 100
}
```

#### Example: browse by region

```json
{
  "mode": "region_browse",
  "region": "france",
  "maxItems": 100
}
```

#### Example: browse by maker

```json
{
  "mode": "maker_browse",
  "makerUsername": "olucurious"
}
```

#### Example: browse a curated collection

```json
{
  "mode": "collection_browse",
  "collection": "startups-of-2020"
}
```

#### Example: launches within a date window

```json
{
  "mode": "latest",
  "launchDateFrom": "2026-07-01",
  "launchDateTo": "2026-07-31",
  "maxItems": 500
}
```

### Use cases

- **Market research** — track what's launching in a given space (AI tools, fintech, dev tools) week over week
- **Investor sourcing** — build a feed of newly launched startups matching your investment thesis
- **Competitive intelligence** — monitor new entrants in your category and tag
- **Newsletter / content curation** — pull the day's launches for a "startups to watch" roundup
- **Lead generation** — find early-stage companies to reach out to as a vendor, agency, or partner
- **Trend analysis** — measure launch volume and category mix over time
- **Regional market mapping** — see what's launching in a specific country or continent
- **Maker/founder research** — pull every product a serial founder has submitted to BetaList
- **Retrospective research** — revisit a specific month/year's launch cohort via curated collections

### FAQ

**What is BetaList?** BetaList is a long-running startup discovery platform where founders submit their product for a public launch to an audience of early adopters, journalists, and investors.

**Why do some records have a `launchDate` and others don't?** The homepage's **Latest launches** feed groups startups by launch day, so `launchDate` is always present there. **Search**, **category/tag browse**, and **region browse** listing pages don't show a launch date directly — but with the default `fetchDetails: true`, the actor reads it from each startup's own detail page, so it's reliably present in every mode. Turning `fetchDetails` off falls back to listing-only data, where `launchDate` is only available in `latest` mode (and, for curated collections that use BetaList's editorial card layout, from the "featured on" caption).

**What are `description`, `screenshots`, `websiteUrl`, `makers`, `topics`, `locations`, and `relatedStartups`?** These come from each startup's individual BetaList page (enabled by default via `fetchDetails`). `description` is the full write-up (vs. the one-line `tagline`); `screenshots` is the product screenshot gallery shown at the top of the page; `websiteUrl` is the startup's real external site, resolved by following BetaList's own outbound redirect link; `makers` lists who submitted it; `topics` is the complete set of category/tag pairs BetaList assigned — often more than the single `category`/`tag` implied by a browse URL; `locations` is the region(s) BetaList associates with the startup; `relatedStartups` is BetaList's own "Discover startups similar to X" recommendations.

**Is `websiteUrl` always reachable?** The URL itself is always correctly resolved from BetaList's own redirect (never fabricated), but it points to each startup's own, independently-hosted website — a small early-stage product occasionally has downtime, rate-limiting, or bot-detection on its own server, same as clicking "Visit Site" on betalist.com directly would encounter. `sourceUrl`, `imageUrl`, and maker `profileUrl` are all first-party BetaList/ImageKit URLs and are consistently reachable.

**What does `isBoosted` mean?** BetaList lets founders pay to "boost" their listing for extra visibility. `isBoosted: true` marks a paid/featured placement; it does not affect the accuracy of the other fields.

**What are the `browsedRegion`/`browsedCollection`/`browsedMaker*` fields?** These stamp the record with the region, collection, or maker you browsed to reach it — they only appear when using the matching mode (`region_browse`, `collection_browse`, or `maker_browse` respectively), and never leak onto records from `latest`, `search`, or `category_tag_browse`.

**Does `maker_browse` also return the maker's own profile info?** Yes — BetaList's "Maker of N startups" page also shows the maker's display name, avatar, bio, and social link, which are stamped onto every startup record that maker submitted (`browsedMakerName`, `browsedMakerAvatarUrl`, `browsedMakerBio`, `browsedMakerSocialUrl`, `browsedMakerStartupCount`). If BetaList has no profile for the given `makerUsername`, the run finishes with 0 records and a clear status message rather than a crash.

**Why does `maker_browse`/`collection_browse` sometimes return fewer records than `maxItems`?** BetaList renders a maker's full submission list and a collection's full roster on a single page — there's no further pagination to fetch, so the actor returns everything on that one page even if it's below your `maxItems` cap.

**How many categories and tags are supported?** All 23 top-level categories and all 734 category/tag combinations BetaList exposes at `/browse`, including a catch-all `Other > Startups` tag. BetaList only lists startups at the category+tag level (browsing a bare category returns no listings), so `categoryTag` always combines both.

**Can I combine `keyword` with `search` mode?** Yes — `keyword` is applied as an additional client-side filter on top of whatever `mode` returns, so you can narrow a `search` or `category_tag_browse` result set further.

**How fresh is the data?** BetaList publishes new launches daily; `latest` mode reflects the live homepage feed at run time.

**Does this actor require a proxy or login?** No. BetaList's listing pages are public and served as plain HTML with no bot-detection observed, so the actor runs without cookies, API keys, or a mandatory proxy.

**Is this affiliated with BetaList?** No, this is a third-party actor that reads BetaList's public pages. It is not affiliated with, endorsed by, or sponsored by BetaList.

# Actor input Schema

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

What to scrape.

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

Free-text query matched against startup name, tagline, and description.

## `categoryTag` (type: `string`):

BetaList only lists startups at the category/tag level, not the bare category level. Pick a Category > Tag combination to browse.

## `region` (type: `string`):

BetaList lists startups by geographic region at both the continent level (e.g. `europe`) and the country level (e.g. `france`) — pick either.

## `collection` (type: `string`):

A curated BetaList roundup: a monthly or yearly retrospective ("Startups of <Month> (<Year>)" / "Startups of <Year>") or a themed/conference collection. Each collection is a small, fixed set of hand-picked startups (not the full launch archive for that period).

## `makerUsername` (type: `string`):

BetaList maker handle (the part after `@` in a profile URL like `betalist.com/@olucurious`) — find it in any startup's `makers[].username` output field. Leading `@` is optional.

## `boostedOnly` (type: `boolean`):

Only keep startups BetaList has marked as BOOSTED (paid featured placement).

## `fetchDetails` (type: `boolean`):

For each startup, additionally fetch its detail page and resolve its real external website URL. Adds the full description, product screenshot gallery, website URL, maker profile(s), the complete topic list, and a reliable launch date in every mode (not just Latest). Costs 2 extra requests per startup, so large `maxItems` runs take longer. Turn off for a fast listing-only scrape.

## `keyword` (type: `string`):

Case-insensitive substring match against the startup name and tagline. Applied on top of the selected mode's results.

## `launchDateFrom` (type: `string`):

Drop startups launched before this date. Reliable in every mode when `fetchDetails` is on; in `latest` mode it also works with `fetchDetails` off. In `latest` mode, an old date reaches back through many pages of the homepage feed (no direct date-jump exists), so very old windows (roughly a few months or more back) take longer and may stop early at a walk-back limit. Empty = no lower bound.

## `launchDateTo` (type: `string`):

Drop startups launched after this date. Reliable in every mode when `fetchDetails` is on; in `latest` mode it also works with `fetchDetails` off. Empty = no upper bound.

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

Hard cap on the number of startup records emitted.

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

Optional. BetaList serves plain server-rendered HTML with no bot-detection observed; a proxy is not required, but the free Apify datacenter (AUTO) group can be enabled to further distribute requests.

## Actor input object example

```json
{
  "mode": "latest",
  "searchQuery": "ai",
  "categoryTag": "ai/artificial-intelligence",
  "region": "north-america",
  "collection": "startups-of-2020",
  "makerUsername": "olucurious",
  "boostedOnly": false,
  "fetchDetails": true,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `startups` (type: `string`):

Dataset containing all scraped BetaList startups.

# 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 = {
    "mode": "latest",
    "searchQuery": "ai",
    "categoryTag": "ai/artificial-intelligence",
    "region": "north-america",
    "collection": "startups-of-2020",
    "makerUsername": "olucurious",
    "boostedOnly": false,
    "fetchDetails": true,
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/betalist-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 = {
    "mode": "latest",
    "searchQuery": "ai",
    "categoryTag": "ai/artificial-intelligence",
    "region": "north-america",
    "collection": "startups-of-2020",
    "makerUsername": "olucurious",
    "boostedOnly": False,
    "fetchDetails": True,
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/betalist-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 '{
  "mode": "latest",
  "searchQuery": "ai",
  "categoryTag": "ai/artificial-intelligence",
  "region": "north-america",
  "collection": "startups-of-2020",
  "makerUsername": "olucurious",
  "boostedOnly": false,
  "fetchDetails": true,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/betalist-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/6x2JemweJJahTL1o4/builds/ntR30ca6hO7nDt9du/openapi.json