# Built In Jobs Scraper - Tech Jobs, Salaries, Skills & Companies (`topapi/builtin-jobs-scraper`) Actor

Scrape US tech and startup jobs from Built In (builtin.com, Built In NYC, SF, LA, Chicago, Austin, Boston, Seattle, Colorado): title, company, salary, skills, remote / hybrid, level, full description, benefits, company profile. Every board filter, monitor mode. $0.45 per 1,000 jobs.

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

## Pricing

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

### What does Built In Jobs Scraper do?

**Built In Jobs Scraper** reads US tech and startup jobs from [Built In](https://builtin.com) - builtin.com and its city sites Built In NYC, San Francisco, LA, Chicago, Austin, Boston, Seattle and Colorado - and returns one row per job: title, company, location, remote / hybrid / on-site, experience level, pay range, top skills, Built In's summary, the exact posting time, and by default the full job page (description, employment type, expiry date, addresses with coordinates, benefits, skills required and the company block). Built for recruiters, staffing agencies, sales teams selling to hiring companies, HR-tech and labour-market analysts who need Built In jobs as data.

Built In scraper · builtin.com scraper · Built In jobs API · Built In NYC jobs · tech jobs scraper · startup jobs data

- **Every Built In filter:** keyword, country, city / state / radius, city site, remote / hybrid / on-site, category and subcategory, experience level, industry, company size, posted within N days, skills, early applicant, company.
- **The full job page on every row, at no extra charge:** description as text, HTML and Markdown, employment type, posting and expiry dates, every address with latitude / longitude, the countries applicants must live in, benefits, skills required, compensation highlights, and the company's HQ, size, founding year, mission and workplace policy.
- **The board's exact posting time:** `publishedAt` comes from the board's own data to the second, not from the "2 Days Ago" label.
- **Past the 10,000-per-search cap:** a keyword search on Built In stops at 400 pages; a bigger run reads the search cell by cell (experience level, workplace, company size).
- **Company profiles too:** website, street address, offices, open jobs by category, workplace policy, tech stack and every perk - on job rows (option) or as company rows from Built In's company directory with its filters.
- **No login, cookies or API key.**
- **Pay only for delivered rows:** no start fee; filtered-out jobs, duplicates and jobs delivered by earlier monitor runs are never charged.
- **Export anywhere:** JSON, CSV, Excel, XML; schedules, webhooks, Make, Zapier, n8n, Google Sheets, Slack, Telegram, Discord, Teams, ntfy.
- **Works with AI agents:** call it through the Apify API or the Apify MCP server; `compact` rows for LLM pipelines.

### What data can you get from Built In?

<table>
<tr>
<td>💼 Job title, Built In id and link</td>
<td>🏢 Company, slug, logo, profile link</td>
<td>🏷️ Category, industries</td>
</tr>
<tr>
<td>📍 Location(s), city, state, country</td>
<td>🗺️ Addresses with latitude / longitude</td>
<td>🏠 Workplace: Remote, Hybrid, In-Office</td>
</tr>
<tr>
<td>🎓 Experience level, employment type</td>
<td>💲 Pay as shown, min / max, currency, period</td>
<td>🛠️ Top skills and skills required</td>
</tr>
<tr>
<td>📝 Full description (text, HTML, Markdown)</td>
<td>✨ Built In's summary of the role</td>
<td>🎁 Benefits and compensation highlights</td>
</tr>
<tr>
<td>📅 Exact posting time (`publishedAt`), expiry date</td>
<td>⚡ Easy Apply, early applicant, reposted, featured</td>
<td>🔗 Built In apply link</td>
</tr>
<tr>
<td>🏛️ Company HQ, employees, year founded</td>
<td>🌐 Company website, offices, tech stack (option)</td>
<td>🔁 New / expired (monitor mode)</td>
</tr>
</table>

Measured on a 60-job run with every option on (search "machine learning", 2026-11-06): title, company, location, workplace, level, industries, summary, top skills, description, employment type, expiry, benefits (97%), skills required, posting time and Easy Apply flag on 100% of rows; coordinates 93%, postal code 58%, published pay 75% (with currency 72%), Built In apply link 83%, company HQ 95%, employees 98%, founded 100%; company website 100%, offices 98%, tech stack 90%; an e-mail written in the job text 27%, a phone 25%.

### How to scrape Built In with Built In Jobs Scraper

1. [Create a free Apify account](https://console.apify.com/sign-up) - $5 of monthly credit, no card needed.
2. Open [Built In Jobs Scraper](https://apify.com/topapi/builtin-jobs-scraper) and click **Try for free**.
3. Type one or more **Search keywords** (e.g. `python`, `product manager`, `account executive`), pick a **Country**, **City site** or **Locations** if you want, and set **Max results**.
4. Click **Start**. The prefilled form (keyword `python`, 20 jobs) finishes in about 6 seconds.
5. Open the **Storage** tab and **Export** as JSON, CSV or Excel - or let a schedule run it for you.

### ⬇️ Input

| Parameter | Type | Description |
|---|---|---|
| **🔍 What to scrape** | | |
| `mode` | Select | `jobs` (default) or `companies` (company profile rows). |
| `searchQueries` | List | Keywords, each its own search, e.g. `["python", "product manager"]`. Empty = the newest jobs. Companies mode: company names. |
| `startUrls` | List | Built In links: search pages (their filters are kept, builtin.com or a city site such as `builtinchicago.org`), job pages, company pages, company jobs pages, company directory pages. |
| `companies` | List | Company names, slugs, links or ids, e.g. `["Stripe", "aerospace-corporation"]`. Jobs mode: their open jobs (every country unless a country or place is set); companies mode: their profiles. |
| **🎯 Filters** (applied by Built In) | | |
| `country` | Select | Empty = United States; `CAN`, `GBR`, `IND`, `DEU` ... or `ANY` (every country). |
| `hub` | Select | City site: `nyc`, `sf`, `la`, `chicago`, `austin`, `boston`, `seattle`, `colorado`, or `remote`. |
| `locations` | List | Cities, states or countries, e.g. `["Denver, CO", "Texas", "London"]` - one search each, resolved with Built In's own location search. |
| `searchRadius` | Select | `5mi` ... `100mi` around a city. |
| `workplaceTypes` | List | `remote`, `hybrid`, `office`. |
| `category`, `subcategories` | Select | Built In's 16 categories and their subcategories, e.g. `data-analytics` / `data-engineering`. |
| `experienceLevels` | List | `internship`, `entry-level`, `junior`, `mid-level`, `senior`, `expert-leader`. |
| `industries`, `companySizes` | List | Built In's 103 industries (`fintech`, `healthtech` ...) and sizes (`1-10` ... `1000` = 1,000+). |
| `postedWithinDays` | Integer | Any number of days (1, 3, 7, 30 are Built In's own filter). |
| `skills`, `earlyApplicantOnly` | List / Boolean | Built In's skill filter (with a keyword or category) and early-applicant filter. |
| **✂️ Refine results** | | |
| `titleKeywords`, `excludeKeywords` | List | Title must / must not contain. |
| `excludeCompanies`, `locationContains` | List | Drop companies; keep locations containing a word. |
| `onlyWithSalary`, `minYearlySalary` | Boolean / Integer | Keep jobs with a pay range, or with a top of range of at least N a year (hourly x 2,080). |
| `easyApplyOnly`, `skipReposts` | Boolean | Default `false`. |
| `postedAfter`, `postedBefore` | Date | Posting-time window. |
| **➕ Extra data** (all included in the price) | | |
| `includeDetails` | Boolean | The full job page (default `true`). Companies mode: the full profile page. |
| `includeCompanyDetails` | Boolean | Company website, address, offices, open jobs by category, tech stack on each job. Default `false`. |
| `extractContacts` | Boolean | E-mails, phones and links written in the job text. Default `false`. |
| `expandCompanies` | Boolean | Browsing without a keyword shows at most 3 jobs per company; on = read every job of those companies. |
| `includeBenefits`, `includeCompanyJobs` | Boolean | Companies mode: every perk (grouped as on the Benefits tab); each company's open jobs as job rows. |
| `descriptionFormat` | Select | `all` (default), `text`, `html`, `markdown`. |
| **🏢 Company directory** (companies mode) | | `techStack`, `perks`, `diversity`, `officeTypes`, `metro` (80 metro areas), `hiringRemote`, `hasOpenJobs`, plus `industries`, `companySizes`, `country`, `locations`, `hub`. |
| **🔁 Monitoring** | | |
| `monitorMode` | Boolean | Only jobs earlier runs with the same input did not deliver. Pair with a schedule. |
| `monitorStoreName` | String | One name per scheduled search, e.g. `python-nyc`; the memory is a named dataset in your account (its last row). |
| `firstRunMode` | Select | `emitAll` (default) or `seedOnly` (remember, deliver from the next run). |
| `emitExpired`, `expiredCheckLimit` | Boolean / Integer | Also report remembered jobs whose page is gone (`changeType: "expired"`). |
| **📦 Output** | | |
| `maxItems` | Integer | Default `50`; `0` = everything that matches. |
| `maxItemsPerSearch`, `maxPages` | Integer | Per-search caps (25 jobs a page). |
| `descriptionMaxLength`, `compact`, `excludeEmptyFields` | Integer / Boolean | Cut descriptions; core fields only (AI / MCP); drop empty fields. |
| **🔔 Alerts** | | Webhook (+ headers), Slack, Discord, Microsoft Teams, Telegram, ntfy; `notificationLimit`. |
| **⚙️ Advanced** | | `proxyConfiguration`, `maxConcurrency` (default 4), `maxRequestsPerFiveMinutes` (default 100). |

#### Input JSON

```json
{
  "searchQueries": ["data engineer", "machine learning engineer"],
  "hub": "nyc",
  "workplaceTypes": ["hybrid", "remote"],
  "experienceLevels": ["senior"],
  "postedWithinDays": 7,
  "onlyWithSalary": true,
  "maxItems": 200
}
```

#### Put one idea per keyword

Each keyword is its own search and the run cap is shared evenly between searches. **Do:** `["data engineer", "analytics engineer"]` · **Don't:** `["data engineer analytics engineer New York"]` (Built In's search looks for all the words in one job; put the city in **City site** or **Locations**).

#### Paste a search link when you already filtered on Built In

Every filter in a Built In search link is kept: `https://builtin.com/jobs/remote/data-analytics/senior?search=sql&daysSinceUpdated=7` returns exactly that search. City-site links (`https://www.builtinchicago.org/jobs?search=python`) are read as the same metro search on builtin.com, 25 jobs a page instead of 10.

#### Turn off the job page for very large lists

With `includeDetails` on (the default), each job is one more page; Built In limits how many pages one IP may open (see Limits), so big runs with full pages take minutes, not seconds. For a quick list of thousands of jobs - title, company, location, workplace, level, pay, top skills, summary, posting time - set `includeDetails: false`: 2,000 jobs took 2.6 minutes.

### ⬆️ Output

One row per job (or per company in companies mode). A real row from a run on 2026-11-06 (description, skills and benefits shortened here):

```json
{
  "type": "job",
  "id": "11885643",
  "title": "Full Stack Lead Security Engineer",
  "url": "https://builtin.com/job/full-stack-lead-security-engineer/11885643",
  "company": "JPMorganChase",
  "companySlug": "jpmorgan-chase",
  "location": "Plano, TX, USA",
  "city": "Plano",
  "state": "Texas",
  "country": "USA",
  "latitude": 33.019695,
  "longitude": -96.697586,
  "workplaceType": "Hybrid",
  "experienceLevel": "Entry level",
  "employmentType": "FULL_TIME",
  "industries": ["Financial Services"],
  "skills": ["Aws Bedrock", "CloudFormation", "Python", "Terraform"],
  "skillsRequired": ["Proficiency in Python scripting", "Knowledge of MITRE ATLAS and OWASP Top 10 for LLMs"],
  "summary": "Lead security engineering for AI, generative AI, LLM, RAG, and ML systems. ...",
  "description": "Description\nTake on a crucial role where you'll be a key part of a high-performing team ...",
  "benefits": ["Offers 401(K)", "Offers disability insurance", "Provides a pension"],
  "easyApply": false,
  "applyUrl": "https://builtin.com/job/full-stack-lead-security-engineer/11885643?handler=ApplyRedirect",
  "postedText": "Reposted 4 Hours Ago",
  "publishedAt": "2026-11-06T07:39:17Z",
  "validThrough": "2026-12-06T07:39:17+00:00",
  "isReposted": true,
  "companyHeadquarters": "New York, NY",
  "companyEmployees": 289097,
  "companyFoundedYear": 1799,
  "companyWebsite": "http://www.jpmorganchase.com",
  "detailsFetched": true
}
```

Every row also carries `locations`, `addresses`, `postalCode`, `isRemote`, `isHybrid`, `applicantLocationRequirements`, `salaryText` / `salaryMin` / `salaryMax` / `salaryCurrency` / `salaryPeriod`, `descriptionHtml`, `descriptionMarkdown`, `benefitsHighlights`, `earlyApplicant`, `directApply`, `applyRequiresLogin`, `postedDate`, `datePosted`, `daysSincePosted`, `featured`, the company block (`companyTagline`, `companyDescription`, `companyWhyWorkWithUs`, `companyWorkplace`, `typicalTimeOnSite`, `insightLinks`), `contentHash` and where it was found (`searchQuery`, `searchLocation`, `searchUrl`, `page`, `positionOnPage`). The company option adds `companyId`, `companyWebsite`, `companyAddress`, `companyIndustries`, `companyTotalOffices`, `companyOffices`, `companyOpenJobs`, `companyOpenJobsByCategory` and `companyTechStack`; the contacts option adds `extractedEmails`, `extractedPhones`, `extractedUrls`. A row whose job page could not be read carries the search-card fields and `detailsFetched: false`. The full field list is in the **Output** tab; the dataset has **Jobs**, **Job details**, **Hiring company** and **Companies** views.

Company rows (companies mode): `companyId`, `name`, `slug`, `url`, `website`, `logo`, `tagline`, `description`, `industries`, `employees`, `foundedYear`, `headquarters`, `address`, `totalOffices`, `officeCities`, `offices`, `openJobs`, `openJobsByCategory`, `hiringNow`, `benefitsCount`, `workplace`, `workplaceDescription`, `typicalTimeOnSite`, `techStack` (name, category, team), `teams`, `featured`, `jobsUrl`, and with `includeBenefits` `perks` and `perkGroups`. On a 50-company directory run: website, industries, open jobs and workplace on 100%, employees and founded 98%, tech stack 92%, HQ and street address 84%.

### How can I use Built In data?

- 🎯 **Recruiters and staffing agencies** - find companies hiring senior engineers in a metro and pitch them candidates; filter by pay and workplace.
- 💼 **B2B sales teams** - a company with 30 open data jobs and a known tech stack is a lead for data tools; `companyOpenJobsByCategory` and `companyTechStack` show it.
- 📊 **Labour-market and pay research** - salary ranges by role, level, city and company size, with exact posting times.
- 🧭 **Job boards and aggregators** - fresh US tech postings with full descriptions and apply links, refreshed by a schedule.
- 🤖 **AI and research teams** - job descriptions, skills required and summaries as clean text or Markdown for skill-demand models.
- 📈 **Hiring-signal monitoring** - run it daily in monitor mode and get only the jobs that are new since yesterday.

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

Pay per row, no start fee:

| What | Price |
|---|---|
| Job row (with the full job page) | **$0.45 per 1,000** ($0.00045 each) |
| Company row (companies mode) | **$0.67 per 1,000** ($0.00067 each) |
| Company profile on jobs, contacts, benefits, Markdown, monitor mode | included |

Examples from real runs: 20 jobs (the prefilled form) = $0.009; 150 jobs = $0.0675; 1,000 jobs = $0.45. The $5 of monthly credit in Apify's free plan covers about 11,000 jobs. Set **Maximum cost per run** in the run options and the run stops cleanly at that amount (a $0.02 limit delivered 44 jobs, 44 charged).

### Run it on a schedule (only new jobs)

1. Fill in the search and turn on **Only new jobs** (`monitorMode`) with a **Monitor memory name**, e.g. `python-nyc`.
2. Save it as a task and add a schedule (e.g. every morning at 7:00).
3. Each run reads the newest pages only until it reaches jobs published before the last run, and delivers only jobs not delivered before; a run with nothing new costs nothing in rows (measured: an empty poll used $0.0001 of platform usage in 2.5 seconds).
4. Add a Slack, Telegram, Discord, Teams, ntfy or webhook alert to get the new jobs pushed to you.

```json
{
  "searchQueries": ["python"],
  "hub": "nyc",
  "monitorMode": true,
  "monitorStoreName": "python-nyc",
  "emitExpired": true,
  "maxItems": 200
}
```

Through the API: `POST https://api.apify.com/v2/acts/topapi~builtin-jobs-scraper/runs?token=<YOUR_TOKEN>` with the input above as the body; through MCP, add the actor to your Apify MCP server.

### Integrations, API, scheduling & MCP

- **Schedules:** hourly, daily or weekly from the **Schedules** tab; with `monitorMode` each run returns only new jobs. A job delivered without its job page or company page comes back once with `changeType: "details"` when a later run reads them (charged as a job).
- **Webhooks:** fire a URL when a run finishes - push rows to your CRM, ATS, Slack or a sheet.
- **No-code:** Make, Zapier, n8n, Google Sheets, Airtable, Slack via [Apify integrations](https://docs.apify.com/integrations).
- **API:** call it from Node.js or Python with `apify-client` - code on the [API tab](https://apify.com/topapi/builtin-jobs-scraper/api/python) and the [Apify API reference](https://docs.apify.com/api/v2).
- **MCP / AI agents:** connect Claude, Cursor or any MCP client through the [MCP tab](https://apify.com/topapi/builtin-jobs-scraper/api/mcp) and ask for Built In jobs in plain language; `compact: true` keeps rows small.

### More job scrapers

<table>
<tr>
<td>🌿 <a href="https://apify.com/topapi/welcome-to-the-jungle-jobs-scraper">Welcome to the Jungle Jobs Scraper</a></td>
<td>💼 <a href="https://apify.com/topapi/indeed-jobs-scraper">Indeed Jobs Scraper</a></td>
<td>🌍 <a href="https://apify.com/topapi/naukrigulf-jobs-scraper">Naukrigulf Jobs Scraper</a></td>
</tr>
<tr>
<td>🇩🇪 <a href="https://apify.com/topapi/xing-jobs-scraper">XING Jobs Scraper</a></td>
<td>🧭 <a href="https://apify.com/topapi">All TopApi actors</a></td>
<td></td>
</tr>
</table>

### Limits & empty runs

- **Built In's per-IP limit:** Built In shows a challenge page to an IP that opens more than about 120 pages in 5 minutes (measured 2026-11-06). The run stays under it: about 100 pages per 5 minutes per IP, then the next free egress, then it paces. With full job pages that is roughly 20-30 jobs a minute once the first ~200 are read: 150 jobs took 2.5-5.5 minutes, 1,000 jobs about 47 minutes. Without job pages (`includeDetails: false`) one page is 25 jobs: 2,000 jobs in 2.6 minutes.
- **A challenged egress is never retried:** the run moves one step up (direct, then Apify datacenter, then Apify residential while the run's rows pay for it) and never back. If a job page cannot be read, its row is still delivered with the search-card fields and `detailsFetched: false`; the status message says how many.
- **Results per search:** Built In serves 400 pages (10,000 jobs) per keyword search and 1,000 pages without one; a bigger run is read cell by cell. Browsing without a keyword shows at most 3 jobs per company - `expandCompanies` reads the rest.
- **Apply link:** Built In's own apply link (`applyUrl`, `?handler=ApplyRedirect`) asks a visitor to sign in before it forwards to the employer, so the employer's own application URL is not published to visitors (`applyRequiresLogin`).
- **Not available:** funding rounds and the employer's ATS are not on Built In's public company page; pay is in the row only when the employer published it (72-75% of rows).
- **Empty dataset:** a keyword with no match, filters that removed every job, or a company name Built In does not know - the status message says which. Nothing is charged.

### FAQ

#### How many jobs can Built In Jobs Scraper collect in one run?

As many as match: a keyword search shows up to 10,000 jobs and bigger runs are split into cells; set `maxItems: 0` for everything. With full job pages a run reads about 20-30 jobs a minute after the first ~200 (Built In's per-IP limit); without them, hundreds a minute.

#### How much does Built In Jobs Scraper cost?

$0.45 per 1,000 jobs with the full job page, $0.67 per 1,000 company rows, no start fee. Filtered-out jobs and jobs delivered by earlier monitor runs are free.

#### Can I run Built In Jobs Scraper on a schedule to get only new jobs?

Yes. Turn on `monitorMode`, give it a `monitorStoreName`, save the input as a task and schedule it. Each run delivers only jobs earlier runs did not; an empty poll costs about $0.0001.

#### Can I scrape Built In NYC, Built In SF or another city site?

Yes: pick it in **City site** (`hub`) or paste a city-site search link. The city sites show the jobs of their metro area; the actor reads the same search on builtin.com, 25 jobs a page.

#### Does Built In Jobs Scraper return the salary?

When the employer published one: `salaryText` as Built In shows it ("135K-200K Annually"), `salaryMin` / `salaryMax` as numbers, `salaryPeriod`, and `salaryCurrency` from the job page. `onlyWithSalary` and `minYearlySalary` keep only paid ranges.

#### Can I get company profiles and tech stacks?

Yes: `includeCompanyDetails` adds the company page to each job, and `mode: "companies"` returns company rows from names, links or Built In's company directory (filter by industry, size, tech stack, perks, office type, metro).

#### Can I use Built In Jobs Scraper with the Apify API or MCP?

Yes. Start runs and read datasets with `apify-client` for [Node.js](https://apify.com/topapi/builtin-jobs-scraper/api/javascript) or [Python](https://apify.com/topapi/builtin-jobs-scraper/api/python), or connect an MCP client through the [MCP tab](https://apify.com/topapi/builtin-jobs-scraper/api/mcp).

#### Do I need a Built In account, cookies or an API key?

No. The actor reads what Built In shows any visitor; you pass keywords, links or companies and nothing else.

#### Why did my run return no results?

The keyword matched nothing, your filters removed every job (the status lists how many each filter removed), or the company name is not on Built In (paste its builtin.com link). Nothing is charged for an empty run.

#### Your feedback

We keep improving Built In Jobs Scraper. Found a bug or missing a field? Open an issue on the [Issues tab](https://apify.com/topapi/builtin-jobs-scraper/issues/open).

# Actor input Schema

## `mode` (type: `string`):

Jobs: Built In job ads. Companies: company profiles (by name or link, or from the company directory with its filters).

## `searchQueries` (type: `array`):

One search per keyword, as typed in Built In's search box, e.g. "python", "product manager", "data engineer". Empty = the newest jobs. In Companies mode: company names.

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

Search pages (their filters are kept; builtin.com or a city site such as builtinnyc.com), job pages, company pages, company jobs pages, company directory pages.

## `companies` (type: `array`):

Company names, Built In slugs, links or ids, e.g. "Stripe", "aerospace-corporation", "https://builtin.com/company/coinbase". Jobs mode: their open jobs. Companies mode: their profiles.

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

Jobs in this country (Built In's own country filter). Empty = United States (for named companies: every country). A location or city site narrows it.

## `hub` (type: `string`):

The jobs a Built In city site shows (its metro area), read through builtin.com: the same jobs, 25 a page.

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

Cities, states or countries, resolved with Built In's own location search, e.g. "Denver, CO", "Texas", "London". One search per location.

## `searchRadius` (type: `string`):

Distance around a city location.

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

Remote, hybrid and / or on-site jobs. Empty = all.

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

Built In's job category.

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

Built In's subcategories (each belongs to one category; the category is set from them when empty).

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

Internship, entry level, junior, mid level, senior, expert / leader. Empty = all.

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

The hiring company's industries (Built In's 103). Also filters the company directory.

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

Employees of the hiring company. Also filters the company directory.

## `postedWithinDays` (type: `integer`):

Only jobs posted in the last N days (1, 3, 7 and 30 are Built In's own filter; any other N is applied to the posting time). 0 or empty = any time.

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

Built In's skill filter, e.g. "AWS", "SQL" (with a keyword or a category, as on the site).

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

Built In's "Be an early applicant" filter.

## `titleKeywords` (type: `array`):

Keep a job only when its title contains one of these words.

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

Drop jobs whose title contains one of these words, e.g. "intern", "contract".

## `excludeCompanies` (type: `array`):

Drop jobs from these companies (name contains).

## `locationContains` (type: `array`):

Keep a job only when one of its locations contains one of these words, e.g. "CA", "Brooklyn".

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

Keep only jobs that publish a pay range.

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

Keep jobs whose top of range is at least this much a year (hourly pay x 2,080).

## `easyApplyOnly` (type: `boolean`):

Keep only jobs with Built In's Easy Apply.

## `skipReposts` (type: `boolean`):

Drop jobs the board shows as "Reposted".

## `postedAfter` (type: `string`):

Only jobs posted on or after this date.

## `postedBefore` (type: `string`):

Only jobs posted on or before this date.

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

Read each job's page: full description, posting and expiry dates, employment type, addresses with coordinates, benefits, skills required, company block. No extra charge. Companies mode: the full profile page.

## `includeCompanyDetails` (type: `boolean`):

Add the company page to each job: website, address, offices, open jobs by category, tech stack. One page per company per run.

## `extractContacts` (type: `boolean`):

List the e-mail addresses, phone numbers and links written in the job description.

## `includeBenefits` (type: `boolean`):

Companies mode: every perk the company lists, grouped as on its Benefits tab.

## `includeCompanyJobs` (type: `boolean`):

Companies mode: also deliver each company's open jobs as job rows (charged as jobs).

## `expandCompanies` (type: `boolean`):

Built In shows at most 3 jobs per company when you browse without a keyword. On: read the full list of each company that shows 3.

## `descriptionFormat` (type: `string`):

Which description fields each row carries.

## `techStack` (type: `array`):

Company directory: companies that use these technologies.

## `perks` (type: `array`):

Company directory: companies that offer these perks.

## `diversity` (type: `array`):

Company directory: diversity and inclusion filters.

## `officeTypes` (type: `array`):

Company directory: workplace policy.

## `metro` (type: `string`):

Company directory: one of Built In's 80 metro areas.

## `hiringRemote` (type: `boolean`):

Company directory: companies hiring remote.

## `hasOpenJobs` (type: `boolean`):

Company directory: companies with open jobs.

## `monitorMode` (type: `boolean`):

Each run delivers (and charges) only jobs earlier runs with the same input have not delivered. Pairs with a daily schedule.

## `monitorStoreName` (type: `string`):

Name of the monitor memory (a named dataset in your account that remembers delivered jobs). One name per schedule.

## `firstRunMode` (type: `string`):

What the first run of a new monitor does.

## `emitExpired` (type: `boolean`):

Monitor runs: also deliver a row (changeType "expired") for remembered jobs whose page is gone.

## `expiredCheckLimit` (type: `integer`):

How many remembered jobs a run re-checks (one job page each).

## `resetMonitor` (type: `boolean`):

Forget what earlier runs delivered.

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

Rows in this run, over all searches. A keyword search shows up to 10,000 jobs (400 pages); past that the run splits it by experience level, workplace and company size. 0 = no limit.

## `maxItemsPerSearch` (type: `integer`):

Cap per keyword / location / company search. Empty = shared evenly.

## `maxPages` (type: `integer`):

Board pages (25 jobs each) per search. Empty = as many as needed.

## `descriptionMaxLength` (type: `integer`):

Cut descriptions to this many characters. 0 = full.

## `compact` (type: `boolean`):

Core fields only: title, company, location, workplace, level, pay, skills, summary, description, date.

## `excludeEmptyFields` (type: `boolean`):

Leave out fields that are empty on a row.

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

POST the new rows (up to the alert limit) as JSON after the run.

## `webhookHeaders` (type: `object`):

Extra headers for the webhook, e.g. {"Authorization": "Bearer ..."}.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL.

## `discordWebhookUrl` (type: `string`):

Discord channel webhook URL.

## `teamsWebhookUrl` (type: `string`):

Teams incoming-webhook URL.

## `telegramToken` (type: `string`):

Your Telegram bot token (with the chat id below).

## `telegramChatId` (type: `string`):

Chat or channel id for the bot.

## `ntfyTopic` (type: `string`):

ntfy.sh topic (or your own server below).

## `ntfyServer` (type: `string`):

Your ntfy server, default https://ntfy.sh.

## `notificationLimit` (type: `integer`):

How many jobs an alert lists.

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

Empty = direct, then Apify datacenter, then Apify residential when Built In shows a challenge page. Your own proxy goes first.

## `maxConcurrency` (type: `integer`):

Job pages read at once.

## `maxRequestsPerFiveMinutes` (type: `integer`):

Pace per egress IP. Built In shows a challenge page past ~120-135 requests in a few minutes; the run stays under it and moves to the next free egress.

## Actor input object example

```json
{
  "mode": "jobs",
  "searchQueries": [
    "python"
  ],
  "hub": "national",
  "searchRadius": "",
  "category": "",
  "earlyApplicantOnly": false,
  "onlyWithSalary": false,
  "easyApplyOnly": false,
  "skipReposts": false,
  "includeDetails": true,
  "includeCompanyDetails": false,
  "extractContacts": false,
  "includeBenefits": false,
  "includeCompanyJobs": false,
  "expandCompanies": false,
  "descriptionFormat": "all",
  "metro": "",
  "hiringRemote": false,
  "hasOpenJobs": false,
  "monitorMode": false,
  "monitorStoreName": "builtin-jobs-monitor",
  "firstRunMode": "emitAll",
  "emitExpired": false,
  "expiredCheckLimit": 100,
  "resetMonitor": false,
  "maxItems": 20,
  "compact": false,
  "excludeEmptyFields": false,
  "notificationLimit": 10,
  "maxConcurrency": 4,
  "maxRequestsPerFiveMinutes": 100
}
```

# Actor output Schema

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

One item per job (or per company in Companies mode): title, company, location, workplace, level, pay, skills, dates, the full description, benefits, company block.

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

Per-search counts (board pages, read, delivered), filters, job-page results, egress and requests (written for Console runs, large runs and runs with a problem).

# 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 = {
    "searchQueries": [
        "python"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/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 = {
    "searchQueries": ["python"],
    "maxItems": 20,
}

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

```

## MCP server setup

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