# Work at a Startup Jobs & Company Data (`b2b_leads/work-at-a-startup-real-time-data-scraper`) Actor

Collect live startup jobs and YC company profiles from Work at a Startup: listings by role and keyword, full company profiles with founders and open roles, plus lead details and real-time webhooks. Structured JSON streams to your dataset.

- **URL**: https://apify.com/b2b_leads/work-at-a-startup-real-time-data-scraper.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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/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

## Work at a Startup Real-Time Data

Live startup jobs and YC company profiles from Work at a Startup (Y Combinator's startup jobs board) — structured JSON streamed straight to your dataset. Search the live jobs board by role and keyword, resolve companies to full profiles with founders and open roles, and push everything to your CRM, sheets, or Slack in real time.

> **Free-trial notice:** on the Apify free plan each run returns a small sample (2 results). Upgrade to a paid Apify plan for full, unlimited data.

### Who this is for

- **Recruiters & sourcing teams** building YC-startup talent pipelines
- **Job boards & aggregators** keeping startup listings fresh
- **Founders & operators** tracking who is hiring, for what, and where
- **Investors & researchers** mapping YC hiring activity by batch, industry, and role
- **Agencies & CRMs** enriching startup company records with founders and open roles

#### Use cases

1. **Startup sourcing lists** — collect engineering, product, and GTM openings across YC batches with salary ranges and locations.
2. **Hiring-signal intel** — watch which startups are growing (open-roles count, team size, batch) for sales and fundraising outreach.
3. **Founder discovery** — get founder names, bios, and LinkedIn links per company for partnership and recruiting outreach.
4. **Remote-job feeds** — filter to remote-only roles for remote job boards and talent newsletters.
5. **Market mapping** — compare roles, salaries, and locations across startups by keyword and role.
6. **CRM enrichment** — feed company profiles (website, socials, industry, founders) into your startup database.

### Features

| Feature | What you get | Default |
|---|---|---|
| 💼 Jobs | Live job listings: title, salary range, location, workplace type, company, batch, posting age | ✅ On (10 per search) |
| 🏢 Companies | Full YC company profiles: batch, industry, location, team size, founders, open roles, website/socials | ✅ On (cap 10) |
| 🔗 Scrape by URL | Individual job (`/jobs/...`) or company (`/companies/...`) URLs as their own rows with full details | Off |
| 🎯 Lead details | Adds full posting text, visa/experience notes (jobs) and founders, open roles, links (companies) in place — nothing dropped | Off |
| 🌐 Connection | Apify residential US proxy by default; country picker supported | Residential US |
| 🔔 Webhooks | JSON or Slack push per record, in addition to the dataset | Off |
| 💰 Pricing | Pay-per-result (`result` event) + spend-cap safe; 2-result free-plan sample | — |

Every discovered item is exported. Turning lead details on enriches the same row (`detailsFetched: true`) — it never creates a second row and never drops partial records.

### Input reference

| Field | Type | Default | Notes |
|---|---|---|---|
| `enableJobs` | checkbox | `true` | Collect live job listings. |
| `jobKeywords` | string list | `["AI engineer"]` | Text filter on board cards — every word must appear in the card (title, role, tagline, company). Empty = latest listings. Stored on each row as context. |
| `jobRoles` | string list | `["all"]` | Board roles (one view per role): `all`, `software-engineer`, `designer`, `product-manager`, `data-scientist`, `data-analyst`, `devops-engineer`, `marketing`, `sales`, `operations`, `finance`, `legal`, `recruiting`, `customer-support`, `science`. |
| `feedMaxJobs` | number | `10` | Jobs collected per role board view, after keyword filtering (total can reach this × number of roles). `0` = no cap. Main cost lever for jobs. |
| `feedRemoteOnly` | checkbox | `false` | Keep only remote job rows. |
| `enableCompanies` | checkbox | `true` | Resolve companies from this run's listings to full profiles. |
| `companyKeywords` | string list | `[]` | Extra discovery keywords (one extra board view each on the `all` role) + context on company rows. |
| `feedMaxCompanies` | number | `10` | Cap on company rows. `0` = no cap. Main cost lever for companies. |
| `enableScrapeByUrl` | checkbox | `false` | Enable URL collection below. |
| `jobUrls` | string list | `[]` | e.g. `https://www.workatastartup.com/jobs/103090` |
| `companyUrls` | string list | `[]` | e.g. `https://www.workatastartup.com/companies/parameter` |
| `enableLeadDetails` | checkbox | `false` | Full details in place. Adds a little extra time per record. |
| `webhookUrl` | text | `""` | Extra real-time push target (dataset always written). |
| `webhookFormat` | select | `json` | `json` = full record; `slack` = Slack-friendly message. |
| `proxyConfiguration` | proxy | Residential US | Change only for a different country or custom proxies. |

Empty input still runs a useful demo: the latest board listings (10 jobs).

Validation: enabling Scrape by URL without URLs, or disabling everything with no URLs, returns a clear error before any collection starts.

### Output reference

#### Job row

| Field | Example |
|---|---|
| `featureType` | `jobs_feed` / `scrape_by_url` |
| `recordType` | `job` |
| `jobId` / `jobUrl` | `103090` / `https://www.workatastartup.com/jobs/103090` |
| `title` | `Search Engineer` |
| `companyName` / `companyBatch` / `companyProfileUrl` | `Firecrawl` / `S22` / `…/companies/firecrawl` |
| `location` / `workplaceType` / `remote` | `San Francisco HQ; Toronto Hub / Remote (US)` / `Hybrid` / `true` |
| `jobType` / `roleType` | `Full-time` / `Full stack` |
| `salary` / `salaryRange` / `equityRange` | `$190K - $260K` / … / … |
| `sponsorsVisa` / `minExperience` | `US citizen/visa only` / `3+ years` |
| `description` | Full posting text (lead details on) |
| `postedAt` | Posting age as shown (`about 7 hours ago`) |
| `searchQuery` / `detailsFetched` / `scrapedAt` | context + flags |

#### Company row

| Field | Example |
|---|---|
| `featureType` | `company_profiles` / `scrape_by_url` |
| `recordType` | `company` |
| `name` / `slug` / `profileUrl` | `Parameter` / `parameter` / `…/companies/parameter` |
| `batch` / `industry` / `industries` | `W26` / `B2B -> Security` / `[…]` |
| `location` / `teamSize` | `San Francisco` / `14` |
| `description` / `tagline` | Full pitch + hiring notes |
| `website` / `twitterUrl` / `facebookUrl` | Company links |
| `founders` | `[{ name, linkedinUrl, bio }]` |
| `openJobs` / `openJobsCount` | `[{ jobId, title, location, jobType, salaryRange, jobUrl }]` |
| `leadDetails` | `{ website, twitterUrl, facebookUrl, email, phones, address, … }` (lead details on) |
| `searchQuery` / `detailsFetched` / `scrapedAt` | context + flags |

Run summary (`OUTPUT` in the key-value store) carries `totalPushed`, `enabledFeatures`, `errors`, `spendingLimitReached`, and the `paywall` transparency object.

### Webhooks

Set `webhookUrl` to also push each record as it is finalized (dataset writes always happen). `json` delivers the full record object — point it at Zapier, Make, or your own URL. `slack` delivers a ready-to-read message — point it at a Slack incoming webhook. Delivery is fire-and-forget: failures are logged and never stop the run.

### AI-agent usage (MCP)

Pair this Actor with the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) so agents can call it with natural language. Example prompt for your agent:

