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

Scrape open tech and startup roles from Built In (builtin.com): title, employer, location, workplace type (remote/hybrid/on-site), salary (where posted), experience level and apply URL. Give it a keyword query. No login, no account.

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

## Pricing

$1.50 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Built In Jobs Scraper

> **Unofficial.** This is an independent, community-built actor. It is not affiliated with,
> endorsed by, or connected to Built In or Built In, Inc. in any way. "Built In" is a
> trademark of its respective owner and is used here only to describe what the actor reads.

Scrape open tech and startup roles straight from [Built In](https://builtin.com/jobs)'s
public job search. Give it a keyword query ("software engineer", "data engineer", "product
manager") and it returns every matching role across the result pages, as clean structured
rows. No login, no account, no API key.

> **Your free $5 Apify credit covers roughly 3,300 job listings** at the launch price - more
> than enough to try it on your real search before paying anything.

### What you get

One row per open role, every field read straight off the search card (no extra page fetch):

| field | notes |
|-------|-------|
| `id` | stable `builtin:{jobId}` |
| `provider` | always `builtin` |
| `jobId` | Built In numeric job id |
| `title` | role title |
| `company` | employer |
| `location` | city, region, country - or `N Locations` for a multi-city posting |
| `workplaceType` | Remote / Hybrid / On-site / Remote or Hybrid, where the card shows it |
| `experienceLevel` | e.g. Senior level, Expert/Leader, where the card shows it |
| `salaryText` | raw posted pay ("194K-407K Annually") - Built In shows it on some views only |
| `salaryMin` / `salaryMax` | parsed from `salaryText` where present, else `null` |
| `postedText` | relative post time as Built In shows it ("Reposted 6 Days Ago") |
| `tags` | reserved (empty for now) |
| `url` / `applyUrl` | the Built In job page |

### Input

- **keywords** - what to search Built In for. Sent to Built In's own search (`?search=`), so
  results match the site. Blank returns the newest roles across Built In.
- **maxResults** - stop after N roles (~25 per page). Your cost control. `0` = no cap.
- **titleOnly** - keep only roles whose title contains all your keywords.
- **excludeKeywords** - drop roles containing any of these words (title/company/workplace/
  location/level).
- **location** - keep only roles whose location contains all these words. Built In serves
  location on the card, so no extra fetch is needed; a multi-city posting shows as
  `N Locations` and will not match a city name.
- **remoteOnly** - keep only remote roles (workplace label + location text).
- **maxPages** - safety cap on pages walked for a very broad query.

### How it works

Built In serves its job search as a server-rendered HTML page (no login, no anti-bot
challenge, verified first-hand). This actor fetches `builtin.com/jobs?search={keywords}&page={n}`,
parses the ~25 job cards per page off the rendered HTML, and walks pages until `maxResults`
is reached or the last result page is hit. The keyword query runs on Built In's side;
`titleOnly`, `excludeKeywords`, `location` and `remoteOnly` are applied locally. Unlike some
job actors, **every field - including location and salary - is already on the search card**,
so there is no per-role detail fetch: one page fetch returns ~25 fully-populated rows.

### Cost

Pay-per-event on the dataset item (`apify-default-dataset-item`), no per-run start fee:
**a 1,000-job run costs exactly $1.50** - no minimum ticket, no hidden add-on events. Many
competing Built In actors charge a per-run start fee (up to $0.09/run) on top of their
per-item price; this one does not.

### Legal

Reads only Built In's public, unauthenticated job search - no login, no credential, no
paywall, no CAPTCHA solving. Standard public-web collection. `robots.txt` and site ToS are
respected as the ordinary conditions of public-web scraping.

# Actor input Schema

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

What to search Built In for, e.g. 'software engineer', 'data engineer', 'product manager'. This is sent to Built In's own search (?search=), so it returns the same roles the site would. Leave blank to return the newest roles across all of Built In.

## `maxResults` (type: `integer`):

Stop after this many roles. Your cost control. Built In returns ~25 roles per page, so 100 walks about 4 pages. Set 0 for no cap (walks until the last result page).

## `titleOnly` (type: `boolean`):

Keep only roles whose TITLE contains all of your keywords. Built In ranks by relevance and may return loosely related roles; turn this on to keep only titles that actually name your terms.

## `excludeKeywords` (type: `string`):

Drop any role containing ANY of these words, e.g. 'senior manager clearance'. Applied to the title, company, workplace type, location and experience level. Useful for stripping seniority or terms you do not want.

## `location` (type: `string`):

Keep only roles whose location contains ALL of these words, e.g. 'new york' or 'chicago'. Built In serves the location on the search card itself, so no extra fetch is needed. Note: a role posted in multiple cities shows as 'N Locations' on the card and will not match a city name.

## `remoteOnly` (type: `boolean`):

Keep only remote roles. Uses the workplace-type label on the search card (Remote / Remote or Hybrid) plus the location text.

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

Hard cap on how many search pages to walk, as a safety limit for a very broad query. Built In returns ~25 roles per page. Leave the default unless you know you need more.

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

Proxy configuration. Datacenter proxies are fine for Built In.

## Actor input object example

```json
{
  "keywords": "software engineer",
  "maxResults": 100,
  "titleOnly": false,
  "remoteOnly": false,
  "maxPages": 200,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every job returned by the run, as rows in the default dataset.

# 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": "software engineer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zilicon/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": "software engineer" }

# Run the Actor and wait for it to finish
run = client.actor("zilicon/builtin-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": "software engineer"
}' |
apify call zilicon/builtin-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=zilicon/builtin-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Un60UBp7zg2UvDUTu/builds/Uy4pjgUHxpoCxagS0/openapi.json