# BetaList Startup Listings Scraper (`automation-lab/betalist-startup-listings`) Actor

Export current BetaList startups and supplied public startup pages with descriptions, topics, maker display names, website links and featured dates for recurring launch research.

- **URL**: https://apify.com/automation-lab/betalist-startup-listings.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.16 / 1,000 item processeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## BetaList Startup Listings Scraper

Export current **BetaList startups** for recurring launch research, product discovery, and market mapping. Collect the current home-page startup cards with public detail enrichment, or supply specific BetaList startup URLs.

The output includes startup names, taglines, descriptions, topics, maker display names, public website destinations, featured dates, and source URLs. No login, cookies, or proxy setup is required.

### Who is it for?

- Investors creating a repeatable shortlist of recently featured products.
- Founders researching adjacent products and positioning.
- Analysts building topic-based market maps from public launch descriptions.
- Newsletter researchers reviewing startup launches before editorial selection.

### Why use this scraper?

Get one structured row per unique startup without manually copying its profile. Public details are included in the startup record, not separately charged as enrichment. The Actor reads the website destination from BetaList's public redirect without crawling that external website.

This is a bounded snapshot, not an exhaustive historical database. Store prior exports yourself if you need longitudinal comparisons.

### Get started

1. Open the Actor input.
2. Leave **Startup detail URLs** empty to use the current home page.
3. Set **Maximum startups per run**, such as 10.
4. Run the Actor and inspect the startup dataset.
5. Export JSON, CSV, or Excel from Apify, or retrieve dataset items through the API.

### Input parameters

| Parameter | Default | Behavior |
|---|---|---|
| `startUrls` | `[]` | Optional public detail URLs. An empty array discovers current home-page cards; a nonempty array disables discovery. |
| `maxItems` | `10` | Global maximum unique startup records, integer 1–100. |

Only canonical `https://betalist.com/startups/<slug>` detail URLs are accepted. Query strings, fragments, credentials, other domains, browse pages, and `/visit` inputs are rejected.

URLs are deduplicated before applying the global limit. Current-page discovery can contain fewer startups than the requested maximum. There is no zero/unlimited option, keyword filter, topic filter, or archive pagination.

### Example inputs

Current snapshot:

```json
{"startUrls": [], "maxItems": 10}
```

Specific startup profile:

```json
{
  "startUrls": [{"url": "https://betalist.com/startups/brixcanvas"}],
  "maxItems": 1
}
```

The sample URL is public source data and may change or disappear over time.

### Extracted data

| Field | Meaning |
|---|---|
| `slug` | Identifier from the canonical startup URL. |
| `url` | Public BetaList profile URL. |
| `name` | Startup display name. |
| `tagline` | Heading subtitle on the public profile. |
| `description` | Public description paragraphs, or null when missing. |
| `topics` | Topic labels, or an empty array. |
| `makers` | Public maker display names only, or an empty array. |
| `website` | Public website destination with query and fragment removed, or null. |
| `featuredDate` | Displayed featured date in YYYY-MM-DD format, or null. |
| `scrapedAt` | Collection timestamp in UTC. |

### Output example

This reduced excerpt reflects a real public profile; the dataset contains all fields listed above.

```json
{
  "slug": "brixcanvas",
  "url": "https://betalist.com/startups/brixcanvas",
  "name": "BrixCanvas",
  "tagline": "Turn a conversation into an editable website",
  "topics": ["Event Management", "Online Reservations", "E-Commerce Platforms", "Website Builder", "Membership Management"],
  "website": "https://brixcanvas.com/",
  "featuredDate": "2026-10-24"
}
```

### How much does it cost to scrape BetaList startups?

Pricing is pay per event: a **$0.0005 start fee** per run plus one `item` event per saved startup. Topics, descriptions, maker names, and website metadata have no separate event charge.

| Apify plan | Per startup |
|---|---:|
| FREE | $0.00414 |
| BRONZE | $0.0036 |
| SILVER | $0.002808 |
| GOLD | $0.00216 |
| PLATINUM | $0.00216 |
| DIAMOND | $0.00216 |

Spend tiers follow Apify's qualifying aggregate monthly Store spend, not a private per-Actor bulk schedule. These examples are estimates, not guaranteed invoices.

At BRONZE, one startup costs $0.0041 including the start fee; 10 cost $0.0365; 100 cost $0.3605 if the source supplies that many. You pay for actual saved results, not the requested maximum. The start fee can apply even when a valid run later fails upstream. Consult the pricing tab for the active price and configure an appropriate maximum charge.

### Coverage and limitations

The discovery route uses only current startup rows on the BetaList home page. Promoted rows may appear among those cards. It does not traverse the archive or promise all launches, all categories, historical completeness, private contacts, or engagement metrics.

Public maker names are not verified founder identities. Featured dates describe BetaList's displayed feature date, not incorporation or funding dates. Website URLs are destinations reported by BetaList; they are not verified by visiting the target site.

### Reliability and failures

