AI Deep Job Search

AI Deep Job Search — describe your ideal job in plain English, and an AI agent plans the search across 75+ ATS platforms and 3.9 million+ live jobs, narrows it against live facet counts, and scores the candidates 0–100 with written reasoning. Think of it as deep research for your job hunt. Open the actor, hit Try for free, and run the default input — one text box, no filters, no code or API key required.

What does AI Deep Job Search do?

• Takes one free-text description of what you want — title, level, must-haves, industries, salary, culture, deal-breakers — instead of a wall of filter fields
• Narrows the search autonomously: the agent inspects live facet counts and applies one filter at a time until the candidate pool is small enough to deep-read
• Scores candidates 0–100 — each scored job gets a relevance_score, an is_match flag, and written analysis_notes explaining the verdict
• Transparent shortfalls — when the pool doesn't hold enough strong fits, near-misses below 70 are pushed too, with their scores and reasoning, so you see what almost made the cut
• Writes a full reasoning log to the key-value store: every planning and narrowing step with the facet snapshots that drove it, plus a final scoring summary — per-job reasoning lives in each record's analysis_notes
• Optionally attaches the full company profile — funding, leadership, ratings, tech stack, H1B history — with one switch (include_company_details)

How does the AI agent work?

Under the hood, the agent runs a fixed research pipeline against Jobo's live job index:

1. Query plan — an LLM turns your description into 2–6 broad, synonym-rich title queries plus a scoring brief (must-haves, nice-to-haves, deal-breakers).
2. Facet probe — one broad search returns live counts for work model, experience level, and employment type.
3. Narrowing loop — up to 5 rounds. In each round the agent applies exactly one filter (a work model, experience level, employment type, or skill), chosen by weighing your intent against the live facet counts. It never filters by ATS source. The loop stops early once the pool is down to about 60 jobs.
4. Pool fetch — the agent pulls the candidate pool: up to 100 jobs (60 at the default target_matches).
5. Concurrent scoring — the LLM reads each candidate and scores it 0–100 against your description, writing reasoning for every score.
6. Stop condition — results are pushed in descending score order until target_matches jobs with a score ≥ 70 are found, or the run hits its 240-second budget.

Your plain-English query
   ↓
Query plan ........ 2–6 broad title queries + scoring brief
   ↓
Facet probe ....... live counts: work model, level, type
   ↓
Narrowing loop .... up to 5 rounds, one filter per round
   ↓                 (stops early at ~60 candidates)
Pool fetch ........ up to 100 jobs
   ↓
Concurrent scoring  candidates rated 0–100 with reasoning
   ↓
Results ........... pushed by score until target_matches hit ≥ 70
                     (hard 240-second budget)

Scoring runs on DeepSeek v4 Flash via OpenRouter; search and facet data come from the same live index behind ATS Jobs API.

What data does it return?

Every result is a full job record in Jobo's normalized schema — the same shape as every Jobo actor — plus four AI analysis fields:

Field	Description
relevance_score	0–100 fit against your description
is_match	true when the score is ≥ 70
analysis_notes	The AI's written reasoning behind the score
analysis_timestamp	UTC timestamp of the analysis
title / normalized_title	Raw posting title + canonical title for grouping
company	Company preview: name, website, logo, summary, industries (+ id for enrichment)
locations	Geocoded: city, region, country, latitude/longitude
compensation	{min, max, currency, period}
qualifications / responsibilities / benefits	AI-extracted must-have & preferred skills, duties, and perks
summary / description	2–3 sentence AI recap + full description, HTML stripped
listing_url / apply_url	Canonical listing + direct apply link
source	Which ATS platform the job came from

Set include_company_details: true to replace the company preview with the fully enriched profile: funding rounds and investors, leadership, employee ratings, tech stack, headcount and revenue bands, and H1B filing history. The complete field list is on this page's Output schema tab and at docs.jobo.world.

What is the reasoning log?

Alongside the dataset, the actor writes a reasoning_log to the run's key-value store: the query plan, every narrowing decision with the facet snapshot that motivated it, and a final scoring summary (per-job reasoning is in each record's analysis_notes). If a result surprises you — or you got fewer matches than expected — the log shows exactly what the agent saw and why it chose the path it did. Most job-matching tools are black boxes; this one shows its work.

How much does it cost?

This actor uses pay-per-result pricing: you pay a fixed rate per job record pushed to your dataset — the current rate is in the pricing box on this page. There are no separate compute, proxy, or storage charges. One honest note: the AI analyzes a pool of up to 100 jobs per run to find your matches, so broader queries do more scoring work behind the scenes — but you only pay for the records that land in your dataset. Apify's free plan includes enough credit to run your first searches before paying anything.

How do I use it?

