# BuiltIn Jobs Scraper (`solidcode/builtin-scraper`) Actor

\[💰 $0.95 / 1K] Extract tech job listings from BuiltIn.com — titles, companies, salaries, locations, remote/hybrid status, experience level, skills, and full job descriptions. Filter by keyword, location, category, seniority, workplace type, and posted date.

- **URL**: https://apify.com/solidcode/builtin-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.95 / 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## BuiltIn Jobs Scraper

Pull tech job listings from BuiltIn.com at scale — titles, structured salary bands, company profiles, required skills, posted dates, apply links, and full job descriptions for every role on the board. Built for technical recruiters, sales teams prospecting tech companies, compensation analysts, and talent sourcers who need fresh tech-hiring data without babysitting paginated search results.

### Why This Scraper?

- **All 20 BuiltIn job categories covered** — AI & Machine Learning, Engineering, Data & Analytics, Cybersecurity, Design, Product Management, Sales, Marketing, Finance, HR & Recruiting, Legal, Healthcare Services, Manufacturing & Production, Operations & Support, Program & Project Management, Research, Consulting, Defense & Field Operations, Customer Success, and Supply Chain & Procurement.
- **Structured salary fields, not blobs** — `salaryMin`, `salaryMax`, `salaryCurrency`, and `salaryPeriod` are parsed from every listing that publishes pay (e.g. `209000`, `239000`, `USD`, `year`) — not a raw `"$209K–$239K Annually"` string.
- **Top Skills array on every card** — `skills: ["Python", "AWS", "Kubernetes"]` extracted from BuiltIn's card-level skills strip plus the "Skills Required" section on the detail page.
- **Six experience tiers, exact-match** — Internship, Entry Level (0–1 yrs), Junior (1–2 yrs), Mid Level (2–5 yrs), Senior Level (5–9 yrs), and Expert / Leader (9+ yrs).
- **Four workplace modes** — Any, Remote only, Hybrid, or On-site only — applied as a path filter so multi-location and "Remote or Hybrid" cards are classified correctly.
- **Posted-date filter at 1 / 3 / 7 / 30 days**, with an ISO `postedDate` (e.g. `"2026-05-12"`) pulled from BuiltIn's tracking payload — far more reliable than the "Reposted N Days Ago" UI string.
- **Up to 1,000 results per search keyword or URL**, with automatic cross-page deduplication by job ID — no duplicate rows even when the same job appears on multiple search pages.
- **Paste any BuiltIn URL directly** — a category vertical like `/jobs/engineering`, a filtered search results page, or a company-jobs page like `/company/<slug>/jobs`. URL filters are honored verbatim.
- **Easy-apply detection and direct apply URLs** — `easyApply: true/false` plus the external `applyUrl` for every job that posts one off-site.

### Use Cases

**Tech Recruiting & Talent Sourcing**
- Build candidate pipelines by required skill stack (e.g. every Senior role mentioning Kubernetes + Go in Austin)
- Track which companies are hiring for specific titles, week over week
- Identify hiring spikes at competitor companies before they go public
- Source for niche roles like Staff ML Engineer or Principal Security Architect across 20 categories

**Sales & Business Development**
- Prospect tech companies actively hiring engineers — a high-signal indicator of growth and tooling budget
- Build lead lists segmented by company size, industry tags, and headcount
- Trigger outreach when a target account posts a role for your product's persona (e.g. DevOps tooling vendors targeting "DevOps Engineer" openings)
- Monitor pre-IPO companies expanding their engineering org

**Compensation & Market Research**
- Benchmark salary bands by role, city, and seniority — every published `salaryMin` / `salaryMax` in structured form
- Compare on-site vs. remote pay gaps across Senior and Staff levels
- Track salary inflation in a specific stack (e.g. Rust, Solidity, AI/ML)
- Build city-by-city compensation reports with parsed currency and pay period

**Investment & Market Intelligence**
- Spot startups scaling their engineering org as an early growth signal
- Track which roles a Series B company is filling before its next raise
- Map the tech stack of a target acquisition from required-skills data
- Quantify hiring velocity across portfolio companies

