# Built In Jobs Scraper — Tech & Startup Jobs with Salaries (`fabrikit/builtin-jobs-scraper`) Actor

Scrape builtin.com tech and startup jobs in the US and abroad by keyword, city, remote/hybrid, category, experience, industry and company size. Get company, salary range, top skills, AI summary and exact post time; optional full description and benefits. No login.

- **URL**: https://apify.com/fabrikit/builtin-jobs-scraper.md
- **Developed by:** [Fabrikit](https://apify.com/fabrikit) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 job scrapeds

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

## Built In Jobs Scraper — Tech & Startup Jobs with Salaries

Built In Jobs Scraper extracts tech and startup job listings from builtin.com: the US job board of venture-backed startups and tech employers, plus its international boards (Germany, India, Brazil, Israel, Italy and more). Search by keyword and city, state or country, narrow the results with the same filters the site offers (fully remote / hybrid / on-site, job category and sub-category, experience level, company industry, company size, posting date, skills), and download a flat dataset as JSON, CSV or Excel. No account, cookie or API key needed.

You pay per job saved. Full job pages are an optional add-on, charged per job enriched.

### What each record contains

**Board data (every job, event `job-result`)**

- `jobId`, `url`, `title`
- `company`, `companySlug`, `companyUrl` (the company's Built In profile), `companyLogo`
- `location` plus the full `locations` list and `locationCount`. Jobs posted for 20 places come back with all 20, not just a "20 Locations" label.
- `workplaceType` as shown on Built In ("Remote", "Hybrid", "In-Office", "Remote or Hybrid"…), with `isRemote` and `isHybrid` flags
- `experienceLevel` (Internship, Entry level, Junior, Mid level, Senior level, Expert/Leader)
- `salaryText` as posted ("130K-150K Annually", "22-32 Hourly"), parsed into `salaryMin`, `salaryMax` and `salaryPeriod`. `salaryCurrency` is set to USD only when every location is in the US; otherwise it stays empty unless you turn on details.
- `easyApply`, `industries` (company industries), `topSkills`, and Built In's short AI `summary` of the role
- `postedAt`: exact UTC timestamp. The site only shows "Yesterday" or "Reposted 3 Days Ago"; that text is kept in `postedText`, along with `reposted` and `featured` flags.
- `searchKeyword`, `searchLocation`, `searchUrl`, `page`, `positionOnPage`, `scrapedAt`

**Job page add-on (`includeDetails: true`, event `job-details`)**

- `description` (plain text) and `descriptionHtml`
- Structured salary from the job's schema data: `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`
- `employmentType`, `jobLocationType`, `remoteEligibleCountries`, `hiringRemotelyIn`, `datePosted`, `validThrough`
- `benefits`: the employer's perks list, often 20–50 items such as 401(K) matching, parental leave or learning stipend
- `requirements`: the "Skills Required" bullet list
- `earlyApplicant`
- Company facts: `companyHeadquarters`, `companyEmployees`, `companyFoundedYear`

The Actor never collects recruiter or poster data. E-mail addresses, phone numbers, personal profile links and named contacts are removed from summaries, requirements and descriptions.

### Use cases

- **Startup hiring signals for sales and VC research:** which companies in fintech, healthtech or AI are hiring, for which roles and in which cities. Company size and industry are filters, not just fields.
- **Salary benchmarks:** most US postings on Built In carry a pay range because of state pay-transparency laws. Parsed min/max values go straight into a pivot table.
- **Remote job feeds and newsletters:** fully remote roles by category, refreshed daily with `postedWithin: "1"`.
- **Skills demand analysis:** count `topSkills` across thousands of postings per category or metro.
- **Recruiting and career tools:** alerts for new senior or early-applicant roles at companies of a given size.

### How to use

1. Type one or more **keywords**, or leave the field empty and pick a category instead.
2. Optionally add **locations**. Each one is resolved with Built In's own location service ("Austin, TX", "Colorado", "Germany", "Bangalore"). With no location, the Actor searches the **country** field (default `USA`).
3. Add filters, set `maxItems`, and turn on `includeDetails` if you need descriptions, benefits and the structured salary.

Hybrid engineering roles around Austin posted in the last month:

```json
{
  "keywords": ["software engineer"],
  "locations": ["Austin, TX"],
  "searchRadiusMiles": "25",
  "category": "engineering",
  "workplaceTypes": ["hybrid"],
  "postedWithin": "30",
  "maxItems": 200
}
```

Senior remote data roles at fintech startups with 51–500 people, including job pages:

```json
{
  "category": "data-analytics",
  "subcategories": ["Data Engineering"],
  "workplaceTypes": ["remote"],
  "experienceLevels": ["senior"],
  "industries": ["Fintech"],
  "companySizes": ["51-200", "201-500"],
  "includeDetails": true,
  "maxItems": 100
}
```

A board URL you already filtered on builtin.com, followed page by page:

```json
{
  "searchUrls": ["https://builtin.com/jobs/remote/data-analytics/data-engineering"],
  "maxItems": 500
}
```

### Output example

A real record from a test run (21 Oct 2026). The description and the lists are shortened here.

```json
{
  "jobId": "11777981",
  "url": "https://builtin.com/job/data-engineer/11777981",
  "title": "Data Engineer",
  "company": "tastytrade/ tastylive/ tastyfx/ tastycrypto",
  "companySlug": "ig-tasty",
  "companyUrl": "https://builtin.com/company/ig-tasty",
  "location": "Chicago, IL, USA",
  "locations": ["Chicago, IL, USA"],
  "locationCount": 1,
  "workplaceType": "Hybrid",
  "isRemote": false,
  "isHybrid": true,
  "experienceLevel": "Mid level",
  "salaryText": "130K-150K Annually",
  "salaryMin": 130000,
  "salaryMax": 150000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "easyApply": true,
  "industries": ["Fintech", "News + Entertainment", "Software", "Financial Services"],
  "topSkills": ["Apache Airflow", "AWS", "Dbt", "Kubernetes", "Python", "Snowflake", "SQL", "Tableau"],
  "summary": "Designs and maintains scalable data pipelines and platform architecture using Python, dbt, Airflow, and Snowflake. ...",
  "postedAt": "2026-10-20T20:53:41Z",
  "postedText": "Yesterday",
  "reposted": false,
  "featured": false,
  "searchKeyword": "data engineer",
  "searchLocation": "USA",
  "page": 1,
  "positionOnPage": 2,
  "description": "Company Name: tastytrade\n\nRole: Data Engineer\n\nLocation: Chicago, IL (Hybrid, 3 days/week) ...",
  "employmentType": "Full-time",
  "remoteEligibleCountries": ["USA"],
  "datePosted": "2026-10-20",
  "validThrough": "2026-11-19T20:53:41.000Z",
  "benefits": ["Offers 401(K)", "Provides 401(K) matching", "Offers pet insurance", "..."],
  "requirements": ["2-5 years of professional data engineering experience", "Production experience with dbt", "..."],
  "earlyApplicant": false,
  "companyHeadquarters": "Chicago, IL",
  "companyEmployees": 265,
  "companyFoundedYear": 2011,
  "scrapedAt": "2026-10-21T01:23:12.759Z"
}
```

Without `includeDetails` the record ends at `positionOnPage` plus `scrapedAt`.

### Pricing

| Event | When it is charged |
|---|---|
| `job-result` | Each job saved to the dataset (board data) |
| `job-details` | Each job enriched with its job page, only when `includeDetails` is on |

You pay per job saved. Duplicates (the same job found by two keywords) are dropped before charging, `maxItems` is exact, and the run stops cleanly at your spending limit. See the Pricing tab for current prices; paid Apify plans get lower rates.

### Compared with other Built In scrapers

This Actor returns every location of multi-city jobs, exact UTC post times, the company-size and industry filters, and company facts. Like any scraper, it covers only what Built In shows publicly. Application links behind Built In's apply flow are not collected.

Need the same flat record for Dice.com too? This Actor is built on our [Dice Jobs Scraper](https://apify.com/fabrikit/dice-jobs-scraper) and shares its field names (`salaryMin` / `salaryMax` / `salaryCurrency` / `salaryPeriod`, ISO `postedAt`, `url`), so the two datasets can be appended into one US tech-jobs sheet.

### Integrations

Schedule daily runs and push new jobs to Google Sheets, Airtable, Slack or a webhook, or connect the Actor to n8n, Make or Zapier. You can start runs and read datasets through the Apify API. AI agents can call the Actor as a tool through the Apify MCP server, for example: "find remote senior data jobs at fintech startups posted this week".

### FAQ

**Is scraping Built In legal?** The Actor reads job ads that Built In publishes openly, without logging in, and keeps no personal data. Check that your use fits Built In's terms and the privacy laws that apply to you. This Actor is independent and not endorsed by Built In.

**Do I need a proxy?** The default Apify proxy is expected to work. If Built In starts refusing requests, the Actor switches to RESIDENTIAL proxies on its own. `SUMMARY` in the key-value store shows which route was used.

**How many jobs can one search return?** Built In paginates up to 1,000 pages. Use several keywords, locations or filters for very large pulls; results are de-duplicated across searches.

**Why are some salaries without currency?** Card salaries have no currency sign. The Actor only assumes USD when all locations are in the US. Job pages (`includeDetails`) add the currency when the employer published structured pay data.

**What happens with an unknown filter value?** Built In silently ignores unknown values, so the Actor checks categories, sub-categories and industries against the site's own lists and stops with the valid options. Unknown locations are skipped with a warning.

### Changelog

- **0.1** (October 2026): first release. Keyword, location and country search, every board filter, pasted board URLs, exact `maxItems`, de-duplication, optional job pages (description, structured salary, benefits, requirements, company facts), automatic RESIDENTIAL fallback, contact redaction.

***

### En español

**Built In Jobs Scraper** extrae ofertas de empleo de startups y empresas tecnológicas publicadas en builtin.com, en Estados Unidos y en sus bolsas internacionales. Busca por palabra clave y ciudad, estado o país, y filtra por remoto/híbrido/presencial, categoría, nivel de experiencia, industria, tamaño de empresa, fecha y skills. Cada registro trae empresa, ubicaciones, rango salarial, skills, resumen y fecha exacta de publicación. Con `includeDetails` suma la descripción completa, el salario estructurado con moneda, los beneficios y los datos de la empresa. Consulta la pestaña Pricing para ver los precios actuales; los planes de pago de Apify tienen tarifas más bajas. No guarda datos de reclutadores.

# Actor input Schema

## `keywords` (type: `array`):

Job titles, skills or technologies, one search per entry (for example: data engineer, product manager, kubernetes). Each keyword is combined with each location. Leave empty to list the newest jobs that match the other filters.

## `locations` (type: `array`):

Cities, US states or countries, one search per entry (for example: Austin, TX; New York; Colorado; Germany; Bangalore). Each one is looked up with Built In's own location service. Leave empty to search the whole country set below.

## `country` (type: `string`):

3-letter ISO code of the country to search when the Locations list is empty: USA (default), CAN, GBR, DEU, IND, BRA, ISR... Built In localises searches by visitor IP otherwise, so the Actor always sends a country.

## `searchRadiusMiles` (type: `string`):

Distance around each city location. Ignored for states and countries.

## `workplaceTypes` (type: `array`):

Fully remote, hybrid and/or on-site. Leave empty for all.

## `category` (type: `string`):

One Built In job category. Leave on 'Any category' to search all.

## `subcategories` (type: `array`):

Optional sub-categories of the chosen category, by name or URL alias (for example with Data & Analytics: Data Engineering, Business Intelligence (BI); with Engineering: Software Engineering, DevOps / Platform Engineering). The run stops with the full list if a value is unknown.

## `experienceLevels` (type: `array`):

Only these experience levels. Leave empty for all.

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

Only companies in these Built In industries, by name or alias (for example: Fintech, Healthtech, Artificial Intelligence, Cybersecurity, eCommerce). The run stops with the full list if a value is unknown.

## `companySizes` (type: `array`):

Only companies of these sizes. Leave empty for all.

## `postedWithin` (type: `string`):

Only jobs posted or refreshed in this period.

## `earlyApplicantOnly` (type: `boolean`):

Only jobs Built In flags as 'Be an Early Applicant' (recently posted, few applicants so far).

## `skills` (type: `array`):

Only jobs that list these skills (for example: Python, SQL, AWS). Built In applies this filter only together with a keyword or a category.

## `searchUrls` (type: `array`):

Optional: job board URLs copied from builtin.com with your filters already set (https://builtin.com/jobs/remote/data-analytics/data-engineering?...). Pages are followed automatically. URLs without a location get the country above.

## `includeDetails` (type: `boolean`):

Open each job page to add the full description (plain text and HTML), structured salary with currency, employment type, remote-eligible countries, posting and expiry dates, benefits, requirements, the early-applicant flag and company HQ, headcount and founding year. One extra request per job, charged as the 'job-details' event. Off = fastest and cheapest.

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

Stop after this many unique jobs across all searches (exact; duplicates are removed before counting).

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

Apify Proxy settings. The Actor starts on the configured proxy (datacenter by default) and switches to Apify RESIDENTIAL automatically if Built In starts blocking.

## Actor input object example

```json
{
  "keywords": [
    "data engineer"
  ],
  "country": "USA",
  "searchRadiusMiles": "default",
  "category": "any",
  "postedWithin": "any",
  "earlyApplicantOnly": false,
  "includeDetails": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All jobs collected during the run

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

Searches, pages, resolved locations, ignored filters and network stats of the run

# 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": [
        "data engineer"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/builtin-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 = {
    "keywords": ["data engineer"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/builtin-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 '{
  "keywords": [
    "data engineer"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fabrikit/builtin-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fabrikit/builtin-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/UhStxGcrmrRslF312/builds/WUjT8GIb3pmhhIr9b/openapi.json