> "Find 10 AI engineer jobs at YC startups, include full company details, and tell me which ones are remote with salary ranges."

### FAQ

**Which proxy should I use?** The default Apify residential US proxy works out of the box. Switch countries only if you need a different market view.

**How does the free trial work?** Free-plan runs return 2 results with an upgrade note and exit cleanly. Paid plans get the full requested volume.

**How fresh is the data?** Every run reads the live board and live profiles — listings, batches, and open-roles counts reflect the site at collection time.

**Why did a run export fewer rows than my cap?** Caps are upper bounds per role view: keyword filtering, the remote-only filter, and already-seen deduplication can all yield fewer rows — and each role view only carries the latest ~30 listings. Add more roles to widen the pool. Errors for skipped items are listed in the run summary.

# Actor input Schema

## `enableJobs` (type: `boolean`):

Search live Work at a Startup listings by keyword and role. Returns fast cards: title, company, batch, location, salary when shown, and posting age. On by default.

## `jobKeywords` (type: `array`):

Filter board cards by text, e.g. "AI engineer", "product designer", "sales". Every word must appear somewhere in the card (title, role, tagline, company). Empty = browse the latest listings. Stored on each row as context.

## `jobRoles` (type: `array`):

Board roles to collect, one view per role. Valid values: all, software-engineer, designer, product-manager, data-scientist, data-analyst, devops-engineer, marketing, sales, operations, finance, legal, recruiting, customer-support, science.

