# Fresh Jobs Feed - New Job Listings Every Day (`hirebase/jobs-feed`) Actor

A scheduled feed of the newest job listings, scraped directly from company career pages across 20+ ATS platforms. 5,000+ new jobs every day, expired and ghost jobs filtered out. Run it on a daily schedule to power job boards, alerts and market dashboards.

- **URL**: https://apify.com/hirebase/jobs-feed.md
- **Developed by:** [Hirebase](https://apify.com/hirebase) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 6 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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

## Fresh Jobs Feed - New Job Listings Every Day

A scheduled feed of the **newest job listings on the internet** - 5,000+ new jobs every day, scraped directly from company career pages across 80+ ATS platforms and delivered as clean JSON. Expired and ghost jobs never enter the feed. Powered by [Hirebase](https://www.hirebase.org).

This actor is built to run on a schedule. Results are always sorted newest-first and default to jobs posted in the last 24 hours. Turn on **Only new since last run** and each run saves only the jobs added since the previous one - never the same job twice.

**What people build with it**

- 📰 **Job boards** - keep a niche board fresh with daily inserts and expiry-based delisting.
- 🔔 **Alerts** - new jobs matching your filters, pushed to Slack, Discord or email every morning.
- 📊 **Market dashboards** - hiring velocity by company, category, location or tech stack.
- 🤖 **AI agents** - a clean daily corpus of hiring activity for downstream enrichment.

### How to use it

1. Set your filters (keywords, categories, locations, salary - or none for the full firehose).
2. Create an [Apify Schedule](https://docs.apify.com/platform/schedules) - daily is typical, hourly works too.
3. Add an integration (Google Sheets, Make, n8n, Zapier, webhooks) or consume the dataset via API.

*Posted within (days)* defaults to `1`. Widen it on the first run to backfill, then return it to `1` for incremental daily pulls.

**Keeping a job board in sync:**

1. Turn on **Only new since last run**. The first run returns normal results and records a starting point; every run after that saves only jobs added to Hirebase since the one before, so you never pay for the same job twice.
2. Insert new rows keyed on the stable `id` / `jobSlug` fields.
3. Schedule the [Expired Jobs Feed](https://apify.com/hirebase/expired-jobs) actor alongside it and delete every `id` it returns - those jobs have been taken down from the career page.

### Output

```json
{
  "jobTitle": "Data Engineer",
  "companyName": "Cloudflare",
  "datePosted": "2026-07-27",
  "applicationLink": "https://boards.greenhouse.io/cloudflare/...",
  "locationType": "Hybrid",
  "jobType": "Full Time",
  "jobSlug": "data-engineer-8a91c3d2",
  "jobBoard": "greenhouse"
}
```

Every result carries the full enriched record: salary range, skills, technologies, benefits, seniority, education level, visa sponsorship, company data, cleaned description and original HTML.

### Pricing

Pay per result - you are only charged for jobs actually returned, up to **5,000 results per run**. A focused daily feed (one category or keyword set) typically returns tens to a few hundred new jobs per day.

### FAQ

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

**How is this different from the flagship Job Search Scraper?**
Same data, different defaults: this one is locked to newest-first ordering and preset to a 24-hour window, so scheduled runs are incremental by design. Use the flagship for one-off deep searches.

**How do I avoid paying for the same job twice across daily runs?**
Turn on **Only new since last run** - jobs returned by an earlier run with the same filters are skipped and never billed. Each job also has a stable `id` and `jobSlug` to upsert on. Within a single run, set *Deduplicate results* to skip multi-location repeats (skipped duplicates are not billed).

**How do I detect expired jobs?**
Run the [Expired Jobs Feed](https://apify.com/hirebase/expired-jobs) actor on the same schedule. It returns the `id`, `jobSlug` and `companySlug` of every job removed from a career page since a date - match them against your store and delist.

**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>).

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

Also return the complete description exactly as published on the ATS, in the <code>fullDescriptionHtml</code> field.

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

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

Save only jobs added to Hirebase since this actor (or saved task) last ran with the same filters - for scheduled runs that keep a job board or database fresh. The first run returns normal results and records a starting point. Results are sorted newest first while this is on. Pair it with the Expired Jobs actor to delist what has closed.

## Actor input object example

```json
{
  "keywords": [],
  "geoFilterMode": "auto",
  "geoRadiusUnit": "mi",
  "includeJobsWithoutYoe": true,
  "postedWithinDays": 1,
  "hideRecruitingAgencies": false,
  "currency": "USD",
  "includeJobsWithoutSalary": true,
  "visaSponsorship": "any",
  "fullDescriptionHtml": false,
  "maxResults": 100,
  "dedupeBy": "none",
  "onlyNewSinceLastRun": false
}
```

# 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": [],
    "postedWithinDays": 1
};

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

# Run the Actor and wait for it to finish
run = client.actor("hirebase/jobs-feed").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 '{
  "keywords": [],
  "postedWithinDays": 1
}' |
apify call hirebase/jobs-feed --silent --output-dataset

```

## MCP server setup

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

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/CuAbMT3wPMmrDyQdK/builds/umNNKceQhBcJ0yWxz/openapi.json