# Startup.jobs Scraper (`parsebird/startup-jobs-scraper`) Actor

Extract job listings from Startup.jobs — titles, companies, salaries, locations, descriptions, and application links. Filter by keyword and location. Export as JSON, CSV, Excel. Pay per result.

- **URL**: https://apify.com/parsebird/startup-jobs-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Jobs, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 11 total users, 2 monthly users, 96.6% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 listing scrapeds

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/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

### Startup.jobs Scraper — Extract Job Listings, Salaries & Company Data

Extract structured job listings from [Startup.jobs](https://startup.jobs) — the leading startup job board with thousands of active postings from fast-growing technology companies. Search by keyword, location, and workplace type. Get job titles, company details, salary ranges, descriptions, and application links. Export as JSON, CSV, or Excel.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search by keyword and location, collect up to 500 job listings per run with 24 structured data fields — including salary ranges, job descriptions, employment type, company info, and direct application links. Two-tier pricing: $1/1,000 for listings, $1.50/1,000 with full details.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```
Apify Actor: parsebird/startup-jobs-scraper — extracts job listings from Startup.jobs. $0.001/listing ($1/1000) or $0.0015/detail ($1.50/1000). Call via ApifyClient: client.actor("parsebird/startup-jobs-scraper").call(run_input={"keyword": "software engineer", "location": "Remote", "collectDetails": False, "results_wanted": 20}). Inputs: keyword (string, search term), location (string, default "Remote"), startUrl (string, optional override URL), collectDetails (boolean, default false, fetch full descriptions), results_wanted (integer, default 20, max 500). Output: dataset with id, title, company, location, job_type, salary, posted_at, description_text, description_html, company_logo, apply_link, url, tags, workplace_type, employment_type, salary_min, salary_max, salary_currency, city, country, company_slug, fetched_at. API docs: https://docs.apify.com/api/v2 Token: https://console.apify.com/settings/integrations
```

### What is Startup.jobs Scraper?

**Startup.jobs Scraper** is an [Apify Actor](https://apify.com/actors) that extracts job listings from [Startup.jobs](https://startup.jobs) — a popular job board focused on startup and technology companies. It collects structured data including job titles, company names, salary ranges, locations, full job descriptions, and application links.

This actor uses a **hybrid approach** — a stealth browser bypasses Cloudflare protection and captures API credentials, then queries the Algolia search API directly for fast, paginated results. When `collectDetails` is enabled, detail pages are enriched via browser for full descriptions and apply links. Clean, structured data ready for analysis, monitoring, or integration.

Startup.jobs Scraper is a cost-effective alternative to building your own [Startup.jobs](https://startup.jobs) data pipeline — no coding, infrastructure, or maintenance required.

### What can Startup.jobs Scraper do?

- 🔍 **Keyword search** — Find jobs by role, skill, or technology (e.g. "software engineer", "product manager", "data scientist")
- 📍 **Location filtering** — Filter by "Remote" for remote-first positions, or search all locations
- 📄 **Full description enrichment** — Optionally fetch complete job descriptions and application links from detail pages
- 💰 **Salary data** — Extract salary ranges with currency and interval when published by employers
- 🏢 **Company details** — Company name, logo URL, and slug for each listing
- 🏷️ **Tags and categories** — Role tags, employment type, workplace type, and experience level
- ⚡ **Fast hybrid extraction** — Algolia API for listings, browser for detail enrichment
- 📊 **Up to 500 results per run** — Automatic pagination through listing pages
- 🔗 **Direct application links** — Get the apply URL for each job listing (with `collectDetails`)
- 📅 **Scheduling support** — Set up [recurring runs](https://docs.apify.com/platform/schedules) to monitor new job postings daily or weekly

### What data can you extract from Startup.jobs?

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique job identifier from Startup.jobs |
| `title` | string | Job title (e.g. "Senior Full Stack Engineer") |
| `company` | string | Hiring company name |
| `location` | string | Job location or remote status |
| `job_type` | string | Employment type — Full Time, Part Time, Contract, Internship |
| `salary` | string | Formatted salary range (e.g. "USD 150,000 - 200,000 per year") |
| `posted_at` | string | Job publish timestamp (ISO 8601) |
| `description_text` | string | Plain text job description (when `collectDetails` is enabled) |
| `description_html` | string | Rich HTML job description (when `collectDetails` is enabled) |
| `company_logo` | string | Company logo image URL |
| `apply_link` | string | Direct application URL (when `collectDetails` is enabled) |
| `url` | string | Job listing page URL on Startup.jobs |
| `tags` | array | Role and topic tags (e.g. \["Engineer", "Full Stack", "Senior"]) |
| `workplace_type` | string | Remote, Hybrid, or On-site |
| `salary_min` / `salary_max` | number | Numeric salary bounds for analysis |
| `salary_currency` | string | Currency code (USD, EUR, GBP, etc.) |
| `city` / `country` | string | Structured location fields |
| `company_slug` | string | Company URL slug on Startup.jobs |

### How to scrape Startup.jobs

1. **Go to** [Startup.jobs Scraper](https://apify.com/parsebird/startup-jobs-scraper) on Apify Store and click **Try for free**
2. **Enter a search keyword** — type a job title, skill, or role you're looking for (e.g. "software engineer")
3. **Set the location** — enter "Remote" for remote jobs, or leave it to get all locations (default: Remote)
4. **Choose whether to collect details** — enable "Collect Job Details" to get full descriptions and apply links (disabled by default to keep costs low)
5. **Set your limit** — adjust "Max Results" (default 20, max 500)
6. **Click Start** — the scraper begins extracting job listings immediately
7. **Download your data** — export results as JSON, CSV, Excel, or access them via the [Apify API](https://docs.apify.com/api/v2)

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrl` | string | No | — | Custom Startup.jobs listing URL. Overrides keyword and location filters when provided |
| `keyword` | string | No | `""` | Search phrase — job title, skill, or role keywords |
| `location` | string | No | `"Remote"` | Location filter. Use "Remote" for remote jobs, or enter a city/country |
| `collectDetails` | boolean | No | `false` | Fetch full job descriptions and application links from detail pages. Costs $1.50/1,000 vs $1/1,000 without |
| `results_wanted` | integer | No | `20` | Maximum number of job listings to collect (1–500) |

### Output example

```json
{
    "id": "6654883",
    "title": "Senior Full Stack Engineer",
    "company": "Solace",
    "location": "Remote",
    "job_type": "Full Time",
    "salary": "USD 150,000 - 200,000 per year",
    "posted_at": "2026-01-22T16:50:47Z",
    "description_text": "As a Full Stack Engineer, you'll join a talented team and own delivery from requirements through release...",
    "description_html": "<div class=\"trix-content\">...</div>",
    "company_logo": "https://startup.jobs/logos/34127",
    "apply_link": "https://startup.jobs/apply/4cec53b4-9d8e-4ce7-989b-b9f0e163de13",
    "url": "https://startup.jobs/senior-full-stack-engineer-solace-6654883",
    "source": "listing+details",
    "fetched_at": "2026-02-14T05:28:50.151Z",
    "tags": ["Engineer", "Full Stack", "Senior"],
    "workplace_type": "Remote",
    "employment_type": "full-time",
    "experience_bucket": null,
    "salary_min": 150000,
    "salary_max": 200000,
    "salary_currency": "USD",
    "city": null,
    "country": "United States",
    "company_slug": "solace"
}
```

### How to use Startup.jobs Scraper with the API

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("parsebird/startup-jobs-scraper").call(run_input={
    "keyword": "software engineer",
    "location": "Remote",
    "collectDetails": False,
    "results_wanted": 50,
})

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    salary = job.get("salary") or "Not listed"
    print(f"{job['title']} at {job['company']} — {salary}")
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('parsebird/startup-jobs-scraper').call({
    keyword: 'software engineer',
    location: 'Remote',
    collectDetails: false,
    results_wanted: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(job => {
    const salary = job.salary || 'Not listed';
    console.log(`${job.title} at ${job.company} — ${salary}`);
});
```

### How much does it cost to scrape Startup.jobs?

Startup.jobs Scraper uses [Pay-Per-Event pricing](https://docs.apify.com/platform/actors/running/pay-per-event) with two tiers depending on whether you collect job details.

| Event | What you get | Price per event | Price per 1,000 |
|-------|-------------|----------------|-----------------|
| `listing-scraped` | Job title, company, salary, location, tags, URL | $0.001 | **$1.00** |
| `detail-scraped` | Everything above + full description, HTML, apply link | $0.0015 | **$1.50** |

**Typical costs (listings only, `collectDetails: false`):**

- 20 jobs (default run): **~$0.02**
- 100 jobs: **~$0.10**
- 500 jobs (max per run): **~$0.50**

**Typical costs (with details, `collectDetails: true`):**

- 20 jobs: **~$0.03**
- 100 jobs: **~$0.15**
- 500 jobs: **~$0.75**

New Apify users get a **free trial** with $5 of platform credits — enough to scrape thousands of job listings at no cost.

### Use cases

- **Talent intelligence** — Track hiring demand across startup roles, locations, and seniority levels. Build weekly trend snapshots for leadership and recruiting teams
- **Recruitment operations** — Automate candidate sourcing by collecting new openings and role attributes. Reduce manual job-board monitoring effort
- **Compensation research** — Analyze salary ranges by function, seniority, and market. Support compensation benchmarking with structured salary data
- **Job alert platforms** — Feed job records into internal dashboards, notification systems, or matching algorithms
- **Market research** — Monitor role requirements, tech stacks, and company hiring patterns over time. Identify trends in startup hiring strategies
- **Academic research** — Study startup labor market dynamics, remote work adoption, and salary distribution patterns

### Integrations and export formats

Connect Startup.jobs Scraper output with your existing tools:

- **[Google Sheets](https://apify.com/integrations/google-sheets)** — Automatically sync job data to a spreadsheet for team collaboration
- **[Airtable](https://apify.com/integrations/airtable)** — Build searchable hiring intelligence tables
- **[Zapier](https://apify.com/integrations/zapier)** — Trigger notifications, CRM updates, or Slack alerts when new jobs match your criteria
- **[Make](https://apify.com/integrations/make)** — Automate downstream workflows and data pipelines
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — Deliver fresh results to your own API endpoints

**Export formats:** JSON, CSV, Excel, XML — download directly from the Apify Console or via the [API](https://docs.apify.com/api/v2).

### FAQ

**How fresh is the data?**
Data is extracted live from Startup.jobs at the time of each run. Schedule [recurring runs](https://docs.apify.com/platform/schedules) to keep your dataset up to date — daily, weekly, or at any interval.

**Can I get full job descriptions?**
Yes. Enable `collectDetails` to fetch the full job description text and HTML from each detail page. This costs $1.50/1,000 jobs vs $1/1,000 for listings only.

**Why are some salary fields empty?**
Not all employers publish salary information on Startup.jobs. When salary data is not available, the `salary`, `salary_min`, `salary_max`, and `salary_currency` fields will be null.

**Can I filter by employment type or workplace type?**
The `keyword` field accepts any search term — you can use it to target specific employment types (e.g. "part-time data analyst"). The `location` filter set to "Remote" automatically filters for remote-only positions via the Algolia search API.

**How many jobs can I scrape per run?**
Up to 500 jobs per run using the `results_wanted` parameter. The scraper automatically paginates through as many pages as needed. For larger collections, schedule multiple runs with different keywords.

**Can I use a custom Startup.jobs URL?**
Yes. Paste any Startup.jobs listing URL into the `startUrl` field — it overrides the keyword and location filters. This is useful for scraping specific search result pages or filtered views.

**Does this scraper need proxies?**
No proxies are required for basic usage. The scraper uses a stealth browser to bypass Cloudflare protection and then queries the Algolia search API directly. On Apify, it runs without additional proxy configuration.

**Can I access the data via API?**
Yes. Use the [Apify API](https://docs.apify.com/api/v2) to start runs, retrieve results, and integrate Startup.jobs data into your own applications. See the Python and JavaScript examples above.

**Something not working? Have a feature request?**
Open an issue in the [Issues tab](https://console.apify.com/actors/parsebird~startup-jobs-scraper/issues) — we respond to all reports.

### Is it legal to scrape Startup.jobs?

This Actor extracts publicly available job listing data from [Startup.jobs](https://startup.jobs) — the same information any visitor can see in their browser. It does not bypass authentication, access private data, or violate CAPTCHA protections.

Web scraping of publicly available data is generally considered legal in the United States and European Union, as affirmed by the [US Ninth Circuit ruling in HiQ v. LinkedIn](https://docs.apify.com/academy/anti-scraping/is-web-scraping-legal). However, users are responsible for ensuring their use of extracted data complies with applicable laws, regulations, and the target website's Terms of Service.

For more context, see Apify's guide: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

### Other job scrapers on Apify

Looking for job data from other platforms? Check out these ParseBird scrapers:

- **[Hiring.cafe Jobs Scraper](https://apify.com/parsebird/hiring-cafe-scraper)** — Search across 20+ job boards with keyword, location, salary, and seniority filters
- **[Dice Jobs Scraper](https://apify.com/parsebird/dice-jobs-scraper)** — Extract tech job listings from Dice.com
- **[Wellfound Jobs Scraper](https://apify.com/parsebird/wellfound-jobs-scraper)** — Scrape startup jobs from Wellfound (formerly AngelList Talent)
- **[Xing Jobs Scraper](https://apify.com/parsebird/xing-jobs-scraper)** — Extract job listings from Xing, the leading DACH job platform
- **[Rozee.pk Jobs Scraper](https://apify.com/parsebird/rozeepk-jobs-scraper)** — Scrape jobs from Pakistan's largest job board
- **[Arbeitsagentur Scraper](https://apify.com/parsebird/arbeitsagentur-scraper)** — Extract job listings from Germany's Federal Employment Agency

# Changelog

This Actor's version history is a separate document: https://apify.com/parsebird/startup-jobs-scraper/changelog.md

# Actor input Schema

## `startUrl` (type: `string`):

Custom Startup.jobs listing URL. When provided, it overrides keyword and location filters.

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

Job title or skills to search for (e.g. 'software engineer', 'product manager', 'data scientist').

## `location` (type: `string`):

Location filter. Use 'Remote' for remote-first jobs, or enter a city or country name.

## `collectDetails` (type: `boolean`):

Fetch full job descriptions and application links from each job detail page. Costs $1.50/1,000 jobs with details vs $1/1,000 without.

## `results_wanted` (type: `integer`):

Maximum number of job listings to collect (1–500).

## Actor input object example

```json
{
  "keyword": "software engineer",
  "location": "Remote",
  "collectDetails": false,
  "results_wanted": 20
}
```

# Actor output Schema

## `dataset` (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 = {
    "keyword": "software engineer",
    "location": "Remote",
    "collectDetails": false,
    "results_wanted": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/startup-jobs-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 = {
    "keyword": "software engineer",
    "location": "Remote",
    "collectDetails": False,
    "results_wanted": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/startup-jobs-scraper").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 '{
  "keyword": "software engineer",
  "location": "Remote",
  "collectDetails": false,
  "results_wanted": 20
}' |
apify call parsebird/startup-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/startup-jobs-scraper"
        }
    }
}
```

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/oE1Wjlw7z3AP8er20/builds/mU4aTn7Wh6DIr1SYD/openapi.json