## `feedMaxJobs` (type: `integer`):

Cap the number of jobs collected per role board view (after keyword filtering). Each role runs its own view, so total jobs can reach this cap times the number of roles. This is the main cost lever for jobs. 0 = no cap.

## `feedRemoteOnly` (type: `boolean`):

Keep only job rows marked remote. Off by default.

## `enableLeadDetails` (type: `boolean`):

Enrich each row in place — full posting text, visa and experience notes for jobs; founders, open roles, and website/social links for companies. Every row is still exported even when details are unavailable (nothing is dropped). Adds a little extra time per record.

## `enableCompanies` (type: `boolean`):

Collect YC startup company profiles: batch, industry, location, team size, founders, open roles, and website/social links. Companies are discovered from this run's job listings. On by default.

## `companyKeywords` (type: `array`):

Labels stored on every company row as context (e.g. "AI", "fintech"). Companies are discovered from this run's job listings. Empty = no extra labels.

## `feedMaxCompanies` (type: `integer`):

Cap the number of company rows for this run. This is the main cost lever for companies. 0 = no cap.

## `enableScrapeByUrl` (type: `boolean`):

Collect specific postings and profiles from the URLs below as their own rows with full details. Off by default — turn on and add URLs.

## `jobUrls` (type: `array`):

Job posting URLs to collect (only used when Scrape by URL is enabled). Example: https://www.workatastartup.com/jobs/103090

## `companyUrls` (type: `array`):

Company profile URLs to collect (only used when Scrape by URL is enabled). Example: https://www.workatastartup.com/companies/parameter

## `webhookUrl` (type: `string`):

Optional. Every record is always saved to the run's dataset — this webhook is an ADDITIONAL real-time push. When set, each new record is also delivered to this URL (CRM, Slack incoming webhook, Zapier, Make, Google Sheets).

## `webhookFormat` (type: `string`):

Payload format for the webhook push: raw JSON record, or a Slack-friendly message.

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

Apify residential proxy (US) is enabled by default for reliable collection. Change here only if you need a different country or custom proxy URLs.

## Actor input object example

```json
{
  "enableJobs": true,
  "jobKeywords": [
    "AI engineer"
  ],
  "jobRoles": [
    "all"
  ],
  "feedMaxJobs": 10,
  "feedRemoteOnly": false,
  "enableLeadDetails": false,
  "enableCompanies": true,
  "companyKeywords": [],
  "feedMaxCompanies": 10,
  "enableScrapeByUrl": false,
  "jobUrls": [],
  "companyUrls": [],
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Complete dataset with every field from all enabled features in this run.

## `companies` (type: `string`):

Startup company rows with founders, open roles, and contact links.

## `jobs` (type: `string`):

Job rows from the live startup jobs board.

## `runSummary` (type: `string`):

Per-run metadata: enabled features, exported record count, non-fatal errors, spending-limit status, and the paywall object (detected, isPaying, pricingTier, blocked, limited).

# 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 = {
    "enableJobs": true,
    "jobKeywords": [
        "AI engineer"
    ],
    "jobRoles": [
        "all"
    ],
    "feedMaxJobs": 10,
    "feedRemoteOnly": false,
    "enableLeadDetails": false,
    "enableCompanies": true,
    "companyKeywords": [],
    "feedMaxCompanies": 10,
    "enableScrapeByUrl": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/work-at-a-startup-real-time-data-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 = {
    "enableJobs": True,
    "jobKeywords": ["AI engineer"],
    "jobRoles": ["all"],
    "feedMaxJobs": 10,
    "feedRemoteOnly": False,
    "enableLeadDetails": False,
    "enableCompanies": True,
    "companyKeywords": [],
    "feedMaxCompanies": 10,
    "enableScrapeByUrl": False,
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/work-at-a-startup-real-time-data-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 '{
  "enableJobs": true,
  "jobKeywords": [
    "AI engineer"
  ],
  "jobRoles": [
    "all"
  ],
  "feedMaxJobs": 10,
  "feedRemoteOnly": false,
  "enableLeadDetails": false,
  "enableCompanies": true,
  "companyKeywords": [],
  "feedMaxCompanies": 10,
  "enableScrapeByUrl": false
}' |
apify call b2b_leads/work-at-a-startup-real-time-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_leads/work-at-a-startup-real-time-data-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/jDGfJKyXhmf6iTuxE/builds/L3FGYRFutzXt12dOf/openapi.json