# Job Search Scraper - Direct from Company Career Pages (`hirebase/job-search`) Actor

Search 4M+ live jobs scraped directly from company career pages (Greenhouse, Workday, Lever & 20+ ATS platforms). No job-board reposts, no expired or ghost jobs. Filter by keyword, title, category, location, remote, salary, experience, visa sponsorship and more.

- **URL**: https://apify.com/hirebase/job-search.md
- **Developed by:** [Hirebase](https://apify.com/hirebase) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 4 total users, 2 monthly users, 76.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Job Search Scraper - Direct from Company Career Pages

Search **4M+ live job listings** collected straight from company career pages across 20+ ATS platforms - Greenhouse, Workday, Lever, iCIMS, SmartRecruiters, SAP SuccessFactors, and more. Powered by [Hirebase](https://www.hirebase.org).

**Why this scraper instead of scraping LinkedIn or Indeed?**

- 🎯 **Direct from the source** - jobs come from the employer's own career page, not aggregator reposts.
- 🚫 **No expired or ghost jobs** - listings are continuously re-checked and removed when they go offline.
- 🏢 **No duplicate spam** - one canonical listing per job, with the real application link.
- 🧠 **AI-enriched fields** - parsed skills, technologies, salary ranges, experience level, visa sponsorship, benefits, and quality scores for every job.

### What you can filter by

| Filter | Examples |
|---|---|
| Keywords | `Python`, `Kubernetes`, `HIPAA` |
| Job titles | `Software Engineer`, `Account Executive` |
| Job categories | 39 categories, from Software Engineering to Healthcare |
| Workplace type | Remote, Hybrid, In-Person |
| Location | `Austin, Texas, United States` · `Berlin, Germany` + match mode & radius (miles/km) |
| Employment type | Full-time, Part-time, Contract, Internship |
| Experience | Entry → Executive, plus exact years-of-experience min/max |
| Posted | Last N days, or on/after an exact date (`YYYY-MM-DD`) |
| ATS platform | Greenhouse, Workday, Lever, and 19 more |
| Industry | 23 sectors + sub-industry tags |
| Company | Name, Hirebase slug, description keywords (`fintech`, `healthcare AI`), size |
| Salary | Min/max + currency, hide undisclosed |
| Extras | Visa sponsorship, hide recruiting agencies, deduplicate multi-location postings |

### Output

Each result includes: job title, company (name, slug, website, logo), team, direct application link, original job-board link, posting date, location(s), workplace type, employment type, salary range, years of experience, parsed skills & technologies, benefits, education level, visa sponsorship, stable job/company slugs for syncing, plus a cleaned text description and the original HTML.

Export to JSON, CSV, Excel, or feed it into [Make](https://www.make.com), n8n, Zapier, Google Sheets, or the Apify API.

```json
{
  "jobTitle": "Software Engineer, Data Infrastructure",
  "companyName": "Speechify",
  "applicationLink": "https://job-boards.greenhouse.io/speechify/jobs/5975137004",
  "datePosted": "2026-07-18",
  "locationType": "Remote",
  "location": "Dublin, Ireland",
  "jobType": "Full Time",
  "salaryRange": { "min": 30000, "max": 120000, "currency": "USD", "period": "yearly" },
  "skills": ["Python", "Docker", "Terraform"],
  "visaSponsored": true,
  "jobBoard": "greenhouse"
}
````

### Example searches

**Job seeker - daily remote SWE digest.** Keywords `Software Engineer`, workplace type *Remote*, experience *Senior*, minimum salary `150000`, posted within `7` days. Run it on an [Apify Schedule](https://docs.apify.com/platform/schedules) every morning and add the Gmail or Slack integration to get new matches in your inbox.

**Recruiter - map a niche talent market.** Job category *Sales Jobs*, company size `51-200`, company keywords `fintech`, *Hide recruiting agencies* on. Export to Excel and you have every mid-size fintech's live sales hiring in one sheet.

**Data team - keep a job board fresh.** One category per scheduled run, `maxResults` 5000, *Deduplicate results* set to Company + job title. Sync by `jobSlug`/`id`: anything in your database that stops appearing in fresh runs has expired and can be delisted.

### Pricing

Pay per result - you're only charged for jobs actually returned, up to **5,000 results per run**.

### FAQ

**Do I need a Hirebase account or API key?**
No - API access is built into the actor. Just set your filters and run; you only pay per result through Apify.

**Why do I sometimes see the same job more than once?**
Some employers publish one posting per location. Set *Deduplicate results* to `Company + job title` to collapse them - skipped duplicates are not billed.

**Why did my run fail with a rate limit error?**
The Hirebase API was temporarily busy. Re-run in a few minutes - if it keeps happening, report it via the actor's Issues tab.

**I searched several keywords and got unrelated jobs - why?**
Keywords broaden the search: each keyword adds matches (OR logic) rather than narrowing them. For precise searches, use one focused keyword or combine the *Job titles* / *Job categories* filters with your keyword.

**How fresh is the data?**
Career pages are crawled continuously; expired listings are filtered out, and you can restrict results to jobs posted in the last N days.

**Can I run it on a schedule?**
Yes - use Apify Schedules to run it hourly/daily and combine with `Posted within (days) = 1` to get only new jobs each run.

**Is this legal?**
The data comes from publicly posted job listings on company career pages, accessed via the Hirebase API.

# Actor input Schema

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

Match anywhere in job descriptions, skills, technologies, and benefits (e.g. <code>Python</code>, <code>Kubernetes</code>).

## `jobTitles` (type: `array`):

Match against parsed job titles (e.g. <code>Software Engineer</code>, <code>Product Manager</code>).

## `jobCategories` (type: `array`):

Limit results to one or more Hirebase job categories.

## `locationTypes` (type: `array`):

Remote, hybrid, or in-person roles.

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

One per line, as <code>City, Region, Country</code>, <code>City, Country</code>, or just <code>City</code> (e.g. <code>Austin, Texas, United States</code>).

## `geoFilterMode` (type: `string`):

How strictly locations are matched: <code>auto</code> picks a sensible default, <code>strict</code> requires an exact area match, <code>weak</code> is more forgiving, <code>box</code> uses a bounding box. Only applies when Locations are set.

## `geoRadius` (type: `integer`):

Search radius around each location (default 25). Only applies when Locations are set.

## `geoRadiusUnit` (type: `string`):

Unit for the location radius.

## `jobTypes` (type: `array`):

Full-time, part-time, contract, or internship.

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

Seniority of the role.

## `yoeMin` (type: `integer`):

Only jobs asking for at least this many years of experience.

## `yoeMax` (type: `integer`):

Only jobs asking for at most this many years of experience.

## `includeJobsWithoutYoe` (type: `boolean`):

When using a years-of-experience filter, also keep jobs that don't state a number.

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

Only jobs posted in the last N days. Leave empty for all.

## `postedOnOrAfter` (type: `string`):

Only jobs posted on or after this exact date, as <code>YYYY-MM-DD</code> (e.g. <code>2026-07-01</code>). Overrides "Posted within (days)" if both are set.

## `atsPlatforms` (type: `array`):

Only jobs scraped directly from these applicant tracking systems / career-page platforms.

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

Company industry sectors.

## `subIndustries` (type: `array`):

Narrower company sub-industry tags (e.g. <code>Fintech</code>). Note: this filter is being rolled out on the Hirebase side and may not narrow results yet.

## `companyName` (type: `string`):

Only jobs from this specific company.

## `companySlug` (type: `string`):

Exact Hirebase company slug (from a company's Hirebase URL), for precise company targeting.

## `companyKeywords` (type: `array`):

Match in company descriptions, services, and products (e.g. <code>fintech</code>, <code>healthcare AI</code>).

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

Company headcount buckets.

## `hideRecruitingAgencies` (type: `boolean`):

Exclude postings from recruiters and staffing agencies.

## `salaryMin` (type: `integer`):

Only jobs whose salary range reaches at least this amount (annual).

## `salaryMax` (type: `integer`):

Only jobs whose salary range starts at or below this amount (annual).

## `currency` (type: `string`):

Currency for the salary filter.

## `includeJobsWithoutSalary` (type: `boolean`):

When using a salary filter, also keep jobs that don't disclose salary.

## `visaSponsorship` (type: `string`):

Filter by whether the job offers visa sponsorship.

## `fullDescriptionHtml` (type: `boolean`):

Return the complete raw HTML description from the ATS instead of the cleaned summary.

## `sortBy` (type: `string`):

Order of results.

## `sortOrder` (type: `string`):

Ascending or descending.

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

Maximum number of jobs to save (hard cap 5,000 per run). You are only charged for results actually returned.

## `dedupeBy` (type: `string`):

Skip duplicate postings before they are saved (and billed). <code>Company + job title</code> collapses the same role posted once per location; <code>Content hash</code> only drops byte-identical postings.

## Actor input object example

```json
{
  "keywords": [
    "Python"
  ],
  "geoFilterMode": "auto",
  "geoRadiusUnit": "mi",
  "includeJobsWithoutYoe": true,
  "hideRecruitingAgencies": false,
  "currency": "USD",
  "includeJobsWithoutSalary": true,
  "visaSponsorship": "any",
  "fullDescriptionHtml": false,
  "sortBy": "date_posted",
  "sortOrder": "desc",
  "maxResults": 100,
  "dedupeBy": "none"
}
```

# Actor output Schema

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

Every job matching your filters, one dataset item per job.

# 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": [
        "Python"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hirebase/job-search").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": ["Python"] }

# Run the Actor and wait for it to finish
run = client.actor("hirebase/job-search").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": [
    "Python"
  ]
}' |
apify call hirebase/job-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Job Search Scraper - Direct from Company Career Pages",
        "description": "Search 4M+ live jobs scraped directly from company career pages (Greenhouse, Workday, Lever & 20+ ATS platforms). No job-board reposts, no expired or ghost jobs. Filter by keyword, title, category, location, remote, salary, experience, visa sponsorship and more.",
        "version": "1.0",
        "x-build-id": "XMrZP4w7nRWX7QV7W"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hirebase~job-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hirebase-job-search",
                "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/hirebase~job-search/runs": {
            "post": {
                "operationId": "runs-sync-hirebase-job-search",
                "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/hirebase~job-search/run-sync": {
            "post": {
                "operationId": "run-sync-hirebase-job-search",
                "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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Match anywhere in job descriptions, skills, technologies, and benefits (e.g. <code>Python</code>, <code>Kubernetes</code>).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobTitles": {
                        "title": "Job titles",
                        "type": "array",
                        "description": "Match against parsed job titles (e.g. <code>Software Engineer</code>, <code>Product Manager</code>).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobCategories": {
                        "title": "Job categories",
                        "type": "array",
                        "description": "Limit results to one or more Hirebase job categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Accounting, Payroll & Financial Planning Jobs",
                                "Administration Jobs",
                                "Arts and Design Jobs",
                                "Banking Jobs",
                                "Business Development Jobs",
                                "Business Operations & Strategy Jobs",
                                "Community and Social Services Jobs",
                                "Consulting Jobs",
                                "Culinary Jobs",
                                "Customer Support & Success Jobs",
                                "Data Analyst Jobs",
                                "Driver and Delivery Jobs",
                                "Education Jobs",
                                "Engineering Jobs",
                                "Finance Jobs",
                                "Healthcare Services Jobs",
                                "Hospitality Jobs",
                                "Human Resources Jobs",
                                "Information Technology Jobs",
                                "Insurance Jobs",
                                "IT Support Jobs",
                                "Legal Jobs",
                                "Marketing Jobs",
                                "Media and Communication Jobs",
                                "Operations Jobs",
                                "Product Jobs",
                                "Project & Program Management Jobs",
                                "Purchasing Jobs",
                                "Quality Assurance Jobs",
                                "Real Estate Jobs",
                                "Recruitment Jobs",
                                "Research Jobs",
                                "Retail Jobs",
                                "Risk and Compliance Jobs",
                                "Sales Jobs",
                                "Security Engineer Jobs",
                                "Skilled Trade Jobs",
                                "Software Engineer Jobs",
                                "Support Engineer Jobs"
                            ]
                        }
                    },
                    "locationTypes": {
                        "title": "Workplace type",
                        "type": "array",
                        "description": "Remote, hybrid, or in-person roles.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Remote",
                                "Hybrid",
                                "In-Person"
                            ]
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "One per line, as <code>City, Region, Country</code>, <code>City, Country</code>, or just <code>City</code> (e.g. <code>Austin, Texas, United States</code>).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "geoFilterMode": {
                        "title": "Location match mode",
                        "enum": [
                            "auto",
                            "weak",
                            "strict",
                            "box"
                        ],
                        "type": "string",
                        "description": "How strictly locations are matched: <code>auto</code> picks a sensible default, <code>strict</code> requires an exact area match, <code>weak</code> is more forgiving, <code>box</code> uses a bounding box. Only applies when Locations are set.",
                        "default": "auto"
                    },
                    "geoRadius": {
                        "title": "Location radius",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Search radius around each location (default 25). Only applies when Locations are set."
                    },
                    "geoRadiusUnit": {
                        "title": "Radius unit",
                        "enum": [
                            "mi",
                            "km",
                            "degrees"
                        ],
                        "type": "string",
                        "description": "Unit for the location radius.",
                        "default": "mi"
                    },
                    "jobTypes": {
                        "title": "Employment type",
                        "type": "array",
                        "description": "Full-time, part-time, contract, or internship.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Full Time",
                                "Part Time",
                                "Contract",
                                "Internship"
                            ]
                        }
                    },
                    "experienceLevels": {
                        "title": "Experience level",
                        "type": "array",
                        "description": "Seniority of the role.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Entry",
                                "Junior",
                                "Mid",
                                "Senior",
                                "Executive"
                            ]
                        }
                    },
                    "yoeMin": {
                        "title": "Minimum years of experience",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Only jobs asking for at least this many years of experience."
                    },
                    "yoeMax": {
                        "title": "Maximum years of experience",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Only jobs asking for at most this many years of experience."
                    },
                    "includeJobsWithoutYoe": {
                        "title": "Include jobs without experience data",
                        "type": "boolean",
                        "description": "When using a years-of-experience filter, also keep jobs that don't state a number.",
                        "default": true
                    },
                    "postedWithinDays": {
                        "title": "Posted within (days)",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Only jobs posted in the last N days. Leave empty for all."
                    },
                    "postedOnOrAfter": {
                        "title": "Posted on or after (date)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only jobs posted on or after this exact date, as <code>YYYY-MM-DD</code> (e.g. <code>2026-07-01</code>). Overrides \"Posted within (days)\" if both are set."
                    },
                    "atsPlatforms": {
                        "title": "ATS platforms",
                        "type": "array",
                        "description": "Only jobs scraped directly from these applicant tracking systems / career-page platforms.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "workday",
                                "oraclecloud",
                                "successfactors",
                                "icims",
                                "smartrecruiters",
                                "greenhouse",
                                "workable",
                                "paylocity",
                                "eightfold",
                                "dayforce",
                                "jazzhr",
                                "lever",
                                "taleo",
                                "paycom",
                                "adp",
                                "jobvite",
                                "ashby",
                                "bamboohr",
                                "recruitee",
                                "teamtailor",
                                "rippling",
                                "personio"
                            ],
                            "enumTitles": [
                                "Workday",
                                "Oracle Cloud (Taleo Cloud)",
                                "SAP SuccessFactors",
                                "iCIMS",
                                "SmartRecruiters",
                                "Greenhouse",
                                "Workable",
                                "Paylocity",
                                "Eightfold",
                                "Dayforce",
                                "JazzHR",
                                "Lever",
                                "Taleo",
                                "Paycom",
                                "ADP Workforce Now",
                                "Jobvite",
                                "Ashby",
                                "BambooHR",
                                "Recruitee",
                                "Teamtailor",
                                "Rippling",
                                "Personio"
                            ]
                        }
                    },
                    "industries": {
                        "title": "Industries",
                        "type": "array",
                        "description": "Company industry sectors.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Agriculture",
                                "Arts",
                                "Construction",
                                "Consumer Goods",
                                "Corporate Services",
                                "Design",
                                "Education",
                                "Energy & Mining",
                                "Entertainment",
                                "Finance",
                                "Healthcare",
                                "Legal",
                                "Manufacturing",
                                "Media & Communications",
                                "Nonprofit",
                                "Public Administration",
                                "Public Safety",
                                "Real Estate",
                                "Recreation & Travel",
                                "Retail & Wholesale",
                                "Tech/Software & IT Services",
                                "Transportation & Logistics",
                                "Wellness & Fitness"
                            ]
                        }
                    },
                    "subIndustries": {
                        "title": "Sub-industries",
                        "type": "array",
                        "description": "Narrower company sub-industry tags (e.g. <code>Fintech</code>). Note: this filter is being rolled out on the Hirebase side and may not narrow results yet.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyName": {
                        "title": "Company name",
                        "type": "string",
                        "description": "Only jobs from this specific company."
                    },
                    "companySlug": {
                        "title": "Company slug",
                        "type": "string",
                        "description": "Exact Hirebase company slug (from a company's Hirebase URL), for precise company targeting."
                    },
                    "companyKeywords": {
                        "title": "Company keywords",
                        "type": "array",
                        "description": "Match in company descriptions, services, and products (e.g. <code>fintech</code>, <code>healthcare AI</code>).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companySizes": {
                        "title": "Company size",
                        "type": "array",
                        "description": "Company headcount buckets.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1-10",
                                "11-50",
                                "51-200",
                                "201-500",
                                "501-1000",
                                "1001-5000",
                                "5001-10000",
                                "10001+"
                            ]
                        }
                    },
                    "hideRecruitingAgencies": {
                        "title": "Hide recruiting agencies",
                        "type": "boolean",
                        "description": "Exclude postings from recruiters and staffing agencies.",
                        "default": false
                    },
                    "salaryMin": {
                        "title": "Minimum salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only jobs whose salary range reaches at least this amount (annual)."
                    },
                    "salaryMax": {
                        "title": "Maximum salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only jobs whose salary range starts at or below this amount (annual)."
                    },
                    "currency": {
                        "title": "Salary currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "CAD",
                            "AUD",
                            "INR",
                            "CHF",
                            "SEK",
                            "NOK",
                            "DKK",
                            "PLN",
                            "BRL",
                            "JPY",
                            "SGD"
                        ],
                        "type": "string",
                        "description": "Currency for the salary filter.",
                        "default": "USD"
                    },
                    "includeJobsWithoutSalary": {
                        "title": "Include jobs without salary data",
                        "type": "boolean",
                        "description": "When using a salary filter, also keep jobs that don't disclose salary.",
                        "default": true
                    },
                    "visaSponsorship": {
                        "title": "Visa sponsorship",
                        "enum": [
                            "any",
                            "yes",
                            "no"
                        ],
                        "type": "string",
                        "description": "Filter by whether the job offers visa sponsorship.",
                        "default": "any"
                    },
                    "fullDescriptionHtml": {
                        "title": "Full original description (HTML)",
                        "type": "boolean",
                        "description": "Return the complete raw HTML description from the ATS instead of the cleaned summary.",
                        "default": false
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "date_posted",
                            "salary",
                            "company",
                            "yoe"
                        ],
                        "type": "string",
                        "description": "Order of results.",
                        "default": "date_posted"
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "desc",
                            "asc"
                        ],
                        "type": "string",
                        "description": "Ascending or descending.",
                        "default": "desc"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of jobs to save (hard cap 5,000 per run). You are only charged for results actually returned.",
                        "default": 100
                    },
                    "dedupeBy": {
                        "title": "Deduplicate results",
                        "enum": [
                            "none",
                            "companyAndTitle",
                            "md5Hash"
                        ],
                        "type": "string",
                        "description": "Skip duplicate postings before they are saved (and billed). <code>Company + job title</code> collapses the same role posted once per location; <code>Content hash</code> only drops byte-identical postings.",
                        "default": "none"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
