# AI Job Search Agent — No API Key Needed (`nomad-agent/ai-job-search-agent`) Actor

AI agent that scans the open web for job postings beyond any single job board — no API key required, the AI is included. Returns an LLM match score with reasoning, salary, and HTTP-verified live links, with delta new-only monitoring for cheap scheduled runs.

- **URL**: https://apify.com/nomad-agent/ai-job-search-agent.md
- **Developed by:** [Nomad.Dev](https://apify.com/nomad-agent) (community)
- **Categories:** Jobs, AI, Agents
- **Stats:** 3 total users, 2 monthly users, 71.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 job results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

# README

## AI Job Search Agent — No API Key Needed

An AI agent that hunts the **open web** for job postings matching your query — company career pages, ATS boards, niche sites, anywhere a single job board wouldn't cover.

**No API key. No LLM account. No setup.** Type what you're looking for, hit Run. The AI is included in the price.

> **Claude / Codex skill to describe and setup this actor: [SKILL.md](https://github.com/Exdenta/OinkAIJobSearch/blob/main/skill/ai-job-search-agent/SKILL.md)**

> Most "AI job" tools on the store either just re-serve one board's index, or make you go get an Anthropic/OpenAI key first. This one searches the live web itself, and the AI comes bundled.

### Why this and not a job-board scraper

| | Board scrapers (LinkedIn, Indeed, Hiring.Cafe…) | **This agent** |
|---|---|---|
| Coverage | One board's index | The **open web** — employer career pages + ATS boards that never hit a big board |
| Ranking | Keyword match | **LLM match score 0-100 with a written reason**, best-first |
| Dead links | Common | Every link **HTTP-verified live** before it's returned |
| Salary | Only if the board has a field | Copied **verbatim from the posting**, never guessed |
| Setup | — | **No API key needed** |

### What you get

One flat JSON record per job posting, sorted best-match-first.

| Field | Meaning |
|---|---|
| `matchScore` | **0-100 LLM rating** of how well this posting fits your request |
| `matchReasoning` | One sentence on *why* it scored that — the fit/mismatch signals it weighed |
| `title` | Job title, copied character-for-character from the posting |
| `company` | Hiring company / organisation |
| `location` | Location (may include remote hints) |
| `salary` | Compensation **exactly as stated** on the posting (`"$120k–$150k"`, `"Competitive"`). `null` when the posting states none — the agent never invents a figure |
| `url` | Direct link to the posting on the employer's own site or their ATS |
| `postedAt` | Posting date (`YYYY-MM-DD`) |
| `snippet` | 1-3 sentence summary of the role |
| `verified` | `true` only when the live-link check actually confirmed the URL |
| `isNew` | Present on delta runs — posting not seen in a previous run |

### Input

Everything is optional — describe the job in plain English and let the agent do the rest.

```json
{
  "keywords": ["python", "backend"],
  "locations": ["remote"],
  "userDescription": "Senior Python backend engineer, fully remote, product company. Prefer fintech or dev tooling.",
  "remote": "remote-only",
  "seniority": "senior",
  "titleExclude": ["intern"],
  "maxItems": 15,
  "onlyNewSinceLastRun": false
}
```

`userDescription` is the strongest signal — it's what each posting's `matchScore` is judged against.

### Cheap job alerts: `onlyNewSinceLastRun`

Turn it on and schedule the actor. Postings already seen in a previous run are dropped **before** they're pushed, so **you are not billed for them**. A daily run then costs only whatever is genuinely new that day — often a handful of results, sometimes zero.

### Pricing

**$0.005 per run start + $0.01 per job returned.** No subscription, no rental, no minimum charge.

- 15 jobs ≈ **$0.16**
- A daily delta run that finds 3 new jobs ≈ **$0.04**
- A run that finds nothing, or fails upstream, costs **$0.005 or less** — the per-result fee only fires on results actually delivered, and a failed run is never charged at all.

**The AI is included.** There is no second bill: no Anthropic key, no OpenAI key, no token charges landing on your account later.

> Want to run it on your own LLM key instead, and pay less per result? The BYOK twin — [AI Job Search Agent — Open-Web Job Finder](https://apify.com/nomad-agent/web-search-scraper) — is $3/1,000 results, but you supply and pay for an Anthropic or Mistral key on top.

### Verification — what "verified" does and doesn't mean

`verified: true` means one thing: at run time, the posting URL was **HTTP-reachable and did not redirect to the site's homepage**. It is not a claim that the role is still open or that the posting is accurate. Results are kept (with `verified: false`) when the check is inconclusive — a timeout or a 403 from a bot-defended site is not proof a job is gone, so ambiguous cases aren't punished. Only unambiguous 404/410s and homepage redirects are dropped.

### Integrations

Send results straight to Google Sheets, Slack, Make, Zapier or any webhook via [Apify integrations](https://apify.com/integrations) — no code required, or pull the dataset over the [API](https://docs.apify.com/api/v2).

### Use cases

- Long-tail job discovery beyond the big boards
- A scored, deduped daily job alert (schedule + `onlyNewSinceLastRun`)
- Passive-candidate tooling — find who's hiring for X
- Niche-role hunting (rare stacks, rare titles)
- Backfilling gaps in board coverage

### FAQ

**Do I really not need an API key?**
Correct. The AI runs on our key and is priced into the per-result fee. You need nothing but an Apify account.

**Is it legal to scrape job postings?**
This Actor reads only publicly available job postings — data any visitor can see without logging in. No data behind authentication is touched. Review the target site's terms and your local regulations for your specific use case.

**Do I need an account on the target site?**
No. Postings are discovered via web search and fetched from public pages — no login, cookies or session tokens.

**Why did I get fewer results than `maxItems`?**
The agent only returns postings that survive its checks: it vetoes careers-index pages, closed/expired roles, and third-party repost boards. You are only charged for what it actually returns, so a short run is a cheap run.

**Does the agent invent salaries or dates?**
No. Both are copied from the posting when stated and left `null` when not. The prompt explicitly forbids guessing.

***

⭐ **Finding this useful?** Leaving a review on the Actor page genuinely helps others find it — and tells us what to build next.

🐛 Found a bad result or a bug? Open an issue on the Actor's **Issues** tab and it'll get looked at.

***

**From the maker of [Oink](https://github.com/Exdenta/OinkAIJobSearch)** — an open-source, AI-powered job-search bot for Telegram that runs on these Actors. [Try the free bot](https://t.me/job_search_everyday_bot), get a managed instance at [oinkjobsearch.com](https://oinkjobsearch.com), or browse the [full catalog of 50+ Actors](https://apify.com/nomad-agent).

# Actor input Schema

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

Role or technology keywords the agent should search for (e.g. <code>frontend</code>, <code>react</code>, <code>typescript</code>). Each entry is one keyword or short phrase.

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

Preferred locations, or <code>remote</code>. The agent biases results toward these and skips obvious mismatches.

## `userDescription` (type: `string`):

Free-text description of the role you want. This is the agent's primary signal — and the main thing each posting's <code>matchScore</code> / <code>matchReasoning</code> is judged against. A sentence or two works well.

## `remote` (type: `string`):

Remote work preference. Free text — the AI interprets it (e.g. any, remote-only, hybrid, on-site).

## `seniority` (type: `string`):

Target seniority level. Free text — the AI interprets it (e.g. junior, mid, senior, lead, principal — or any).

## `titleMustMatch` (type: `array`):

The agent prefers postings whose title contains at least one of these terms. A hint, not a hard filter — equivalent titles still qualify.

## `titleExclude` (type: `array`):

The agent skips postings whose title contains any of these terms.

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

Maximum number of job postings to return (1-50; values outside that range are clamped, not rejected). The agent may return fewer if it cannot find enough high-quality matches — you are only charged for what it actually returns.

## `maxAgeHours` (type: `integer`):

Preferred maximum age of postings in hours (default 720 = 30 days; values outside 1-8760 are clamped, not rejected). The agent skips postings the page itself dates older than this, and keeps ones with no stated date. Lower it (e.g. 168 = one week) for fresher but fewer results.

## `onlyNewSinceLastRun` (type: `boolean`):

Delta / monitoring mode: only output postings not already seen in a previous run that also had this flag on. Already-seen postings are dropped before push and are <b>not billed</b>, so this is the cheapest way to run the agent on a schedule and pay only for genuinely new jobs. New records carry <code>isNew: true</code>.

## Actor input object example

```json
{
  "keywords": [
    "frontend",
    "react",
    "typescript"
  ],
  "locations": [
    "remote",
    "Europe",
    "Spain"
  ],
  "userDescription": "Looking for a senior React engineer role at a product company, ideally in fintech or developer tooling, fully remote within Europe.",
  "remote": "any",
  "seniority": "any",
  "titleMustMatch": [
    "frontend",
    "react"
  ],
  "titleExclude": [
    "intern",
    "manager"
  ],
  "maxItems": 15,
  "maxAgeHours": 720,
  "onlyNewSinceLastRun": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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",
        "backend"
    ],
    "locations": [
        "remote"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nomad-agent/ai-job-search-agent").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",
        "backend",
    ],
    "locations": ["remote"],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ndPGqZvxgTdsgqtd3/builds/1aEXdm24EKwFegLVZ/openapi.json