# Startup Jobs Intelligence (`brilliant_gum/startup-jobs-intelligence`) Actor

Scrape job listings from YC-backed startups enriched with salary, equity %, tech stack, seniority, hiring velocity and lead score (0–100). Filter by role, remote, YC batch, funding stage, industry, team size, keywords. Sources: WorkAtAStartup + Greenhouse ATS.

- **URL**: https://apify.com/brilliant\_gum/startup-jobs-intelligence.md
- **Developed by:** [Yuliia Kulakova](https://apify.com/brilliant_gum) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 21 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 job records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Startup Jobs Intelligence

![Startup Jobs Intelligence](https://i.imgur.com/V1S3G4R.png)

**Discover startup job openings with rich company and funding context — all in one run.**

Search across YC-backed companies and their job boards. Every result is enriched with funding stage, tech stack, salary ranges, equity details, seniority level, hiring velocity, and a lead score — giving you the full picture instantly.

***

### What You Get

Each job record includes:

| Field | Description |
|-------|-------------|
| **Job title & apply URL** | Direct link to apply |
| **Location & remote flag** | Is it remote? Where? |
| **Seniority level** | Detected automatically: junior, mid, senior, staff, lead, head |
| **Salary range** | Extracted from description: min, max, currency |
| **Equity** | Range or mention: 0.1%–0.5%, "equity offered" |
| **Tech stack** | 190+ technologies auto-detected from description |
| **Company funding stage** | seed, Series A, Series B, Series C, growth, public |
| **YC batch** | W24, S23, W23 etc. |
| **Team size** | Current headcount |
| **Industries** | Fintech, AI/ML, Healthcare, SaaS… |
| **Hiring velocity** | How many open roles the company has right now |
| **Lead score (0–100)** | Composite signal: funding × velocity × salary × equity |
| **Company links** | Website, LinkedIn, Twitter, YC profile |

***

### Use Cases

- **Tech recruiters** — find every Backend/ML/DevOps opening at Series A–B YC startups before they hit job aggregators
- **Job seekers** — filter by remote + salary + equity + tech stack in one place
- **Sales & BD teams** — identify fast-growing companies (high hiring velocity = available budget)
- **VC analysts** — track which portfolio companies are expanding
- **Market researchers** — analyse hiring trends across the YC ecosystem

***

### Input Options

#### Simple search (engineering jobs, remote)

```json
{
  "roles": ["eng"],
  "remote": true,
  "maxResults": 50
}
```

#### Early-stage YC companies only, with salary filter

```json
{
  "roles": ["eng", "data"],
  "fundingStage": ["early"],
  "minSalary": 150000,
  "hasEquity": true,
  "maxResults": 100
}
```

#### Specific YC batches + tech stack

```json
{
  "ycBatchFilter": ["W24", "S23"],
  "techStack": ["Rust", "Go", "Kubernetes"],
  "remote": true,
  "maxResults": 30
}
```

#### AI/ML companies, all roles

```json
{
  "industries": ["AI / ML", "Developer Tools"],
  "keywords": "machine learning",
  "sources": ["workatastartup", "greenhouse"],
  "maxResults": 200
}
```

#### Startup sales intelligence

```json
{
  "fundingStage": ["series_b", "series_c"],
  "minTeamSize": 50,
  "maxTeamSize": 300,
  "roles": ["sales", "marketing"],
  "maxResults": 100
}
```

***

### Filters Reference

| Parameter | Type | Description |
|-----------|------|-------------|
| `keywords` | string | Match against job title and description |
| `roles` | array | `eng`, `design`, `product`, `sales`, `marketing`, `ops`, `finance`, `data` |
| `location` | string | City, country, or "Remote" |
| `remote` | boolean | Remote jobs only |
| `ycBatchFilter` | array | e.g. `["W24","S23","W23"]` |
| `fundingStage` | array | `early` (seed–Series C), `growth` (Series D+, late-stage) |
| `industries` | array | e.g. `["Fintech","AI / ML","Healthcare"]` |
| `minTeamSize` | integer | Minimum team size |
| `maxTeamSize` | integer | Maximum team size |
| `techStack` | array | Required technologies, e.g. `["Rust","PostgreSQL","Kubernetes"]` |
| `minSalary` | integer | Minimum annual salary in USD |
| `hasEquity` | boolean | Must mention equity/options |
| `seniority` | array | `intern`, `junior`, `mid`, `senior`, `staff`, `principal`, `lead`, `head` |
| `maxResults` | integer | 1–1,000 (default 100) |
| `includeJobDescription` | boolean | Include full job text (default false) |
| `sources` | array | `workatastartup`, `greenhouse` |

***

### Lead Score

Every job receives a score from **0 to 100** with a grade (A–F):

| Score | Grade | Meaning |
|-------|-------|---------|
| 80–100 | **A** | Prime target — high-growth stage, active hiring, salary + equity disclosed |
| 65–79 | **B** | Strong lead — established company, healthy hiring |
| 50–64 | **C** | Good opportunity — some signals present |
| 35–49 | **D** | Low signal — limited public data |
| 0–34 | **F** | Minimal data available |

Factors contributing to the score include: funding stage, number of open roles, team size, YC batch recency, salary transparency, equity disclosure, and company profile completeness.

***

### Sample Output

```json
{
  "jobTitle": "Senior Backend Engineer",
  "applyUrl": "https://boards.greenhouse.io/acme/jobs/123",
  "location": "San Francisco, CA / Remote",
  "isRemote": true,
  "seniority": "senior",
  "salaryMin": 180000,
  "salaryMax": 220000,
  "salaryCurrency": "USD",
  "equityMin": 0.1,
  "equityMax": 0.3,
  "equityRaw": "0.1% - 0.3%",
  "techStack": ["Go", "Kubernetes", "PostgreSQL", "AWS"],
  "atsType": "greenhouse",
  "postedAt": "2026-04-15T00:00:00.000Z",
  "company": {
    "name": "Acme AI",
    "ycBatch": "W23",
    "stage": "early",
    "totalFunding": "$45M",
    "teamSize": 65,
    "industries": ["AI / ML", "Developer Tools"],
    "website": "https://acme.ai",
    "isHiring": true
  },
  "hiringVelocity": {
    "openRoles": 12,
    "last30Days": 7,
    "trend": "growing"
  },
  "leadScore": {
    "score": 87,
    "grade": "A",
    "factors": ["stage:series_b", "open_roles:12", "team_size:65", "salary_range_disclosed", "equity_range_disclosed"]
  }
}
```

***

### Pricing

| Event | Cost | Description |
|-------|------|-------------|
| Run start | $0.02 | Flat fee per run |
| Job record | $0.002 | Per result (without description) |
| Job + description | $0.005 | Per result with full job text |

**Example:** 100 jobs without descriptions = **$0.02 + $0.20 = $0.22 total**

***

### Data Sources

- **WorkAtAStartup** — YC's official job board, updated daily
- **Greenhouse** — Direct ATS job board access (public API)

Company metadata (YC batch, funding, team size) is sourced from the YC company directory, updated daily.

***

### Perfect For

- Recruiting & staffing agencies focused on tech startups
- Job seekers targeting YC-backed companies
- B2B SaaS sales teams doing account-based outreach
- Early-stage investors tracking portfolio hiring
- HR analytics and market research

# Actor input Schema

## `keywords` (type: `string`):

Search terms matched against job title and description (e.g. 'machine learning', 'fullstack react')

## `roles` (type: `array`):

Filter by role type. Leave empty for all roles.

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

City, country, or 'Remote'. Leave empty to include all locations.

## `remote` (type: `boolean`):

Only include remote-eligible jobs

## `ycBatchFilter` (type: `array`):

Restrict to specific YC batches, e.g. \["W24","S23"]. Leave empty for all batches.

## `fundingStage` (type: `array`):

Filter companies by stage. 'early' = seed through Series C startups. 'growth' = late-stage, Series D+ and acquired companies. Leave empty for all.

## `industries` (type: `array`):

Filter by industry tags, e.g. \["Fintech","AI / ML","Healthcare"]. Leave empty for all.

## `minTeamSize` (type: `integer`):

Minimum company employee count

## `maxTeamSize` (type: `integer`):

Maximum company employee count

## `techStack` (type: `array`):

Only include jobs that mention at least one of these technologies in the description, e.g. \["Rust","Kubernetes","PyTorch"]

## `minSalary` (type: `integer`):

Only include jobs with an extracted salary >= this value. Leave empty to include all (including those with no salary listed).

## `hasEquity` (type: `boolean`):

Only include jobs that mention equity, options or RSUs

## `seniority` (type: `array`):

Filter by seniority. Leave empty for all levels.

## `maxResults` (type: `integer`):

Maximum number of job records to return (1–1000)

## `includeJobDescription` (type: `boolean`):

Include full job description text (truncated to 2000 characters). Increases cost per record.

## `sources` (type: `array`):

Which job boards to scrape. 'workatastartup' = YC's official board (fastest). 'greenhouse' = direct ATS pages for YC companies.

## `minDelay` (type: `integer`):

Minimum delay between requests in milliseconds

## `maxDelay` (type: `integer`):

Maximum delay between requests in milliseconds

## Actor input object example

```json
{
  "roles": [
    "eng"
  ],
  "remote": false,
  "ycBatchFilter": [],
  "fundingStage": [],
  "industries": [],
  "techStack": [],
  "hasEquity": false,
  "seniority": [],
  "maxResults": 100,
  "includeJobDescription": false,
  "sources": [
    "workatastartup"
  ],
  "minDelay": 1500,
  "maxDelay": 4000
}
```

# Actor output Schema

## `jobId` (type: `string`):

Unique deterministic job identifier

## `jobTitle` (type: `string`):

Job title as listed

## `jobUrl` (type: `string`):

URL of the job listing page

## `applyUrl` (type: `string`):

Direct application URL

## `atsType` (type: `string`):

Source system: workatastartup | greenhouse | lever

## `postedAt` (type: `string`):

ISO 8601 date when the job was posted

## `scrapedAt` (type: `string`):

ISO 8601 timestamp of when the record was scraped

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

Job location string

## `isRemote` (type: `string`):

Whether the job is remote-eligible (true/false)

## `seniority` (type: `string`):

Detected seniority: intern | junior | mid | senior | staff | principal | lead | head

## `salaryMin` (type: `string`):

Minimum annual salary in USD (null if not listed)

## `salaryMax` (type: `string`):

Maximum annual salary in USD (null if not listed)

## `salaryCurrency` (type: `string`):

Salary currency code: USD | EUR | GBP etc.

## `salaryRaw` (type: `string`):

Original salary text as found in the job description

## `equityMin` (type: `string`):

Minimum equity percentage (null if not mentioned)

## `equityMax` (type: `string`):

Maximum equity percentage (null if not mentioned)

## `equityRaw` (type: `string`):

Original equity text as found in the job description

## `techStack` (type: `string`):

Technologies extracted from job description (e.g. Go, PostgreSQL, AWS)

## `jobDescription` (type: `string`):

Full job description text (only if includeJobDescription=true)

## `departments` (type: `string`):

Department tags from Greenhouse/Lever

## `company` (type: `string`):

Company object: name, ycBatch, stage, totalFunding, teamSize, website, industries, isHiring

## `hiringVelocity` (type: `string`):

Hiring signals: openRoles, last30Days, trend (growing | stable | low)

## `leadScore` (type: `string`):

Lead quality score 0-100 with grade A-F and contributing factors

# 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 = {
    "keywords": "",
    "location": "",
    "ycBatchFilter": [],
    "industries": [],
    "techStack": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("brilliant_gum/startup-jobs-intelligence").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 = {
    "keywords": "",
    "location": "",
    "ycBatchFilter": [],
    "industries": [],
    "techStack": [],
}

# Run the Actor and wait for it to finish
run = client.actor("brilliant_gum/startup-jobs-intelligence").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 '{
  "keywords": "",
  "location": "",
  "ycBatchFilter": [],
  "industries": [],
  "techStack": []
}' |
apify call brilliant_gum/startup-jobs-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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