1. Open the actor and click Try for free — you'll need a free Apify account.
2. Describe the job in plain English in query: title, level, must-have skills, industries, salary expectations — and your deal-breakers ("no agencies", "skip anything PHP-heavy"). The more specific you are, the sharper the scores.
3. Optionally set a location — a city, country, or loose region like "Bay Area" or "DACH" — and pick target_matches (how many strong matches you want).
4. Click Start. The agent plans, narrows, and scores; a typical run takes a few minutes.
5. Read the results: jobs arrive sorted by relevance_score, each with written analysis_notes — and the full reasoning_log is in the key-value store.

⬇️ Input

Five fields, only one of them required. There are no manual filters — the agent chooses and applies them itself, and logs why.

Parameter	Type	Description
query	string (required)	Plain-English description of your ideal job: title, level, skills, industries, salary, culture, deal-breakers.
location	string	One location; loose forms like "Bay Area", "DACH", or "Remote" work. Empty = global.
posted_after	string	Only jobs posted after this date — ISO 8601 (2026-01-01) or relative (14 days ago).
target_matches	integer	Stop after this many jobs score ≥ 70. Range 1–100, default 10.
include_company_details	boolean	Attach the full enriched company profile to each result (default false).

Senior backend engineer with deal-breakers

{
  "query": "I'm a senior backend engineer with 8 years of experience looking for a remote or hybrid role at a SaaS or fintech company. Strong in Python, Go, and AWS — please skip anything PHP-heavy. Looking for 160k USD+ base, company size 50–500, engineering-led culture. Not interested in consulting, agencies, gambling, or defense.",
  "location": "San Francisco",
  "target_matches": 10
}

Product manager moving into fintech, fresh postings only

{
  "query": "Product manager with 5 years in B2B SaaS looking to move into fintech or payments. I want to own a product end to end and work directly with engineers — not a growth or marketing PM seat. Full-time only; hybrid is fine.",
  "location": "New York",
  "posted_after": "14 days ago",
  "target_matches": 15
}

Engineering manager in Europe, with company enrichment

{
  "query": "Engineering manager who still enjoys architecture discussions, looking to lead a 5–15 person product team. Remote-friendly European company with an English-speaking, async-friendly culture. No agencies or consultancies, and nothing in gambling.",
  "location": "Europe",
  "target_matches": 20,
  "include_company_details": true
}

⬆️ Output example

Results land in the dataset under two views: AI-Scored Job Matches (one row per scored job) and Company details (populated when include_company_details is on). Export as JSON, CSV, or Excel. A typical record — here scored against a query asking for an embedded C/C++ engineer in medical devices:

{
  "relevance_score": 86,
  "is_match": true,
  "analysis_notes": "Strong match: an embedded software role building capital equipment for cardiac surgery — squarely in the requested medical-devices domain, with C and C++ as core must-haves. Full-time, on-site in Minneapolis. Points deducted: the disclosed range tops out at 104k USD and the level is mid rather than senior.",
  "analysis_timestamp": "2026-07-10T09:14:02Z",
  "id": "f0f6a7d0-c667-48f7-95bc-a91f172e2d6d",
  "title": "Software Engineer",
  "normalized_title": "Software Engineer",
  "summary": "Design and develop software for capital equipment and medical devices used by cardiac surgeons and electrophysiologists…",
  "company": {
    "id": "6647fb14-d420-434a-a332-9c972016b9b0",
    "name": "AtriCure",
    "website": "https://atricure.com",
    "logo_url": "https://images.jobo.world/logos/atricure.jpg",
    "industries": ["Medical Devices & Equipment"],
    "details_url": "https://connect.jobo.world/api/companies/6647fb14-d420-434a-a332-9c972016b9b0"
  },
  "locations": [
    {
      "location": "Minneapolis, MN",
      "city": "Minneapolis",
      "region": "Minnesota",
      "country": "United States",
      "latitude": 44.9772995,
      "longitude": -93.2654692
    }
  ],
  "compensation": { "min": 71036, "max": 104186, "currency": "USD", "period": "yearly" },
  "employment_type": "Full-time",
  "workplace_type": "On-site",
  "experience_level": "Mid Level",
  "qualifications": {
    "must_have": {
      "education": ["Bachelor's degree in Systems Engineering, Electrical Engineering, or Computer Engineering"],
      "skills": [
        { "name": "C", "type": "hard" },
        { "name": "C++", "type": "hard" },
        { "name": "Software Development Methodologies", "type": "hard" }
      ]
    },
    "preferred": {
      "skills": [
        { "name": "Rust", "type": "hard" },
        { "name": "Python", "type": "hard" }
      ]
    }
  },
  "is_work_auth_required": true,
  "listing_url": "https://job-boards.greenhouse.io/atricure/jobs/4309998009",
  "apply_url": "https://job-boards.greenhouse.io/atricure/jobs/4309998009#app",
  "source": "greenhouse",
  "date_posted": "2026-07-09T13:47:14Z",
  "description": "…full job description, HTML stripped…"
}