Requests are sequential and time-bounded. Transient network errors, HTTP 429, and server errors receive at most two additional attempts with backoff. Unsupported responses, missing startup headings, mismatched canonical pages, and unrecognizable listing markup fail explicitly rather than returning a false empty success.

If a later startup fails, previously saved rows may remain in the dataset. Treat a failed run's output as partial. The `SUMMARY` key-value record is written only after a successful collection and records requests, retries, bytes, discovered URLs, mode, and saved count.

### Integrations

Use an Apify Schedule for periodic snapshots, then join exports on `slug` or `url` in your own database. Compare descriptions and topic arrays to identify changed positioning; the Actor itself does not issue change alerts.

Send dataset exports to Google Sheets, a BI tool, or a warehouse using Apify integrations. Keep source URLs in downstream reports so an analyst can inspect the public evidence before making decisions.

### API usage

Use your own Apify token through an environment variable. Do not paste credentials into input.

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~betalist-startup-listings/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"maxItems":10}'
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/betalist-startup-listings').call({ maxItems: 10 });
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 10 });
console.log(items);
```

Python:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/betalist-startup-listings').call(run_input={'maxItems': 10})
print(client.dataset(run['defaultDatasetId']).list_items(limit=10).items)
```

### Use with MCP

Select the stable Actor-specific endpoint:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/betalist-startup-listings"
```

For Claude Desktop, Cursor, and VS Code clients supporting remote HTTP MCP:

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/betalist-startup-listings"}}}
```

Configure authentication according to your client. Example prompts: “Collect 10 current BetaList startups and summarize the topics with source links.” Or: “Extract this public BetaList startup URL and show its description and website.”

Discover actual tool names and arguments with scoped `tools/list`; selection also supplies run/data tools, not just one Actor tool. Discovery is read-only. For an authorized run, start once and retain the run ID and storage IDs; they are metadata, not rows. If nonterminal, follow the same run with bounded 2/4/8-second backoff capped at 10 seconds and a 120-second deadline. Choose a client timeout longer than the server wait plus transport margin. On timeout, recover the known run rather than start another; if its ID is unknown, report uncertainty.

After success, read bounded dataset pages with explicit fields, limit and offset. For example, admit pages of 20 rows, at most 100 source rows and 64 KiB of serialized UTF-8 content into model context. Enforce byte limits host-side, disclose omitted oversized rows, and report continuation offsets and truncation. If your client cannot enforce that ceiling, do not claim a hard byte guarantee. Full exports stay in storage outside model context. At deadline, report pending and stop polling; failed-run rows are partial. Client discovery/caching capabilities differ; no numeric token-saving guarantee is implied.

### Legality, responsible use and privacy

Use public startup information responsibly and comply with applicable laws, source terms, and data-protection obligations. Public availability is not permission for unsolicited outreach or unrestricted republication. This Actor does not retrieve private emails, phone numbers, accounts, or login-protected pages and is not affiliated with BetaList.

No AI provider is used at runtime. Run datasets, logs, and key-value records follow your Apify storage retention settings; you can delete those stores through Apify. There is no persistent Actor-global cache. For help, open an issue on the Actor's Apify page.

Failed operations send sanitized diagnostic input, exceptions, and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days.

### FAQ and troubleshooting

**Why are there fewer rows than maxItems?** The home page is finite, duplicates are removed, and an explicit URL list may contain fewer unique URLs. maxItems is an upper bound, not a coverage promise.

**Can I scrape categories or the full archive?** Not with this Actor. Supply known public startup detail URLs or use current-home-page discovery.

**Why did a URL fail?** Check that it is a canonical public startup page. Deleted pages, challenges, upstream errors, or source markup changes fail explicitly. Do not treat partial rows from a failed run as a complete export.

**Can I obtain contact details or startup traction?** No. Only the documented public profile fields are included.

### Related workflows

This is a standalone BetaList launch corpus. Other startup directories represent distinct launch sources, not additional BetaList or funding coverage. Combine exports in your own pipeline only when those differences fit your research question.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/betalist-startup-listings/changelog.md

# Actor input Schema

## `startUrls` (type: `array`):

Leave empty to discover startup cards from the current BetaList home page only. Otherwise fetch only these canonical https://betalist.com/startups/<slug> URLs; no listing discovery. Queries, fragments, other hosts and non-detail paths are rejected. Duplicates are removed before the global limit.

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

Global maximum unique startup records, applied after URL deduplication across supplied URLs or current-page discovery. Default 10, range 1–100; zero/unlimited is unsupported. Current-page availability can return fewer records. No archive pagination is performed.

## Actor input object example

```json
{
  "startUrls": [],
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Public startup profiles collected in this run.

## `summary` (type: `string`):

Successful run request, retry and output counters.

# 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 = {
    "startUrls": [],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/betalist-startup-listings").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 = {
    "startUrls": [],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/betalist-startup-listings").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [],
  "maxItems": 10
}' |
apify call automation-lab/betalist-startup-listings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/betalist-startup-listings"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/WdcxCGMY8i2VAduTe/builds/L2gObIg0bwHFthX1z/openapi.json