# AI Job Search - Semantic Search by Meaning, Not Keywords (`hirebase/ai-job-search`) Actor

Describe the job you want in plain English and get the best-matching live jobs, ranked by meaning - not keyword overlap. Semantic AI search over 4M+ jobs scraped directly from company career pages, with no expired or ghost jobs. Combine with filters for location, remote, salary, experience and more.

- **URL**: https://apify.com/hirebase/ai-job-search.md
- **Developed by:** [Hirebase](https://apify.com/hirebase) (community)
- **Stats:** 3 total users, 2 monthly users, 100.0% 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## AI Job Search - Semantic Search by Meaning, Not Keywords

Describe the job you want in plain English and get back the **best-matching live jobs, ranked by meaning** - not by which postings happen to repeat your keywords. Semantic AI search over **4,000,000+ jobs** scraped directly from company career pages, with expired and ghost jobs filtered out. Powered by [Hirebase](https://www.hirebase.org).

Keyword search only finds the words you spell. A search for *registered nurse* skips the hospital that posts *"RN - Trauma ICU"*; this actor understands they mean the same thing - in the example below, 34 of the 300 results are titled only "RN", and a keyword search would have missed every one.

**Why this actor?**

- 🧠 **Search by meaning** - write the query the way you'd brief a recruiter: *"senior backend engineer building payment systems in Go at a fintech"*.
- 🏆 **Ranked results** - every job carries a `rank`, 1 = closest match, so the first rows are the ones to read.
- 🎯 **Semantic + filters in one run** - combine the query with remote/hybrid, location and radius, salary, experience, industry, company size and more.
- 🚫 **No expired or ghost jobs** - listings come straight from employer career pages and are removed when they go offline.
- ♻️ **Duplicates dropped before you pay** - the same role posted in ten cities is saved once by default.

### How to use it

1. Type what you're looking for into **What job are you looking for?**
2. Optionally narrow it down: workplace type, locations, experience level, salary, industry, posted date.
3. Set **Max results** (up to 2,500) and run.

Results come back best match first. To keep only close matches, set **Minimum match strength** - around 60% keeps most relevant jobs, 65-70% keeps only the closest few, and 75% or more usually returns nothing.

### Example input

```json
{
  "query": "registered nurse in an ICU night shift",
  "locationTypes": ["In-Person"],
  "maxResults": 300
}
```

### Output

A real result from the query above (run 2026-09-22; rankings move day to day as postings open and close):

```json
{
  "rank": 1,
  "jobTitle": "Registered Nurse (RN) - ICU Nights PRN",
  "companyName": "Community Health Systems",
  "companyWebsite": "https://chs.net",
  "applicationLink": "https://fa-evxo-saasfaprod1.fa.ocs.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1/job/161707",
  "datePosted": "2026-09-22",
  "locationType": "In-Person",
  "location": "Vicksburg, MS, United States",
  "jobType": "Full Time",
  "jobCategories": ["Healthcare Services Jobs"],
  "yearsOfExperience": { "min": 0, "max": 2 },
  "salaryRange": null,
  "requirementsSummary": "The RN must have 0-2 years of experience in a clinical nursing role or student clinical rotations in an acute care setting and hold a valid RN license",
  "visaSponsored": false,
  "jobBoard": "oraclecloud",
  "jobSlug": "registered-nurse-rn-icu-nights-prn-84c57924",
  "companySlug": "community-health-systems"
}
```

The rest of the top five were ICU nursing roles at Wellstar, Tenet and University Hospitals. At #11 and #12 came *RN - Trauma ICU* (Carilion Clinic) and *RN - Neonatal ICU Nights* (UT Southwestern) - neither title contains "registered nurse", so a keyword search would have missed both.

Each result also includes company logo, structured locations, skills, education level, recruiting-agency flag, company profile data, quality scores, a cleaned text description and the original HTML. Export to JSON, CSV or Excel, or pipe into Make, n8n, Zapier, Google Sheets or the Apify API.

### Great for

- **Job seekers and career tools** - "find me roles like this one" without guessing every title variant.
- **Recruiters and sourcers** - map a hard-to-name role (*"founding engineer who has shipped developer tools"*) across every employer hiring for it.
- **Job boards and newsletters** - build curated, on-theme lists from a single description.
- **AI agents** - hand an LLM's natural-language request straight to the search.

### Pricing

Pay per result - you are only charged for jobs actually saved, up to **2,500 results per run**. Duplicates skipped by the dedupe setting are never charged.

### FAQ

**Do I need an API key?**
No - API access is built into the actor. Describe the job and run.

**How is this different from the Job Search Scraper?**
The Job Search Scraper matches exact keywords and titles and can page through millions of results - use it when you know the precise words or want complete coverage of a filter. This actor ranks by meaning and returns the most relevant 2,500 - use it when the right jobs are described in many different ways.

**Why is it capped at 2,500 results?**
Semantic search is a relevance ranking: it returns the closest 2,500 matches for your query. Past that point results are rarely relevant. For bulk exports of everything matching a filter, use the Job Search Scraper.

**Is there a relevance score?**
Results are returned in relevance order and numbered with `rank`. A numeric similarity score is not exposed - use **Minimum match strength** to cut off weak matches instead.

**Which filters work with AI search?**
Workplace type, locations and radius, employment type, experience level, years of experience, posted date, ATS platform, industry (one at a time), company name and size, recruiting agencies, salary and visa sponsorship - each checked against live results. Job categories and sub-industries are not supported by AI search: put them in the query instead (*"data analyst at a fintech"*). Sorting is not offered - results are always ordered by match.

**Can I run it on a schedule?**
Yes - add *Posted within (days)* = `1` and run it on an Apify Schedule to get fresh matches for your description every day.

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

# Actor input Schema

## `query` (type: `string`):

Describe the role in plain language, the way you would explain it to a recruiter. Jobs are ranked by how closely they match the meaning, not by exact keywords - e.g. <code>senior backend engineer building payment systems in Go at a fintech</code>.

## `minMatchStrength` (type: `integer`):

Only keep jobs that match your query at least this closely. Leave empty to get the best matches whatever their strength. Matches thin out fast: around 60% keeps most relevant jobs, 65-70% keeps only the closest few, and 75% or more usually returns nothing.

## `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>).

## `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: `string`):

Only jobs at companies in this industry sector. The AI search filters on one industry at a time.

## `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.

## `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.

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

Maximum number of jobs to save, best matches first (up to 2,500 - the most relevant results the AI search returns). You are only charged for results actually returned.

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

Skip duplicate postings before they are saved (and billed). Semantic search ranks the same role posted in several locations side by side, so <code>Company + job title</code> is on by default.

## Actor input object example

```json
{
  "query": "Senior backend engineer building distributed systems with Python and Kubernetes",
  "locationTypes": [
    "Remote"
  ],
  "geoFilterMode": "auto",
  "geoRadiusUnit": "mi",
  "includeJobsWithoutYoe": true,
  "hideRecruitingAgencies": false,
  "currency": "USD",
  "includeJobsWithoutSalary": true,
  "visaSponsorship": "any",
  "maxResults": 50,
  "dedupeBy": "companyAndTitle"
}
```

# Actor output Schema

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

Jobs ranked by how closely they match your query, 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 = {
    "query": "Senior backend engineer building distributed systems with Python and Kubernetes",
    "locationTypes": [
        "Remote"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hirebase/ai-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 = {
    "query": "Senior backend engineer building distributed systems with Python and Kubernetes",
    "locationTypes": ["Remote"],
}

# Run the Actor and wait for it to finish
run = client.actor("hirebase/ai-job-search").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "Senior backend engineer building distributed systems with Python and Kubernetes",
  "locationTypes": [
    "Remote"
  ]
}' |
apify call hirebase/ai-job-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hirebase/ai-job-search"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0kpuy8gim7cExV4N9/builds/FZebVfwhHEpGVDZBW/openapi.json