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

Scrape Built In (builtin.com) US tech jobs: title, company, salary, remote or hybrid, seniority, top skills, full description and dates, plus company profiles with employees, offices and open roles. Search by category, skill, role, city or remote. Export to JSON, CSV or Excel, or via API.

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

## Pricing

from $1.00 / 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.

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

Scrape tech jobs from **[Built In](https://builtin.com)** (builtin.com), the US job board for software engineering, data, AI,
product, design, marketing, sales and operations roles at tech companies and startups. This Built In jobs scraper reads
Built In's job lists by **category**, **subcategory**, **skill or role**, **Remote**, **Hybrid** or **city**, and gives every job
with its **company**, **salary as Built In shows it**, **work mode**, **experience level**, **industries**, **top skills** and
Built In's summary — and, from each job's own page, the **full description**, **posting and expiry dates**, **employment type**,
**exact salary and currency**, **every location with coordinates**, **benefits** and **required skills**.

It can also add a **company profile row** for each company: **total employees**, **product + tech employees**, **offices**,
**year founded**, **website**, **industries**, **workplace** (remote, hybrid, on site) and **open jobs by department** — the data
recruiters and sales teams use to read hiring as a buying signal.

No login, no browser, no proxy. Pay only for the rows you get.

### What you can do with this Built In scraper

- **Recruiting and sourcing**: every open engineering, data or product role of US tech companies, with salary ranges and
  seniority, to find who is hiring for what.
- **Sales prospecting on hiring signals**: companies hiring now, with their size, product + tech headcount, offices, website
  and how many jobs each department has open.
- **Salary benchmarking**: published pay by role, level, city and work mode — US pay-transparency laws put a range on most
  postings.
- **Job alerts and feeds**: schedule it daily with **Posted within** and **Only new jobs** to receive just the jobs posted
  since the last run.
- **Labour-market research**: remote vs hybrid vs office, skills in demand, which industries are hiring.

### Input

| Field | What it does |
|---|---|
| **Keywords (skills or roles)** | `Python`, `Java`, `DevOps`, `Data Science`, `Backend Developer`, `Product Manager`, `Account Executive`… A keyword Built In has a page of its own for (about 300 skills and roles) is read through that page; any other keyword (`Kubernetes`, `Rust`) is looked for in the job titles and top skills of the categories you choose, or of every job. |
| **Categories** | Built In's 16 categories: Engineering, AI & Machine Learning, Data & Analytics, Design, Product Management, Program & Project Management, Marketing, Sales, Customer Success, Operations & Support, Cybersecurity, Finance, HR & Recruiting, Legal, Consulting, Supply Chain. |
| **Subcategories** | The 108 narrower lists of Built In's filter panel: Software Engineering, DevOps / Platform Engineering, Data Engineering, Machine Learning Engineering, Product Design, Account Executive… |
| **Locations** | `Remote`, `Hybrid`, or a US city or state. The 71 metro areas Built In keeps lists for (Atlanta, Dallas, Houston, Miami, Philadelphia, Phoenix, Washington DC…) are read through those lists; any other place (New York, San Francisco, Seattle, Boston, Chicago, Austin, Los Angeles, Denver, Texas…) is kept from the national list by each job's locations. Each keyword or category is searched in each location. |
| **Built In job list links** | Any page of Built In's job board, read as it is. |
| **Built In company links** | Company profiles (`https://builtin.com/company/block-inc`): one company row each. |
| **Posted within** | Past 24 hours, 3 days, week or month, through Built In's own New Jobs filter. |
| **Work modes** | Remote, hybrid, in-office, in-office or remote, remote or hybrid. |
| **Experience levels** | Internship, entry level, junior, mid level, senior, expert / leader. |
| **Minimum yearly salary** | Jobs whose published pay reaches it (hourly pay counted at 2,080 hours a year). |
| **Only jobs with a published salary** | Leaves out jobs whose card shows no salary. |
| **Include job details** | On by default: opens each job's page (charged as job-with-details). |
| **Include company profiles** | Adds one row per company of the jobs delivered, once per run. |
| **Max jobs per search** | 100 by default; 0 for every job the list shows. |
| **Only new jobs since the last run** | Monitor mode for scheduled runs: jobs delivered before are skipped and not charged. |

Example — remote software engineering jobs and Python jobs in New York, posted this week, senior level, with company
profiles:

```json
{
    "subcategories": ["engineering/software-engineering"],
    "keywords": ["Python"],
    "locations": ["Remote", "New York"],
    "postedWithin": "7",
    "seniorities": ["senior", "expert_leader"],
    "includeCompanies": true,
    "maxJobsPerSearch": 200
}
```

### Output: Built In jobs data

One row per job (description shortened):

```json
{
    "rowType": "job",
    "status": "ok",
    "search": "Python · Remote",
    "searchUrl": "https://builtin.com/jobs/remote/dev-engineering/python",
    "position": 1,
    "jobId": "11843249",
    "url": "https://builtin.com/job/senior-software-engineer-react-python/11843249",
    "title": "Senior Software Engineer - React & Python",
    "companyName": "Nearform",
    "companyUrl": "https://builtin.com/company/nearform",
    "companyLogo": "https://cdn.builtin.com/cdn-cgi/image/f=auto,fit=scale-down,w=128,h=128/sites/www.builtin.com/files/2024-03/nearform_logo.JPEG",
    "postedAgo": "2 Days Ago",
    "reposted": false,
    "postedAt": "2026-10-23T07:18:58.507Z",
    "workMode": "remote",
    "locations": ["United States"],
    "salaryText": "150K-180K Annually",
    "salaryMin": 150000,
    "salaryMax": 180000,
    "salaryPeriod": "year",
    "seniority": "senior",
    "industries": ["Information Technology", "Consulting"],
    "summary": "Designs and builds scalable applications using React and Python, contributing to component development…",
    "topSkills": ["Git", "JavaScript", "Python", "React", "Typescript", "Unit Testing"],
    "details": {
        "description": "This is a full-time, permanent opportunity for candidates based in the United States…",
        "descriptionHtml": "<p>This is a&nbsp;<strong>full-time, permanent opportunity</strong>…",
        "datePosted": "2026-10-23",
        "validThrough": "2026-11-22T16:46:36.000Z",
        "employmentTypes": ["FULL_TIME"],
        "remoteAllowed": true,
        "applicantCountries": ["USA"],
        "jobLocations": [{ "city": null, "region": null, "country": "USA", "latitude": null, "longitude": null }],
        "baseSalaryMin": 150000,
        "baseSalaryMax": 180000,
        "baseSalaryCurrency": "USD",
        "baseSalaryPeriod": "YEAR",
        "benefits": [],
        "skillsRequired": ["At least 8 years of commercial experience", "Deep knowledge and experience with JavaScript or TypeScript, including React"],
        "companyEmployees": 350,
        "companyFoundedYear": 2011,
        "companyHeadquarters": "Tramore"
    },
    "scrapedAt": "2026-10-25T07:18:59.403Z"
}
```

With **Include company profiles**, one row per company:

```json
{
    "rowType": "company",
    "status": "ok",
    "companyId": "105938",
    "name": "Block",
    "url": "https://builtin.com/company/block-inc",
    "website": "https://block.xyz",
    "industries": ["Blockchain", "eCommerce", "Fintech", "Payments", "Software", "Financial Services", "Cryptocurrency"],
    "foundedYear": 2009,
    "totalEmployees": 12000,
    "productTechEmployees": 8000,
    "headquarters": "Oakland",
    "city": "Oakland",
    "region": "CA",
    "country": "US",
    "totalOffices": 23,
    "offices": ["Oakland, California, USA", "Tech Central Sydney", "Atlanta, Georgia, USA"],
    "workplace": "Remote Workspace",
    "typicalTimeOnSite": null,
    "openJobs": 208,
    "openJobsByDepartment": [
        { "department": "Sales", "openJobs": 99, "openJobsCapped": true },
        { "department": "Engineering", "openJobs": 26, "openJobsCapped": false }
    ],
    "affiliatedProfiles": [{ "name": "Square", "url": "https://builtin.com/company/square" }]
}
```

A search that finds nothing, a link that cannot be read, or a page Built In's robots.txt closes gives one **free** row with
`rowType: "status"` and the reason (`no_results`, `not_found`, `invalid`, `disallowed`, `blocked`).

### Built In job fields

| Field | Meaning |
|---|---|
| `jobId`, `url`, `title` | Built In's job id, the job's page and title |
| `companyName`, `companyUrl`, `companyLogo` | The employer and its Built In profile |
| `postedAgo`, `reposted`, `postedAt` | The card's label ("Reposted 2 Days Ago") and the instant worked out from it |
| `workMode` | `remote`, `hybrid`, `in_office`, `in_office_or_remote`, `remote_or_hybrid` |
| `locations` | Every location the job lists |
| `salaryText`, `salaryMin`, `salaryMax`, `salaryPeriod` | The salary as the card shows it, and its numbers (`year`, `month`, `hour`…) |
| `seniority` | `internship`, `entry_level`, `junior`, `mid_level`, `senior`, `expert_leader`, `not_specified` |
| `industries`, `summary`, `topSkills` | The company's industries, Built In's summary and the job's top skills |
| `search`, `searchUrl`, `position` | Which search found the job, the list it read and the place in it |
| `details.description`, `details.descriptionHtml` | The full job description, as text and as HTML |
| `details.datePosted`, `details.validThrough` | When the job was posted (or reposted) and until when Built In lists it |
| `details.employmentTypes`, `details.remoteAllowed`, `details.applicantCountries` | Full time, part time, contract…; remote allowed; countries applicants may live in |
| `details.jobLocations` | City, region, country and coordinates of each location |
| `details.baseSalaryMin`, `…Max`, `…Currency`, `…Period` | The exact published range, when the posting has one |
| `details.benefits`, `details.skillsRequired` | The company's benefits and the job's required skills |
| `details.companyEmployees`, `details.companyFoundedYear`, `details.companyHeadquarters` | The company box of the job page |

Company rows add `companyId`, `website`, `logo`, `description`, `foundedYear`, `totalEmployees`, `productTechEmployees`,
`headquarters`, `street`, `city`, `region`, `postalCode`, `country`, `totalOffices`, `offices`, `workplace`,
`typicalTimeOnSite`, `openJobs`, `openJobsByDepartment` and `affiliatedProfiles`. A fact the profile does not show is
`null`: many large companies publish no product + tech headcount.

### Pricing

| Event | Price |
|---|---|
| `job` — a job as its list card shows it | US$0.001 |
| `job-with-details` — a job read with its own page | US$0.002 |
| `company` — a company profile | US$0.002 |
| Status rows (nothing found, closed page, bad link) | free |

Set a maximum cost per run in Apify and the Actor stops at what it can pay for.

### Limits

- **Built In's keyword search is closed to crawlers** by its robots.txt (`/jobs*?search=`), so this Actor never uses it: a
  keyword is read through Built In's own page for it, or matched on this side against the job titles and top skills of the
  lists you choose. The Actor obeys robots.txt on every request; a pasted link it closes gives a free row.
- **New York City, San Francisco, Seattle, Boston, Chicago, Austin, Los Angeles and Colorado** have lists of their own on
  Built In, but robots.txt closes them, so jobs there are kept from the national lists by their locations.
- **Built In localizes some lists by the visitor's location.** The Actor runs from Apify's US servers, so those lists show US
  jobs; the run's summary names the place each list showed jobs for.
- Built In's lists stop at 1,000 pages, and big lists are shown ranked rather than newest first; use **Posted within** for
  the newest jobs.
- `postedAt` is as precise as Built In's label (hours, days, then months); `details.datePosted` gives the date.
- One request a second, one IP, no proxy: a run of 100 jobs with details takes about two minutes.

### Is it legal to scrape Built In?

This Actor reads only public pages anyone can open without an account, follows Built In's robots.txt on every request, and
asks at a gentle pace. It collects job postings and company profiles, not personal data about applicants. Built In's terms
restrict automated access; you are responsible for how you use the data and for complying with the laws and terms that
apply to you. This Actor is not affiliated with, endorsed by, or sponsored by Built In.

# Actor input Schema

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

Skills or roles as people write them, e.g. <code>Python</code>, <code>Java</code>, <code>DevOps</code>, <code>Data Science</code>, <code>Backend Developer</code>, <code>Product Manager</code>, <code>Account Executive</code>. A keyword Built In has a page of its own for (about 300 skills and roles) is read through that page; any other keyword is looked for in the job titles and top skills of the categories below (or of every job). Built In's free-text search is closed to crawlers by its robots.txt, so it is never used.

## `categories` (type: `array`):

Built In's job categories, read whole when no keyword is given, and the place where a keyword without a page of its own is looked for.

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

Narrower lists inside a category, as Built In's filter panel offers them.

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

<code>Remote</code>, <code>Hybrid</code>, or a US city or state. The 71 metro areas Built In keeps lists for (Atlanta, Dallas, Houston, Miami, Philadelphia, Phoenix, Washington DC…) are read through those lists; any other place (New York, San Francisco, Seattle, Boston, Chicago, Austin, Los Angeles, Denver, or a state such as Texas) is kept from the national list by each job's locations. Each keyword or category is searched in each location. Leave empty for the whole US.

## `jobListUrls` (type: `array`):

Pages of Built In's job board, e.g. <code>https://builtin.com/jobs/remote/dev-engineering</code> or <code>https://builtin.com/jobs/atlanta/engineering</code>, each read as it is (its page number dropped). Links robots.txt closes, such as keyword searches (<code>?search=</code>), give a free row and are not read. Job pages are not taken.

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

Company profiles, e.g. <code>https://builtin.com/company/block-inc</code>: one company row each (employees, product and tech employees, offices, founding year, website, industries, open jobs by department).

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

Only jobs posted or reposted in the last days, through Built In's own New Jobs filter. Combine with a schedule and Only new jobs for a daily feed.

## `workModes` (type: `array`):

Keep only jobs whose card shows one of these work modes. Empty keeps every mode.

## `seniorities` (type: `array`):

Keep only jobs at these levels, as Built In labels them.

## `minYearlySalary` (type: `integer`):

Only jobs whose published pay reaches this much a year (hourly pay counted at 2,080 hours, monthly times twelve). Jobs without a published salary are left out when this is set.

## `onlyWithSalary` (type: `boolean`):

Leave out jobs whose card shows no salary.

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

Open each job's page for the full description, posting and expiry dates, employment type, exact salary and currency, every location with coordinates, benefits, required skills and the company's size. Charged as job-with-details instead of job.

## `includeCompanies` (type: `boolean`):

Add one row per company of the jobs delivered (once per run): total and product + tech employees, offices, founding year, website, industries, workplace and open jobs by department. Charged as company.

## `maxJobsPerSearch` (type: `integer`):

Stop each search after this many jobs. 0 means every job the list shows.

## `onlyNewJobs` (type: `boolean`):

Deliver, and charge, only jobs that an earlier run with the same searches and filters has not delivered. Made for scheduled runs.

## Actor input object example

```json
{
  "categories": [],
  "subcategories": [
    "engineering/software-engineering"
  ],
  "locations": [
    "Remote"
  ],
  "jobListUrls": [],
  "companyUrls": [],
  "postedWithin": "any",
  "workModes": [],
  "seniorities": [],
  "onlyWithSalary": false,
  "includeDetails": true,
  "includeCompanies": false,
  "maxJobsPerSearch": 20,
  "onlyNewJobs": false
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "subcategories": [
        "engineering/software-engineering"
    ],
    "locations": [
        "Remote"
    ],
    "maxJobsPerSearch": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("steadyscrape/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 = {
    "subcategories": ["engineering/software-engineering"],
    "locations": ["Remote"],
    "maxJobsPerSearch": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("steadyscrape/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 '{
  "subcategories": [
    "engineering/software-engineering"
  ],
  "locations": [
    "Remote"
  ],
  "maxJobsPerSearch": 20
}' |
apify call steadyscrape/builtin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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