What can you expect from a run?

• A typical run takes a few minutes — the search-and-scoring pipeline works to a 240-second budget and pushes everything it has scored when the deadline hits, so you get partial results rather than nothing. (Company enrichment, when enabled, runs after scoring and can add time.)
• Results are sorted by score, best first — scored jobs are pushed in descending order until the target is met.
• Near-misses appear when matches run short: if the pool can't fill your target with ≥ 70 scores, jobs below 70 are pushed with is_match: false and their reasoning, so a shortfall is transparent, not silent.
• You may get fewer than target_matches when the pool simply doesn't contain enough strong fits — the reasoning_log shows what was tried and why.
• The underlying index is fresh: new jobs are indexed within 24 hours, every listing is re-verified daily, and expired jobs are removed within 24 hours.

Integrations, API & MCP

Everything on the Apify platform works out of the box: schedules (hourly/daily/weekly runs), webhooks on run completion, and one-click integrations with Zapier, Make, n8n, Slack, Google Sheets, and Google Drive.

Prefer code? Call this actor as an AI job-matching API from Python or JavaScript with the Apify API clients — start a run, wait for it, and page through the dataset in a few lines (ready-made snippets are in the API section of this page). AI agents can run it through the Apify MCP server, which exposes this actor as a tool.

Use cases

Who	What for
Job seekers	Turn "here's what I actually want" into a ranked, reasoned shortlist instead of paging through boards
Recruiters	Shortlist live openings that match a candidate's profile — and see which companies are competing for them
Career coaches	Run curated searches for clients and hand over scored shortlists with written reasoning
AI agents	A one-call "deep job research" tool via MCP — free-text in, scored and explained matches out

❓ FAQ

How is this different from ATS Jobs API?

ATS Jobs API is deterministic search: you choose the filters, it returns matching pages. This actor is an agent: you describe intent, and it picks the filters, reads the candidates, and tells you which ones fit and why. Use ATS Jobs API for data pipelines and bulk pulls; use this one when the question is "which of these jobs should I actually pursue?"

What does the relevance score mean?

It's the AI's 0–100 judgment of how well a job fits your description — skills, level, location, salary, industry, and your stated deal-breakers. Jobs scoring 70 or higher are flagged is_match: true, and every score comes with analysis_notes explaining the reasoning.

Can I see jobs that didn't make the cut?

Sometimes. Results are pushed in descending score order until target_matches jobs scoring ≥ 70 are reached — so when strong matches fill the target, only they appear. When the pool runs short, the near-misses below 70 are pushed too, with their scores, reasoning, and is_match: false.

What model scores the jobs?

DeepSeek v4 Flash via OpenRouter. The model is fixed and maintained by Jobo — it isn't user-configurable, so scoring behavior stays consistent between runs.

How long does a run take?

A few minutes, typically — the search-and-scoring pipeline works to a 240-second budget. If it runs out mid-scoring, everything scored so far is pushed to the dataset.

Why did I get fewer matches than target_matches?

Two possible reasons: the candidate pool was exhausted (there simply weren't enough jobs scoring ≥ 70 for your query) or the 240-second budget was hit first. Open the reasoning_log in the key-value store — it shows which, and what the agent tried.

Where can I check if the API behind this actor is up?

At jobo.world/status — the live status page for the Jobo Connect API that powers every Jobo actor.

⚖️ Is it legal to scrape job listings?

Yes — this actor only extracts publicly posted job listings, the content employers publish specifically to be found and shared. It does not collect private user data. Note that scraped results can incidentally contain personal data (e.g., a recruiter's name in a job description); personal data is protected by the GDPR and similar regulations, so only process it with a legitimate reason and consult a lawyer if unsure. Read more in Apify's guide to the legality of web scraping.

All ATS names are trademarks of their respective owners. This actor is an independent product and is not affiliated with, endorsed by, or sponsored by any of them.

🔗 Related actors

Found your matches? Feed the Lever and Ashby matches' apply URLs into AI Auto-Apply — describe your ideal job in one run, apply to the best fits in the next.

Actor	Best for
ATS Jobs API	Search 75+ ATS platforms in one call
ATS Jobs Feed	Bulk export for data pipelines — cursor pagination, 1,000 jobs/batch
AI Auto-Apply	AI fills and submits job applications for you
Greenhouse Jobs Scraper	175,000+ jobs from tech companies on Greenhouse
Crunchbase Company Lookup	Funding, leadership, and tech-stack data for any company

About Jobo & support

Jobo builds job-data infrastructure: a normalized, daily-verified index of jobs scraped directly from company ATS boards, powering job boards, AI agents, and HR-tech products.

• Questions or bugs? Open a ticket on this actor's Issues tab — issues are answered within hours.
• Website: jobo.world · Enterprise API: jobo.world/enterprise · API status: jobo.world/status
• Email: enrico@jobo.world