**Candidate Job Hunting**
- Pull every remote Senior role posted in the last 7 days into a spreadsheet
- De-duplicate cross-board listings by company + title before applying
- Export apply URLs for one-shot bulk application workflows
- Filter to companies that publish salary up front (just drop rows where `salaryMin` is null)

**Job Board Operators & Aggregators**
- Mirror BuiltIn into your own tech-jobs vertical with full salary, skills, and descriptions
- Power "trending skills" or "top hiring companies" dashboards
- Keep an internal listings index fresh with daily incremental pulls (`postedWithinDays: "1"`)

### Getting Started

#### Simplest Run

Just a keyword — runs nationwide with default filters and pulls the first 100 results.

```json
{
    "searchQueries": ["software engineer"]
}
````

#### Remote-Only, Last 7 Days

```json
{
    "searchQueries": ["machine learning engineer"],
    "remoteMode": "remote",
    "postedWithinDays": "7",
    "maxResultsPerQuery": 500
}
```

#### Location + Category + Seniority

Senior data engineers in Austin posted in the last month.

```json
{
    "searchQueries": ["data engineer"],
    "location": "Austin, TX",
    "category": "data-analytics",
    "experienceLevel": "senior",
    "postedWithinDays": "30",
    "maxResultsPerQuery": 250
}
```

#### Direct BuiltIn URLs

Paste any BuiltIn jobs URL — search results, category verticals, or company jobs pages.

```json
{
    "startUrls": [
        "https://builtin.com/jobs/engineering/senior",
        "https://builtin.com/jobs?search=python&city=New%20York&state=NY&country=USA",
        "https://builtin.com/company/stripe/jobs"
    ],
    "maxResultsPerQuery": 200
}
```

#### Fast Mode (Cards Only)

Turn off detail enrichment for roughly 3× faster runs when you only need title, company, salary, location, and skills from the card.

```json
{
    "searchQueries": ["devops engineer", "site reliability engineer"],
    "remoteMode": "remote",
    "fetchDescription": false,
    "maxResultsPerQuery": 1000
}
```

### Input Reference

#### Search & Targeting

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | string\[] | `["software engineer"]` | Job titles or keywords to search for. Each keyword runs a separate search. Up to 50 keywords per run. |
| `location` | string | `""` | City, state, country, or blank for nationwide. Examples: `"Austin, TX"`, `"United States"`, `"London, UK"`. Applies to every keyword in `searchQueries`. |
| `startUrls` | string\[] | `[]` | Paste BuiltIn URLs directly — search results, category verticals (e.g. `/jobs/engineering`), or company-jobs pages (e.g. `/company/<slug>/jobs`). Filters in the URL are honored as-is. Up to 50 URLs per run. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `remoteMode` | select | `Any` | Workplace type: `Any`, `Remote only`, `Hybrid`, or `On-site only`. |
| `category` | select | `Any` | One of 20 BuiltIn job categories (Engineering, Data & Analytics, AI & Machine Learning, Design, Product Management, Sales, Marketing, etc.). |
| `experienceLevel` | select | `Any` | Years-of-experience tier: Internship, Entry Level (0–1 yrs), Junior (1–2 yrs), Mid Level (2–5 yrs), Senior Level (5–9 yrs), or Expert / Leader (9+ yrs). |
| `postedWithinDays` | select | `Any time` | Recency filter: Last 24 hours, Last 3 days, Last 7 days, or Last 30 days. |

#### Output Control

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResultsPerQuery` | integer | `100` | Maximum number of jobs to collect per keyword or URL. Hard cap of 1,000. The scraper stops requesting new pages once the cap is reached but keeps the full final page even if it slightly overshoots. |
| `fetchDescription` | boolean | `true` | Fetch the full job description, skills array, and apply URL from each listing's detail page. Turn off for ~3× faster runs — but `description`, `descriptionHtml`, `skills`, and `applyUrl` will be empty. |

### Output

One row per job posting. Multi-location jobs surface every city in `location` and the first parsed city/state/country in the dedicated fields.

