# Built In Jobs Scraper: US Tech Jobs (`puhmeisterluka/builtin-jobs-scraper`) Actor

Tech job listings from any builtin.com search: title, company, salary range, remote or hybrid, locations, level, skills, benefits and the full description. Paste a search URL or type keywords, schedule it for new jobs only.

- **URL**: https://apify.com/puhmeisterluka/builtin-jobs-scraper.md
- **Developed by:** [Luka Puhmeister](https://apify.com/puhmeisterluka) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

Get job listings from any Built In search as JSON, CSV or Excel. Tech, product, sales and data jobs at US
startups and tech companies, plus remote jobs worldwide. No login, no proxy.

- **Paste a search URL or type keywords.** Search on builtin.com/jobs with the filters you want and copy the URL, or fill in **Keywords**.
- **Salaries as numbers.** `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod`, ready to filter, next to the salary text Built In shows.
- **Full job details.** Description, employment type, benefits, required skills, addresses, posting and expiry dates, from each job's own page.
- **Exact publish times.** `publishedAt` comes to the second, not "2 days ago".
- **Monitor mode.** Turn on **Only new jobs** and schedule it. Each run returns only jobs it has not returned before for that search.

### What data does it return?

| Field | Example | Notes |
|---|---|---|
| `id`, `url` | `12142296`, `https://builtin.com/job/principal-product-marketing-manager-iis/12142296` | |
| `title` | `Principal Product Marketing Manager - IIS` | |
| `company`, `companyUrl`, `companyLogo` | `Huntress`, `https://builtin.com/company/huntress`, `https://cdn.builtin.com/...` | |
| `publishedAt`, `postedAgo`, `isReposted` | `2026-11-09T21:17:51Z`, `44 Minutes Ago`, `false` | Live or last reposted, UTC |
| `workModel` | `Remote` | `Remote`, `Hybrid`, `In-Office`, or a mix such as `Remote or Hybrid` |
| `locations` | `["Austin, TX, USA", "Seattle, WA, USA"]` | As the results list shows them |
| `salary` | `180K-210K Annually` | As the results list shows it |
| `experienceLevel` | `Senior level` | |
| `industries`, `skills` | `["Cybersecurity"]`, `["AI", "Microsoft"]` | Top skills from the results list |
| `summary` | `Own product marketing for ...` | Built In's short summary |
| `isEasyApply`, `isFeatured` | `true`, `false` | |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | `180000`, `210000`, `USD`, `year` | From the job page |
| `employmentType` | `FULL_TIME` | |
| `isRemote`, `remoteCountries` | `true`, `["USA"]` | Where applicants may live |
| `addresses` | `["West Des Moines, Iowa, USA"]` | Street and zip where given |
| `benefits` | `["Offers health insurance", ...]` | |
| `requirements` | `["6+ years of product marketing experience", ...]` | The "Skills Required" list |
| `datePosted`, `validThrough` | `2026-11-09`, `2026-12-09T21:17:51+00:00` | |
| `description`, `descriptionHtml` | `What We Do: ...` | Plain text and HTML |
| `detailsFetched` | `true` | Whether the job page was read |
| `searchUrl`, `scrapedAt` | | |

With **Full job details** off you get what the results list shows: title, company, salary text, work model,
locations, level, summary, top skills and publish time. That run makes 10 to 25 times fewer requests. The fields
that need job pages stay empty.

**Contact details:** email addresses and phone numbers in descriptions are masked. Apply through the job's page.

The run's `SEARCHES` record shows, per search, the pages read, the last page Built In offers, jobs returned and jobs
that were taken down before they could be read. Those are not returned or charged.

### Output example

One item from a real run, long texts shortened:

```json
{
  "id": 12141463,
  "url": "https://builtin.com/job/backend-engineer-iii-data-onboarding-ng-siem-hybrid/12141463",
  "title": "Backend Engineer III, Data Onboarding, NG-SIEM (Hybrid)",
  "company": "CrowdStrike",
  "companyUrl": "https://builtin.com/company/crowdstrike",
  "companyLogo": "https://static.builtin.com/cdn-cgi/image/f=auto,fit=scale-down,w=128,h=128/companies-assets/63646/logo/67eb0c76-ebf0-...",
  "publishedAt": "2026-11-09T20:34:21Z",
  "postedAgo": "An Hour Ago",
  "isReposted": false,
  "isFeatured": false,
  "isEasyApply": false,
  "workModel": "Remote or Hybrid",
  "locations": [
    "New York, NY, USA"
  ],
  "salary": "120K-185K Annually",
  "experienceLevel": "Senior level",
  "industries": [
    "Cloud",
    "Computer Vision",
    "Information Technology"
  ],
  "summary": "Develop and operate Go-based, globally available distributed systems that enable petabyte-scale data ingestion for...",
  "skills": [
    "Amazon Web Services (Aws)",
    "Apache Kafka",
    "Docker"
  ],
  "detailsFetched": true,
  "datePosted": "2026-11-09",
  "validThrough": "2026-12-09T20:34:21+00:00",
  "employmentType": "FULL_TIME",
  "isRemote": true,
  "salaryMin": 120000,
  "salaryMax": 185000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "remoteCountries": [
    "USA"
  ],
  "addresses": [
    "New York, New York, USA"
  ],
  "benefits": [
    "Offers 401(K)",
    "Provides 401(K) matching",
    "Offers disability insurance"
  ],
  "requirements": [
    "U.S. citizenship or U.S. permanent residency",
    "Bachelor's or Master's degree in Computer Science or a related field, or equivalent work experience",
    "7+ years of experience designing, implementing, and maintaining software products, systems, and releases across the..."
  ],
  "description": "As a global leader in cybersecurity, CrowdStrike protects the people, processes and technologies that drive modern...",
  "descriptionHtml": "<p>As a global leader in cybersecurity, CrowdStrike protects the people, processes and technologies that drive...",
  "searchUrl": "https://builtin.com/jobs/remote/dev-engineering?country=USA",
  "scrapedAt": "2026-11-09T22:19:30+00:00"
}
```

### How to use it

1. Search on builtin.com/jobs: pick a category, remote or hybrid, level, industry.
2. Paste the results URL into **Search URLs**. Add as many as you like. Or fill in **Keywords**.
3. Set **Max jobs per search**.
4. Run, then download from the Dataset tab or pull results through the API.

### Input example

```json
{
  "startUrls": [
    { "url": "https://builtin.com/jobs/remote/dev-engineering" },
    { "url": "https://builtin.com/jobs/data-analytics/senior" }
  ],
  "keywords": "machine learning",
  "country": "USA",
  "postedWithin": "week",
  "maxItems": 200,
  "fetchDetails": true,
  "onlyNew": false
}
```

### How much does it cost?

Pay per event, with no subscription and no platform usage on top:

| Event | Price |
|---|---|
| Run start | $0.005 |
| Job returned | $0.00011 per job ($0.11 per 1,000) |

So 1,000 jobs cost $0.115. Jobs that fail or are filtered out are never billed. Set a maximum total charge on the run for a hard cap.

### Use it from code

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("PuhmeisterLuka/builtin-jobs-scraper").call(run_input={
    "keywords": "data engineer",
    "maxItems": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["company"], item["salaryMin"], item["salaryMax"], item["url"])
```

Works the same from Node, Make, Zapier, n8n, or as an MCP tool for AI agents.

### FAQ

**Why does it add `country=USA` to my search?**
Built In picks the country from the visitor's IP address. Without a place in the URL, a run could see another
country's jobs depending on where Apify's server sits. So every search that names no city, state or country gets
the **Country** input, USA by default. Set it to `GBR`, `IND`, `CAN` and so on, or clear it to let Built In decide.

**How many jobs can one search return?**
Keyword searches stop at page 400 (10,000 jobs). Category pages show 10 to 12 jobs per page. For more, split the
search by category, level or place.

**Why do some salaries look odd?**
Employers type them. A few say "85K-65K" or "40-136K Hourly". The Actor passes on what Built In has, unchanged.

**How does Only new jobs work?**
The Actor remembers the job ids it returned for each search, in a key-value store named `builtin-jobs-scraper-state`
in your account. Later runs skip those and stop after three pages in a row with nothing new. Built In lists newer
jobs first, so this stays cheap. Delete the store to start over.

**Does it need a proxy?**
No. Requests go one at a time, a second apart.

**Something broke?**
Open an issue on the Issues tab. Fixes usually ship within a day.

### More job scrapers

Same developer, same output style and pricing model:

- [Apna Jobs Scraper](https://apify.com/puhmeisterluka/apna-jobs-scraper): India, blue-collar and entry-level jobs with salary
- [Cutshort Scraper](https://apify.com/puhmeisterluka/cutshort-scraper): India, tech jobs with salary and skills
- [Shine Jobs Scraper](https://apify.com/puhmeisterluka/shine-jobs-scraper): India, jobs with salary, experience and skills
- [Jobbird Scraper](https://apify.com/puhmeisterluka/jobbird-scraper): Netherlands, vacatures with salary and hours
- [Arbeitsagentur Jobs Scraper](https://apify.com/puhmeisterluka/bundesagentur-jobs-scraper): Germany, the federal Jobsuche
- [karriere.at Scraper](https://apify.com/puhmeisterluka/karriere-at-scraper): Austria, jobs with stated minimum pay
- [Jobup.ch Scraper](https://apify.com/puhmeisterluka/jobup-scraper): Switzerland, jobs and employers from jobup.ch
- [Jobnet.dk Scraper](https://apify.com/puhmeisterluka/jobnet-scraper): Denmark, the public Jobnet job search
- [No Fluff Jobs Scraper](https://apify.com/puhmeisterluka/nofluffjobs-scraper): Poland, tech jobs with salary ranges
- [RocketJobs Scraper](https://apify.com/puhmeisterluka/rocketjobs-scraper): Poland, jobs with salaries and skills
- [Computrabajo Scraper](https://apify.com/puhmeisterluka/computrabajo-scraper): Latin America, jobs from every Computrabajo country site
- [MyCareersFuture Scraper](https://apify.com/puhmeisterluka/mycareersfuture-scraper): Singapore, jobs with salary and employer UEN
- [Remote OK Jobs Scraper](https://apify.com/puhmeisterluka/remoteok-jobs-scraper): remote jobs from Remote OK, by tag
- [Ashby Jobs Scraper](https://apify.com/puhmeisterluka/ashby-jobs-scraper): every job on any company's Ashby board
- [Lever Jobs Scraper](https://apify.com/puhmeisterluka/lever-jobs-scraper): every job on any company's Lever board
- [Greenhouse Jobs Scraper](https://apify.com/puhmeisterluka/greenhouse-jobs-scraper): every job on any company's Greenhouse board
- [SmartRecruiters Jobs Scraper](https://apify.com/puhmeisterluka/smartrecruiters-jobs-scraper): every job on any company's SmartRecruiters career site
- [ADP Jobs Scraper](https://apify.com/puhmeisterluka/adp-jobs-scraper): jobs from any employer's ADP career site

# Actor input Schema

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

Built In results pages. Search on builtin.com/jobs with the filters you want (category, remote, level, industry, company size), then paste the URL.

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

Optional. Adds a keyword search, e.g. "data engineer" or "rust".

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

Three-letter country code: USA, CAN, GBR, IND, DEU and so on. Used for every search that does not name a place itself. Built In otherwise picks the country from the visitor's IP. Clear it to leave that to Built In.

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

Optional, with State. For example "Austin". Used like Country.

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

Optional, the full name, e.g. "Texas".

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

Only jobs posted in this window. Applies to every search that has no date filter of its own.

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

Stop each search after this many jobs. Keeps your bill predictable.

## `fetchDetails` (type: `boolean`):

Open every job for the full description, salary as numbers, employment type, benefits, required skills, addresses and dates. Off returns what the results list shows (title, company, salary text, work model, locations, level, summary, top skills) and makes 10 to 25 times fewer requests.

## `onlyNew` (type: `boolean`):

Return only jobs this Actor has not returned before for the same search. Put it on a schedule to get new jobs as they appear.

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

Optional. Runs work without a proxy.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://builtin.com/jobs/remote/dev-engineering"
    }
  ],
  "country": "USA",
  "postedWithin": "any",
  "maxItems": 100,
  "fetchDetails": true,
  "onlyNew": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One item per job in the default dataset.

## `searches` (type: `string`):

Pages read, last page, jobs returned and jobs that had gone, for every search URL.

# 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 = {
    "startUrls": [
        {
            "url": "https://builtin.com/jobs/remote/dev-engineering"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("puhmeisterluka/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 = {
    "startUrls": [{ "url": "https://builtin.com/jobs/remote/dev-engineering" }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("puhmeisterluka/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 '{
  "startUrls": [
    {
      "url": "https://builtin.com/jobs/remote/dev-engineering"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call puhmeisterluka/builtin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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