# Built In Jobs Scraper (`deriverge/builtin-jobs-scraper`) Actor

Tech and startup jobs from Built In with the pay range as numbers, seniority, top skills, company industries and remote, hybrid or office workplace. Filter by keywords, Built In category, country, state or city, and add full descriptions when you need them.

- **URL**: https://apify.com/deriverge/builtin-jobs-scraper.md
- **Developed by:** [deriverge s.r.o.](https://apify.com/deriverge) (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.25 / 1,000 jobs

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

Built In (builtin.com) lists jobs at tech companies and startups, mostly in the United States. This actor returns one row per job: title, company with its industries, locations, workplace type, seniority, the pay range as numbers, top skills, a short summary and, on request, the full description. The form starts with `data engineer` in the Data: data engineering category; click **Start** for 20 jobs. Built In does not let robots use its keyword search, so keywords are matched on the listings the actor reads. It costs $0.50 per 1,000 jobs on the Free plan ($0.25 on Business), and the $5 of monthly credit in Apify's Free plan covers about 10,000 jobs.

### Output fields

| Field | Description |
|---|---|
| `title`, `company`, `companyUrl` | Job title, the hiring company and its profile page on Built In, such as `https://builtin.com/company/general-motors`. |
| `industries` | Industries Built In gives the company, for example `["Automotive", "Big Data", "Software"]`. |
| `locations` | Every place the job is offered, as `Austin, TX, USA`. |
| `workplace` | `In-Office`, `Hybrid`, `Remote` or a choice such as `Remote or Hybrid` and `In-Office or Remote`. |
| `seniority` | `Entry level`, `Junior`, `Mid level`, `Senior level`, `Expert/Leader` or `Internship`. |
| `salaryText`, `salaryMin`, `salaryMax`, `salaryPeriod`, `salaryCurrency` | Pay as Built In shows it, `125K-169K Annually`, and the same as `125000`, `169000`, `yearly` and `USD`. Empty when the job shows no pay. |
| `skills` | Top skills from the job card, such as `Databricks`, `Snowflake` or `Kafka`. |
| `summary` | Built In's short summary of the role from the job card. |
| `postedText`, `postedAt` | Age as shown (`Yesterday`, `Reposted 2 Days Ago`) and the date worked out from it. With details on, `postedAt` is the posting date from the job page. |
| `validThrough`, `employmentType` | With details on: when the ad expires and `FULL_TIME`, `PART_TIME`, `CONTRACTOR` or `INTERN`. |
| `description`, `descriptionHtml` | With details on: the whole ad as plain text and as HTML. |
| `url`, `companyLogo` | The job page and the company logo. |
| `searchQuery` | The search that found the job. |

### How to scrape Built In jobs

1. Type **Keywords**, such as `data engineer`, `react` or `account executive`. A job matches when every word starts a word in its title, company, skills or industries, so `engineer` also finds `Engineering Manager`.
2. Pick a **Category** that fits the keywords, such as Data: data engineering or Engineering: Python. The actor then reads only that category: 20 data engineer jobs took 5 seconds on 11 October 2026. Without a category it reads all jobs of the location, and `python` across the United States needed 63 result pages and 93 seconds for 100 matches.
3. Choose the **Country** and, if you want, the **State or region (optional)** and **City (optional)**, written in full as Built In does: `New York`, `California`, `England`.
4. Set **Workplace** to Remote, Hybrid or In office. In office reads all jobs and keeps those whose label includes In-Office.
5. Turn on **Include full job details** for the description, expiry date and employment type, then click **Start**. Jobs appear in the **Output** tab during the run and can be downloaded as CSV, Excel or JSON.

Search links copied from builtin.com also work in **Search links from builtin.com (optional)**. A `search=` word in such a link is matched like **Keywords**. As API input, hybrid product jobs in New York City:

```json
{
  "keywords": "product manager",
  "category": "product",
  "country": "USA",
  "state": "New York",
  "city": "New York",
  "workplace": "hybrid",
  "maxItems": 200
}
```

### Example output

One job from a run on 11 October 2026, with `description` and `descriptionHtml` cut short.

```json
{
  "key": "builtin:11606231",
  "jobId": "11606231",
  "title": "Senior Data Engineer",
  "url": "https://builtin.com/job/senior-data-engineer/11606231",
  "company": "General Motors",
  "companyUrl": "https://builtin.com/company/general-motors",
  "companyLogo": "https://cdn.builtin.com/cdn-cgi/image/f=auto,fit=scale-down,w=128,h=128/sites/www.builtin.com/files/2025-06/gm_avatar_white_blue%201.png",
  "workplace": "Hybrid",
  "locations": [
    "Austin, TX, USA"
  ],
  "seniority": "Senior level",
  "industries": [
    "Automotive",
    "Big Data",
    "Information Technology",
    "Robotics",
    "Software",
    "Transportation",
    "Manufacturing"
  ],
  "salaryText": "125K-169K Annually",
  "salaryMin": 125000,
  "salaryMax": 169000,
  "salaryPeriod": "yearly",
  "salaryCurrency": "USD",
  "summary": "Design and optimize scalable cloud data warehouses, data lakes, pipelines, and Operational Data Stores for near-real-time IoT analytics. Integrate and process large datasets using Databricks, Snowflake, Flink, Spark, Kubernetes, and Iceberg. Monitor pipeline health, improve performance and cost efficiency, ensure data quality and security, and collaborate with technical and business stakeholders.",
  "skills": [
    "Apache Flink",
    "Apache Iceberg",
    "Spark",
    "AWS",
    "Ci/Cd",
    "Databricks",
    "ETL",
    "Google Cloud Platform",
    "Java",
    "Kafka",
    "Kubernetes",
    "Azure",
    "Ocpp",
    "Python",
    "Snowflake",
    "Spark Streaming",
    "SQL"
  ],
  "postedText": "Yesterday",
  "postedAt": "2026-10-10",
  "validThrough": "2026-11-09T02:49:25+00:00",
  "employmentType": "FULL_TIME",
  "description": "Description\nThis role is categorized as hybrid. This means the successful candidate is expected to report to Austin Technical Center three times per week, at minimum [or other frequency dictated by the business if more than 3 days].\nThe Role\nThe GM Energy Data Engineering team is on the lookout for a talented Data ...",
  "descriptionHtml": "<b>Description</b><br><strong> This role is categorized as hybrid. This means the successful candidate is expected to report to Austin Technical Center three times per week, at minimum [or other frequency dictated by the business if more than 3 days]. </strong>  <br><strong> The Role </strong>  <br>The GM Energy Data ...",
  "searchQuery": "\"data engineer\" [data-analytics/data-engineering] in USA",
  "scrapedAt": "2026-10-11T16:14:29.538Z"
}
```

### How much does it cost to scrape Built In jobs?

| | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| 1,000 jobs | $0.50 | $0.40 | $0.325 | $0.25 |

You pay only for the events in the table. There is no start fee, and compute time and proxies are included.

10,000 jobs cost $5.00 on the Free plan and $2.50 on Business. Jobs that do not match the keywords, the In office filter or **Exclude keywords**, repeats across searches and jobs held back by the new-only mode are not charged.

### Limits

- A search reads at most 200 result pages of 10 to 25 jobs. A run over all US jobs read 2,192 jobs in 200 pages and about 5 minutes on 11 October 2026.
- Keyword matching happens after the pages are read, so a rare keyword without a category can end with few or no jobs after 200 pages.
- The actor waits a second between result pages. If Built In answers with a verification page or HTTP 429 anyway, the run stops and keeps the jobs it has.
- Built In lets about 150 job pages be opened in a row. With **Include full job details** on, rows after that keep the card fields and the run log says how many got descriptions.
- Pay shows on most US jobs and few others: 47 of 58 US data engineer jobs had a range on 11 October 2026, and 6 of 60 in-office jobs in the United Kingdom.

### Daily alerts for new Built In jobs

Turn on **Return only jobs new since the last run**, give the run a **Watch name** such as `nyc-data` (a saved task gets one automatically) and schedule it daily. A job that came back once is skipped for 90 days.

### FAQ

#### Is it legal to scrape Built In?

The actor reads job ads that Built In shows to any visitor, and only pages its robots.txt allows: the job lists without a search word and the job pages. It collects no data about candidates and no recruiter contacts. Ad texts belong to the employers; check Built In's terms before you republish them.

#### Which countries does it cover?

Most jobs are in the United States. The form also offers Canada, the United Kingdom, India, Germany, Ireland, the Netherlands, France, Spain, Poland, the Czech Republic, Australia, Singapore, Brazil, Mexico and Israel, or Anywhere.

### Related scrapers

- [Remote Jobs Scraper](https://apify.com/deriverge/remote-jobs-scraper)
- [Dice Jobs Scraper](https://apify.com/deriverge/dice-jobs-scraper)
- [Career Site and ATS Jobs API](https://apify.com/deriverge/career-site-jobs-search)
- [Greenhouse Jobs Scraper](https://apify.com/deriverge/greenhouse-jobs-scraper)

### Support

This actor is built and maintained by deriverge s.r.o., a software company based in the Czech Republic. If a run fails or a field you need is missing, please open an issue in the **Issues** tab or write to us at info@deriverge.com. We respond in English and Czech. Runs can be scheduled in Apify Console or started from the **API** tab, which has examples for Python, JavaScript and cURL and works with Make, Zapier, n8n and the Apify MCP server. If the actor saves you time, a short review helps other people find it.

# Changelog

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

# Actor input Schema

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

Words every job must contain in its title, company, skills or industries, for example "data engineer", "react" or "sales". Built In does not let robots use its own keyword search, so the actor reads the listings and keeps the matching jobs; pick a Category as well to make this fast. Leave empty for all jobs.

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

Built In's own job category, for example Data: data engineering or Engineering: Python. The actor reads only the jobs in it, which makes a keyword search much faster.

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

Country of the jobs. Built In otherwise picks a location from the server address, so a country is always sent.

## `state` (type: `string`):

Full state or region name as Built In writes it, for example New York, California or England.

## `city` (type: `string`):

City name, for example New York, Chicago, Austin or London. Use together with the state.

## `workplace` (type: `string`):

Keep only jobs with this workplace type. In office reads all jobs and keeps those labelled In-Office.

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

Built In job list addresses, for example https://builtin.com/jobs/remote/dev-engineering/python?country=USA. A search word in the link (search=) is matched on the jobs as Keywords. Each link is its own search.

## `excludeKeywords` (type: `array`):

Drop jobs whose title or company contains any of these.

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

Opens each job for the full description (text and HTML), exact posting date, expiry date and employment type. Built In lets only about 150 job pages be opened in a row, so use it for smaller runs; the price is the same.

## `newOnly` (type: `boolean`):

Keeps a snapshot per watch name (or per saved task) and returns only jobs that were not there before. Schedule it daily for a job alert.

## `watchName` (type: `string`):

Name of the snapshot used by the new-only mode, for example "nyc-data". Runs from a saved task get one automatically.

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

Hard cap on returned jobs. Built In shows 25 jobs per page (10 in a category) and the scraper reads up to 200 pages per search.

## Actor input object example

```json
{
  "keywords": "data engineer",
  "category": "data-analytics/data-engineering",
  "country": "USA",
  "workplace": "any",
  "includeDetails": false,
  "newOnly": false,
  "maxItems": 20
}
```

# Actor output Schema

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

One row per job with company, location, employment type, salary, skills and full description.

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

Jobs matching and returned per search, dropped rows, and request counts.

# 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",
    "category": "data-analytics/data-engineering",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("deriverge/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",
    "category": "data-analytics/data-engineering",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("deriverge/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",
  "category": "data-analytics/data-engineering",
  "maxItems": 20
}' |
apify call deriverge/builtin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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