```json
{
    "jobId": "847291",
    "title": "Senior Software Engineer, Platform",
    "jobUrl": "https://builtin.com/job/senior-software-engineer-platform/847291",
    "company": "Stripe",
    "companyUrl": "https://builtin.com/company/stripe",
    "companyLogoUrl": "https://cdn.builtin.com/cdn-cgi/image/.../stripe-logo.png",
    "companyIndustry": "Fintech • Payments • Software",
    "location": "Austin, TX, USA; Remote",
    "city": "Austin",
    "state": "TX",
    "country": "USA",
    "isRemote": false,
    "workplaceType": "Hybrid",
    "experienceLevel": "5-7 Years Experience",
    "employmentType": "Full-Time",
    "category": ["Information Technology", "Financial Services"],
    "skills": ["Go", "Python", "Kubernetes", "PostgreSQL", "AWS"],
    "salaryText": "180K-240K Annually",
    "salaryMin": 180000,
    "salaryMax": 240000,
    "salaryCurrency": "USD",
    "salaryPeriod": "year",
    "description": "Stripe builds economic infrastructure for the internet...",
    "descriptionHtml": "<p>Stripe builds economic infrastructure for the internet...</p>",
    "postedDate": "2026-05-10",
    "easyApply": false,
    "applyUrl": "https://stripe.com/jobs/listing/senior-software-engineer-platform/847291",
    "searchQuery": "software engineer",
    "searchLocation": "Austin, TX",
    "scrapedAt": "2026-05-15T14:30:00Z"
}
```

#### Core Job Fields

| Field | Type | Description |
|-------|------|-------------|
| `jobId` | string | BuiltIn's unique job identifier |
| `title` | string | Job title |
| `jobUrl` | string | Direct link to the BuiltIn job posting |
| `category` | string\[] | Industry / functional tags for the role |
| `employmentType` | string | Full-Time, Part-Time, Contract, etc. |
| `postedDate` | string | ISO date the job was posted (e.g. `"2026-05-10"`) |
| `scrapedAt` | string | ISO timestamp the row was collected |

#### Company

| Field | Type | Description |
|-------|------|-------------|
| `company` | string | Company name |
| `companyUrl` | string | BuiltIn company profile URL |
| `companyLogoUrl` | string | Company logo image URL |
| `companyIndustry` | string | Bullet-separated industry tags (e.g. `"Fintech • Payments • Software"`) |

#### Location & Workplace

| Field | Type | Description |
|-------|------|-------------|
| `location` | string | Raw location text — semicolon-separated for multi-location jobs |
| `city` | string | First parsed city |
| `state` | string | First parsed state / region code |
| `country` | string | First parsed country (ISO-3 where available) |
| `isRemote` | boolean | True when the job is fully remote |
| `workplaceType` | string | Normalized to `Remote`, `Hybrid`, or `On-site` |
| `experienceLevel` | string | Verbatim experience label from the listing (e.g. `"5-7 Years Experience"`) |

#### Salary, Skills & Description

| Field | Type | Description |
|-------|------|-------------|
| `salaryText` | string | Raw salary band as shown on the card |
| `salaryMin` | number | Parsed minimum salary |
| `salaryMax` | number | Parsed maximum salary |
| `salaryCurrency` | string | Currency code (e.g. `"USD"`) |
| `salaryPeriod` | string | Pay period — `year`, `hour`, or `month` |
| `skills` | string\[] | Required skills array (e.g. `["Python", "AWS"]`) |
| `description` | string | Full job description as plain text |
| `descriptionHtml` | string | Full job description as HTML |

#### Apply & Search Context

