# Built In Jobs Scraper — US Tech Jobs, Salaries & Companies (`yugenox/builtin-jobs-scraper`) Actor

Scrape Built In (builtin.com) tech jobs by category, metro, work model, seniority, company size and skills: title, company, salary range, location, remote/hybrid, seniority, skills, posted date, full description, benefits, plus company size, HQ and founding year. No login.

- **URL**: https://apify.com/yugenox/builtin-jobs-scraper.md
- **Developed by:** [Yugenox Corp](https://apify.com/yugenox) (community)
- **Categories:** Jobs, Lead generation
- **Security:** Limited permissions
- **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 — US Tech Jobs, Salaries & Companies

Scrape job listings from **[Built In](https://builtin.com/jobs)** (builtin.com), the job board for US tech and startup
roles, into clean JSON, CSV or Excel. Pick Built In's own filters — category, metro area, remote / hybrid,
experience level, company size, skills, posting date — and get one row per job with the **salary range**,
**location and work model**, **seniority**, **skills**, **industries**, **posting date**, the **full job description**,
**benefits**, office addresses and the **hiring company's size, headquarters and founding year**.

No login, no cookies, no browser — fast and cheap.

### What you can do with it

- **Tech recruiting & sourcing** — pull every open Data Engineering role in Atlanta, or all senior remote Product
  Management jobs, with salary ranges, and work them in a spreadsheet or your ATS.
- **Sales prospecting with hiring signals** — find companies hiring for Sales, Cybersecurity or Engineering right
  now, with company size, HQ and founding year on every row.
- **Salary benchmarking** — Built In shows a salary range on most US jobs; compare pay by category, metro,
  seniority and company size.
- **Job-market research** — track which skills, industries and work models are in demand, week by week.
- **Job boards & newsletters** — feed fresh tech jobs (with the original Built In link) into your own product.

### How to use it

1. Choose one or more **Job categories** (e.g. *Engineering*, *Data & Analytics › Data Engineering*, *Sales*).
   Leave empty for all jobs.
2. Optionally add **Locations** (a Built In metro like *Atlanta*, *Dallas*, *Washington DC*, or any city / state such
   as *Seattle, WA*, *Texas*, *Remote*), a **Work model**, **Experience level**, **Company size**, **Posted within**,
   **Skills** or **Keywords**.
3. Set **Max jobs** and press **Start**. Each category × location is a separate search; the max is shared fairly
   between them.

You can also paste **Built In URLs**: a job (`https://builtin.com/job/…/12345`) or a job-board page with your filters
already set (`https://builtin.com/jobs/remote/data-analytics?country=USA`). A search term in a job-board URL is applied
as a keyword filter.

#### Input example

```json
{
  "categories": ["data-analytics/data-engineering", "engineering"],
  "workModels": ["remote", "hybrid"],
  "locations": ["Atlanta"],
  "seniority": ["senior"],
  "postedWithin": "7",
  "maxItems": 200,
  "includeDetails": true
}
```

| Input | What it does |
|---|---|
| Job categories | Built In's 16 categories and their sub-categories. Empty = all. |
| Work model | Remote, Hybrid, On-site. |
| Locations | Built In metro areas get their own job board; any other city, state or "Remote" is matched on each job's locations. |
| Country | United States (default) or Canada. |
| Max jobs | For the whole run. 0 = up to 10,000. |
| Include full details | On by default: reads each job's page for the full description, exact salary + currency, exact posting date, employment type, benefits, addresses and company facts. Same price on or off. |
| Experience level | Internship, Entry, Junior, Mid, Senior, Expert/Leader. |
| Company size | 1-10 up to 1,000+ employees. |
| Posted within | Past 24 hours / 3 days / week / month. |
| Skills | e.g. Python, SQL, React — best together with a category. |
| Keywords | Words that must appear in the title, company, summary, skills or industries. |
| Built In URLs | Job pages or job-board pages. |
| Max pages per search | How many job-board pages one search may read when keywords or a non-metro city leave jobs out (default 30). Searches without such filters read as many pages as Max jobs needs. |

### Output

One row per job. A real row (trimmed):

```json
{
  "jobId": "11930330",
  "title": "Safety Data Analysis Engineer - AV Operational Safety and Issue Response (GPSSC)",
  "url": "https://builtin.com/job/safety-data-analysis-engineer-av-operational-safety-and-issue-response-gpssc/11930330",
  "company": "General Motors",
  "companyUrl": "https://builtin.com/company/general-motors",
  "location": "United States",
  "locations": ["United States"],
  "workModel": "Remote or Hybrid",
  "isRemote": true,
  "seniority": "Senior level",
  "seniorityLevel": "senior",
  "salaryText": "160K-246K Annually",
  "salaryMin": 160200,
  "salaryMax": 246300,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "employmentType": "FULL_TIME",
  "postedText": "Posted Yesterday",
  "postedDate": "2026-10-28",
  "validThrough": "2026-11-27T03:02:19+00:00",
  "industries": ["Automotive", "Big Data", "Information Technology", "Robotics", "Software", "Transportation", "Manufacturing"],
  "skills": ["BigQuery", "C++", "Docker", "Kubernetes", "Python", "SQL", "Time-Series Analysis"],
  "summary": "Analyzes autonomous-vehicle telemetry, time-series signals, incidents, software releases, and operational data …",
  "description": "Description\nAt General Motors, our product teams are redefining mobility. …",
  "benefits": ["Offers 401(K)", "Provides 401(K) matching", "Offers disability insurance", "…"],
  "remoteEligibility": ["USA"],
  "easyApply": false,
  "companyTagline": "We make amazing products people love, for every journey.",
  "companyHq": "Detroit, MI",
  "companyEmployees": 165000,
  "companyFoundedYear": 1908,
  "category": "Data & Analytics",
  "searchQuery": "Data & Analytics · remote",
  "page": 1,
  "position": 4,
  "detailsScraped": true,
  "scrapedAt": "2026-10-29T18:47:21.003Z"
}
```

Every row has every field (empty ones are `null` or `[]`), so CSV / Excel exports keep the same columns.
The dataset has two views: **Overview** (job, company, location, salary, posted, link) and **Details**
(skills, industries, company facts, benefits, description).

### Pricing

Pay per event — you only pay for what you get:

| Event | Price |
|---|---|
| Job saved | **$1.00 per 1,000 jobs** ($0.001 each) — with or without full details |
| Job-board page that gave no new matching job | $0.10 per 1,000 pages ($0.0001 each) |
| Run start | $0.002 per run |

A run of 1,000 jobs with full details costs about **$1.00**. Duplicates (the same job found by two of your searches)
and jobs your filters leave out are never charged. If Built In has nothing for a search you pay only the run start and
the one page that was checked. Your **maximum charge per run** setting is always respected.

### Tips

- **Metro areas are the fastest location filter.** Built In has its own job board for Atlanta, Baltimore, Birmingham,
  Charlotte, Columbus, Dallas-Fort Worth, Detroit, Houston, Jacksonville, Kansas City, Las Vegas, Miami,
  Minneapolis-Saint Paul, Nashville, Orlando, Philadelphia, Phoenix, Pittsburgh, Portland, Raleigh-Durham, Salt Lake
  City, San Antonio, San Diego, St. Louis, Tampa Bay and Washington DC. Other cities (e.g. Seattle, Boston, New York,
  Austin, Chicago, Denver, Los Angeles, San Francisco) are matched on each job's location list — pair them with a
  category so fewer pages are read.
- **Keywords filter, they don't search.** Combine keywords with a category (e.g. category *Engineering* + keyword
  *kubernetes*) for the best hit rate. Raise **Max pages per search** for rare keywords.
- **Card-only mode** (*Include full details* off) is about 5× faster and has the title, company, location, work model,
  salary text and range, seniority, skills, industries and a short summary.
- Schedule the actor daily with **Posted within: Past 24 hours** to collect only new jobs.
- Jobs are listed newest first, like on Built In.

### FAQ

**Is it legal to scrape Built In?**
This actor reads only public job listings that anyone can see without an account, at a modest pace, and it respects
Built In's robots.txt (pages Built In asks crawlers not to visit are never requested). Job postings are published by
employers to be seen widely. As with any data, how you use it is up to you — check the rules that apply to your use
case (for example if you republish the listings), and consult a lawyer if unsure.

**Does it access any private data?**
No. It never logs in and reads nothing behind a login. Rows describe jobs and the companies hiring. If a job
description contains a recruiter's personal e-mail address or phone number, it is replaced with `[email removed]` /
`[phone removed]`; company mailboxes such as careers@ stay.

**Why does a job show "Remote or Hybrid" when I asked for Remote?**
Built In tags many jobs with more than one work model and includes them in both filters. `workModel` shows Built In's
exact label and `isRemote` is true whenever remote work is possible.

**Why is `salaryCurrency` empty on some rows?**
With full details on, the currency comes from the job page. In card-only mode it is set to USD only for US
locations; elsewhere it stays empty rather than guessed.

**Can I get more than 10,000 jobs?**
One run returns up to 10,000. Split bigger pulls by category or metro area and run them in parallel or on a schedule.

**The run says "Stopped at your spending limit".**
Your maximum charge per run was reached; raise it in the run options to get more jobs.

**Something looks wrong?**
Open an issue on the actor's page with the run link — every run also stores a `RUN_REPORT` in its key-value store
with what happened.

# Actor input Schema

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

Built In job categories (and sub-categories) to scrape, e.g. "Engineering", "Data & Analytics › Data Engineering", "Sales". Each one is a separate search. Leave empty for all categories.

## `workModels` (type: `array`):

Remote, Hybrid and/or On-site. Empty = all. (Built In tags many jobs with two models, e.g. "Remote or Hybrid".)

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

Optional cities, states or "Remote". Built In metro areas get their own job board: Atlanta, Baltimore, Birmingham, Charlotte, Columbus, Dallas Fort Worth, Detroit, Houston, Jacksonville, Kansas City, Las Vegas, Miami, Minneapolis Saint Paul, Nashville, Orlando, Philadelphia, Phoenix Mesa Scottsdale, Pittsburgh, Portland, Raleigh Durham, Salt Lake City, San Antonio, San Diego, St. Louis, Tampa Bay, Washington DC. Any other place (e.g. "Seattle, WA", "Texas", "NYC", "Toronto") is matched on each job's locations. Each location is a separate search.

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

Country whose jobs Built In lists. Built In is mostly a US job board; Canada also has a good number of jobs.

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

Maximum number of jobs for the whole run, shared fairly between your searches. 0 = up to 10,000.

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

Also open each job's own page for the full description, exact salary range and currency, exact posting date, employment type, benefits, office addresses, remote eligibility and the company's size, HQ, founding year and profile. Turn off for faster card-only rows (title, company, location, work model, salary text, seniority, skills, industries, summary). Same price either way.

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

Only jobs at these experience levels. Empty = all.

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

Only jobs at companies of these sizes. Empty = all.

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

Only jobs posted or updated in this period.

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

Only jobs listing at least one of these skills, e.g. "Python", "SQL", "React", "Salesforce". Works best together with a category.

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

Only jobs whose title, company, summary, skills or industries contain one of these keywords (all words of a keyword must appear), e.g. "product manager", "fintech", "kubernetes". Built In's job board has no keyword search for scrapers, so keywords filter the jobs of your categories / locations — pick a category too for the best results.

## `startUrls` (type: `array`):

Optional: Built In job URLs (builtin.com/job/…/12345) or job-board URLs (builtin.com/jobs/remote/data-analytics?country=USA, filters in the URL are kept; a search term in the URL is applied as a keyword filter).

## `maxPagesPerSearch` (type: `integer`):

How many Built In job-board pages (10-25 jobs each) one search may read when keywords, a city that is not a Built In metro, on-site, mid-level or skills without a category leave jobs out. Searches without such filters read as many pages as Max jobs needs.

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

Apify Proxy (datacenter) is the default and comes with every Apify plan. If Built In refuses datacenter IPs for a while, the run switches to residential proxies when your account has them.

## `_noResidential` (type: `boolean`):

Internal (canaries): behave exactly like an account without the RESIDENTIAL proxy group.

## Actor input object example

```json
{
  "categories": [
    "data-analytics"
  ],
  "workModels": [
    "remote"
  ],
  "country": "USA",
  "maxItems": 10,
  "includeDetails": true,
  "postedWithin": "any",
  "maxPagesPerSearch": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "_noResidential": false
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped jobs.

## `run` (type: `string`):

Status and statistics for this run.

## `report` (type: `string`):

RUN_REPORT: how the run ended, counts, requests and proxy use.

# 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 = {
    "categories": [
        "data-analytics"
    ],
    "workModels": [
        "remote"
    ],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("yugenox/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 = {
    "categories": ["data-analytics"],
    "workModels": ["remote"],
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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