| Field | Type | Description |
|-------|------|-------------|
| `easyApply` | boolean | True when BuiltIn's one-click apply is enabled |
| `applyUrl` | string | External apply URL (employer's ATS) when published |
| `searchQuery` | string | The search keyword that produced this row |
| `searchLocation` | string | The location input that produced this row |

### Tips for Best Results

- **Combine keywords and locations in one run** — list every variant in `searchQueries` (e.g. `["software engineer", "backend engineer", "platform engineer"]`) with a single `location`, and the scraper runs each keyword separately and deduplicates by `jobId` per query.
- **Use `location: ""` + `remoteMode: "remote"`** to capture every fully-remote tech role nationwide — BuiltIn's `/jobs/remote` segment is the cleanest source of nationwide remote listings.
- **Filter to salary-transparent roles** — after the run, drop rows where `salaryMin` is null. BuiltIn publishes pay on roughly half of all listings, and the structured fields make this a one-line filter.
- **For daily monitoring, set `postedWithinDays: "1"`** and schedule the actor for a 24-hour cadence — you get only fresh listings without re-paying for yesterday's results.
- **Turn off `fetchDescription` for large keyword sweeps** when you only need title + company + salary + skills — runs go about 3× faster because BuiltIn's per-job detail fetch is the slow step.
- **Paste a category vertical as a `startUrl`** (e.g. `https://builtin.com/jobs/cyber-security`) for the cleanest single-category pull — BuiltIn's category URLs already filter out misclassified roles.
- **Cap at 1,000 per query** — BuiltIn's own pagination ceiling is ~10,000, but results start repeating beyond the first 1,000 unique IDs. Stay under the cap or split into narrower searches by city + seniority.

### Pricing

**$0.95 per 1,000 results** — you only pay for job rows that land in your dataset. No compute, storage, or per-page fees on top.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.10 |
| 1,000 | $0.95 |
| 10,000 | $9.50 |
| 100,000 | $95.00 |

A "result" is one job row in the output dataset, deduplicated by job ID. Apify platform fees (compute units, storage) follow your plan and are billed separately.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is built for legitimate recruiting, sales prospecting, market research, and job-hunting workflows. Users are responsible for complying with applicable laws and BuiltIn's Terms of Service. Do not use extracted data for spam, harassment, discriminatory hiring practices, or any unlawful purpose. When using contact or hiring data, follow fair-hiring regulations and anti-spam laws (GDPR, CAN-SPAM, CCPA) in your jurisdiction.

# Actor input Schema

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

Job titles or keywords to search for, such as 'python developer' or 'data scientist'. Each keyword runs a separate search. Up to 50 keywords per run.

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

Where to search for jobs. Enter a city, state, country, or leave blank for nationwide. Example: 'Austin, TX' or 'United States'. Applies to every keyword in 'Search Keywords'.

## `remoteMode` (type: `string`):

Filter by where the job is performed.

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

Paste full BuiltIn URLs — search results (https://builtin.com/jobs?...), category verticals (https://builtin.com/jobs/engineering), or company-jobs pages (https://builtin.com/company/<slug>/jobs). Filters in the URL are honored as-is. Up to 50 URLs per run.

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

BuiltIn's top-level job category. Leave on 'Any' to search all categories.

## `experienceLevel` (type: `string`):

Filter by years-of-experience tier.

## `postedWithinDays` (type: `string`):

Only show jobs posted within this time period.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of jobs to collect per search keyword or URL. Hard cap of 1,000 per query — BuiltIn paginates 25 jobs/page, and beyond ~40 pages results start repeating. Cross-page deduplication is applied by job ID. The actor stops requesting new pages once the cap is reached but keeps the full final page even if it slightly overshoots.

## `fetchDescription` (type: `boolean`):

Fetch the full job description, skills array, and apply URL from each listing's detail page. Leave on for the most complete data. Turn off to make runs about 3x faster — but the description, descriptionHtml, skills, and applyUrl fields will be empty.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer"
  ],
  "remoteMode": "any",
  "startUrls": [],
  "category": "",
  "experienceLevel": "",
  "postedWithinDays": "",
  "maxResultsPerQuery": 100,
  "fetchDescription": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped job listings with key fields.

## `detail` (type: `string`):

Complete job data including descriptions, skills, structured salary fields, and company enrichment.

# 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": [
        "software engineer"
    ],
    "location": "",
    "remoteMode": "any",
    "startUrls": [],
    "category": "",
    "experienceLevel": "",
    "postedWithinDays": "",
    "maxResultsPerQuery": 100,
    "fetchDescription": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/builtin-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": ["software engineer"],
    "location": "",
    "remoteMode": "any",
    "startUrls": [],
    "category": "",
    "experienceLevel": "",
    "postedWithinDays": "",
    "maxResultsPerQuery": 100,
    "fetchDescription": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/builtin-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 '{
  "searchQueries": [
    "software engineer"
  ],
  "location": "",
  "remoteMode": "any",
  "startUrls": [],
  "category": "",
  "experienceLevel": "",
  "postedWithinDays": "",
  "maxResultsPerQuery": 100,
  "fetchDescription": true
}' |
apify call solidcode/builtin-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BuiltIn Jobs Scraper",
        "description": "[💰 $0.95 / 1K] Extract tech job listings from BuiltIn.com — titles, companies, salaries, locations, remote/hybrid status, experience level, skills, and full job descriptions. Filter by keyword, location, category, seniority, workplace type, and posted date.",
        "version": "1.0",
        "x-build-id": "vv5WLlzDVvcQOvtlN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~builtin-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-builtin-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~builtin-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-builtin-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~builtin-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-builtin-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search Keywords",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Job titles or keywords to search for, such as 'python developer' or 'data scientist'. Each keyword runs a separate search. Up to 50 keywords per run.",
                        "default": [
                            "software engineer"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Where to search for jobs. Enter a city, state, country, or leave blank for nationwide. Example: 'Austin, TX' or 'United States'. Applies to every keyword in 'Search Keywords'."
                    },
                    "remoteMode": {
                        "title": "Workplace Type",
                        "enum": [
                            "any",
                            "remote",
                            "hybrid",
                            "office"
                        ],
                        "type": "string",
                        "description": "Filter by where the job is performed.",
                        "default": "any"
                    },
                    "startUrls": {
                        "title": "Direct BuiltIn URLs",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Paste full BuiltIn URLs — search results (https://builtin.com/jobs?...), category verticals (https://builtin.com/jobs/engineering), or company-jobs pages (https://builtin.com/company/<slug>/jobs). Filters in the URL are honored as-is. Up to 50 URLs per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Job Category",
                        "enum": [
                            "",
                            "ai-machine-learning",
                            "consultant",
                            "customer-success-experience",
                            "cyber-security",
                            "data-analytics",
                            "defense-field-operations",
                            "designer",
                            "engineering",
                            "finance",
                            "healthcare-services",
                            "hr-recruiting",
                            "legal",
                            "manufacturing-production",
                            "marketing",
                            "operations-support",
                            "product-management",
                            "program-project-management",
                            "research",
                            "sales",
                            "supply-chain-procurement"
                        ],
                        "type": "string",
                        "description": "BuiltIn's top-level job category. Leave on 'Any' to search all categories.",
                        "default": ""
                    },
                    "experienceLevel": {
                        "title": "Experience Level",
                        "enum": [
                            "",
                            "internship",
                            "entry-level",
                            "junior",
                            "mid-level",
                            "senior",
                            "expert-leader"
                        ],
                        "type": "string",
                        "description": "Filter by years-of-experience tier.",
                        "default": ""
                    },
                    "postedWithinDays": {
                        "title": "Posted Within",
                        "enum": [
                            "",
                            "1",
                            "3",
                            "7",
                            "30"
                        ],
                        "type": "string",
                        "description": "Only show jobs posted within this time period.",
                        "default": ""
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Results per Query",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of jobs to collect per search keyword or URL. Hard cap of 1,000 per query — BuiltIn paginates 25 jobs/page, and beyond ~40 pages results start repeating. Cross-page deduplication is applied by job ID. The actor stops requesting new pages once the cap is reached but keeps the full final page even if it slightly overshoots.",
                        "default": 100
                    },
                    "fetchDescription": {
                        "title": "Fetch Full Job Descriptions",
                        "type": "boolean",
                        "description": "Fetch the full job description, skills array, and apply URL from each listing's detail page. Leave on for the most complete data. Turn off to make runs about 3x faster — but the description, descriptionHtml, skills, and applyUrl fields will be empty.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```