# HiringCafe Jobs Scraper (`automation-lab/hiringcafe-jobs`) Actor

Search HiringCafe and export structured job identity, company, location, remote, compensation, posting, requirements context, and application data for recruiting feeds.

- **URL**: https://apify.com/automation-lab/hiringcafe-jobs.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.48 / 1,000 job extracteds

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/actors/running/actors-in-store.md#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

## HiringCafe Jobs Scraper

Search public HiringCafe job results and export structured hiring data for recruiting and labor-market feeds.

HiringCafe Jobs Scraper returns one dataset row per unique job.

Each row can include job identity, title, company, location, workplace type, compensation, posting date, requirements context, technical tools, and application URLs.

The Actor accepts ordinary keyword searches and HiringCafe URLs with encoded search filters.

### What does HiringCafe Jobs Scraper do?

The Actor turns HiringCafe searches into reusable datasets.

Use it to:

- find jobs for a role, skill, or company;
- refresh a recruiting feed on a schedule;
- export hiring data to JSON, CSV, Excel, or another integration;
- analyze remote, location, seniority, and compensation signals;
- collect stable job IDs and source URLs for downstream comparison.

The Actor reads HiringCafe's public structured search data.

It does not require a HiringCafe account.

### Who is it for?

Recruiters can build focused role or company searches.

Talent sourcing teams can export openings for candidate research.

Labor-market analysts can collect repeatable samples of current hiring demand.

Sales and research teams can identify companies with relevant open roles.

Data engineers can schedule runs and load normalized rows into a warehouse.

Job-feed builders can retain source attribution and direct application links.

### Why use this HiringCafe scraper?

HiringCafe exposes rich search-result metadata across many employer career sites.

This Actor normalizes the useful fields without requiring a browser for every run.

It provides:

- keyword and filtered-URL inputs;
- deterministic pagination;
- within-run deduplication by stable job ID;
- explicit maximum-item control;
- typed, integration-ready dataset rows;
- bounded retries for transient upstream failures;
- non-zero failure status for challenge pages or changed response shapes.

The Actor does not silently treat a blocked response as an empty search.

### What HiringCafe job data can I extract?

| Field | Meaning |
| --- | --- |
| `jobId` | Stable HiringCafe job identity |
| `requisitionId` | Source or employer requisition identity when shown |
| `title` | Published job title |
| `companyName` | Hiring company |
| `companyWebsite` | Company website when available |
| `companySize` | Estimated employee count when available |
| `companyIndustry` | Company sector or industry |
| `companyTagline` | Short company context from HiringCafe enrichment |
| `location` | Formatted workplace location |
| `countries` | Workplace countries |
| `workplaceType` | Remote, hybrid, onsite, or related classification |
| `employmentTypes` | Full time, contract, internship, or other commitments |
| `seniority` | Seniority level when available |
| `salaryMin` / `salaryMax` | Yearly normalized compensation range |
| `salaryCurrency` | Listed currency |
| `salaryFrequency` | Frequency used in the original compensation statement |
| `compensationTransparent` | Whether compensation is marked transparent |
| `datePosted` | Estimated publication timestamp |
| `sourcePlatform` | Original ATS or career-site platform |
| `sourceUrl` | Public source or application URL |
| `applyUrl` | Direct application URL |
| `canonicalUrl` | Canonical URL retained for the exported record |
| `descriptionText` | Description, requirements, or company context available in search results |
| `requirements` | HiringCafe requirements summary |
| `technicalTools` | Tools and technologies associated with the role |
| `roleActivities` | Normalized role activities |
| `languages` | Language requirements |
| `benefits` | Benefits indicated in job metadata |
| `visaSponsorship` | Visa-sponsorship signal when available |
| `relocationAssistance` | Relocation-assistance signal when available |
| `isExpired` | HiringCafe expiration status |
| `searchQuery` | Query that produced the row |
| `scrapedAt` | Export timestamp |

Fields can be null or empty when an employer did not publish that information.

### How to scrape HiringCafe jobs

1. Open the Actor in Apify Console.
2. Enter one or more role, skill, or company terms in **Search queries**.
3. Optionally add HiringCafe search URLs with filters you configured on the site.
4. Set **Maximum jobs** to control output and cost.
5. Run the Actor.
6. Review the **HiringCafe jobs** dataset view.
7. Export the rows or connect the dataset to your workflow.

Start with 10–50 jobs to inspect coverage for your search.

### Input parameters

#### `searchQueries`

An array of non-empty role, skill, or company searches.

Examples:

- `software engineer`
- `data scientist`
- `AI engineer`
- `Amazon`
- `product manager`

Multiple queries are processed in order.

Duplicate jobs are saved only once within a run.

#### `startUrls`

Optional public HiringCafe search URLs.

The Actor accepts `hiringcafe.com` and legacy `hiring.cafe` hosts.

It preserves the URL's encoded `searchState` object.

A URL with a simple `q` parameter is also supported.

Other domains are rejected before any scraping begins.

#### `maxItems`

The maximum number of unique jobs saved across all inputs.

Allowed range: 1–1,000.

Default: 50.

The Actor stops as soon as this limit is reached.

#### `includeDescriptionHtml`

When enabled, the Actor adds `descriptionHtml` if HiringCafe exposes raw HTML.

Search results often contain a requirements summary rather than a full job-description body.

`descriptionText` therefore falls back to available requirements or company context.

### Example input

```json
{
  "searchQueries": ["software engineer", "data scientist"],
  "maxItems": 25,
  "includeDescriptionHtml": false
}
```

### Example output

This representative shape is based on a current local run.

```json
{
  "jobId": "ashby___sample-company___96c74af4-b3d7-4960-a666-212ce4debac8",
  "requisitionId": "96c74af4-b3d7-4960-a666-212ce4debac8",
  "title": "Software Engineer, Integrations",
  "companyName": "Sample AI Company",
  "companyWebsite": "https://sample-ai.example",
  "location": "Toronto or San Francisco or New York City or London",
  "countries": ["Canada", "United States", "United Kingdom"],
  "workplaceType": "Remote",
  "employmentTypes": ["Full Time"],
  "seniority": "Mid Level",
  "salaryMin": 150000,
  "salaryMax": 270000,
  "salaryCurrency": "USD",
  "salaryFrequency": "Yearly",
  "compensationTransparent": true,
  "sourcePlatform": "ashby",
  "applyUrl": "https://jobs.example.org/sample-company/96c74af4",
  "requirements": "Production software engineering and external API integration experience.",
  "technicalTools": ["Python", "TypeScript"],
  "isExpired": false,
  "searchQuery": "software engineer",
  "scrapedAt": "2025-01-15T12:00:00.000Z"
}
```

Example values are anonymized; actual runs return current public source values.

### How much does it cost to export HiringCafe jobs?

The Actor uses pay-per-event pricing.

A one-time start event is charged when a run begins.

A `job` event is charged only for each unique job saved to the default dataset.

Rejected, duplicate, empty, and failed records are not charged as jobs.

The one-time start event costs **$0.00005**.

The per-job prices are **$0.00092 FREE**, **$0.0008 BRONZE**, **$0.000624 SILVER**, **$0.00048 GOLD**, **$0.00032 PLATINUM**, and **$0.000224 DIAMOND**.

The six prices decrease by Apify account tier.

At BRONZE pricing, a 10-job preview costs **$0.00805**: one start plus 10 jobs.

At BRONZE pricing, a 100-job feed costs **$0.08005**: one start plus 100 jobs.

Set the maximum-jobs input to place a predictable upper bound on job-event charges.

A naturally empty search incurs the start event but produces no job events.

### Build recurring recruiting feeds

Use Apify schedules to run a stable input daily or weekly.

Store `jobId`, `isExpired`, and `scrapedAt` in your destination.

Compare each new dataset with your prior snapshot to identify additions or removals.

The Actor itself does not maintain cross-run history or send alerts.

Use Apify integrations, webhooks, or your own database for that layer.

### Export to spreadsheets and data pipelines

Apify datasets can be downloaded as JSON, CSV, Excel, XML, or RSS.

Common workflows include:

- send a scheduled dataset to Google Sheets;
- load rows into BigQuery, Snowflake, or PostgreSQL;
- trigger an automation from a run-finished webhook;
- enrich company domains in a downstream process;
- join snapshots by `jobId` for labor-market analysis.

Preserve `sourceUrl` or `applyUrl` when publishing or reviewing results.

### JavaScript API example

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/hiringcafe-jobs').call({
  searchQueries: ['AI engineer'],
  maxItems: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("MY-APIFY-TOKEN")
run = client.actor("automation-lab/hiringcafe-jobs").call(run_input={
    "searchQueries": ["data scientist"],
    "maxItems": 25,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~hiringcafe-jobs/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["product manager"],"maxItems":25}'
```

Fetch the resulting default dataset after the run succeeds.

Do not commit API tokens into code or input files.

### Use HiringCafe Jobs Scraper with MCP

Add this Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/hiringcafe-jobs"
```

#### Claude Desktop, Cursor, and VS Code MCP setup

Claude Desktop, Cursor, and VS Code can use this HTTP MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/hiringcafe-jobs"
    }
  }
}
```

#### Example prompts for MCP usage

After connecting the MCP server, ask your MCP client:

- “Use the HiringCafe Jobs Scraper MCP tool to find 20 remote software engineer jobs and show company, location, and salary.”
- “Use MCP to export Amazon-related HiringCafe jobs with stable IDs and apply URLs.”
- “Use the MCP tool to create a table of AI engineer jobs that show transparent compensation.”

### Reliability and pagination

The Actor first resolves HiringCafe's current Next.js build identifier.

It then requests structured search pages in sequence.

A changed build identifier is refreshed once after a 404.

Transient network, 403, 429, and server responses receive bounded retries.

The Actor validates status, challenge shape, JSON, and expected result fields.

Unexpected challenge or payload changes fail the run instead of returning misleading empty data.

### Limits and data freshness

Results reflect HiringCafe's public search data at run time.

The Actor does not log in or access saved-user data.

A search may return fewer rows than `maxItems` because of source availability or deduplication.

HiringCafe controls enrichment, publication dates, salary normalization, and expiration flags.

Some fields can be inferred by HiringCafe rather than supplied directly by an employer.

Search-result context is not guaranteed to include the full original job description.

The maximum output is 1,000 jobs per run.

### Troubleshooting

#### Why did my search return no jobs?

Try the same query on HiringCafe and verify that public results currently exist.

Use a broader role name or a filtered HiringCafe URL.

An empty valid search succeeds with zero job rows.

#### Why are salary fields null?

Many employers do not publish compensation.

The Actor returns salary only when HiringCafe exposes normalized compensation data.

#### Why did the run fail instead of returning zero rows?

The Actor detected an upstream challenge, HTTP failure, invalid JSON, or unexpected response shape.

Inspect the run log and retry later rather than treating that failure as a valid empty feed.

#### Why was a start URL rejected?

Only public HiringCafe URLs containing `searchState` or `q` are accepted.

This prevents accidental requests to unrelated domains or non-search pages.

### Responsible use and legality

This Actor extracts public job-search information.

You are responsible for complying with applicable laws, source terms, and employer-site requirements.

Use reasonable schedules and result limits.

Retain source attribution when appropriate.

Do not use the output for spam, unlawful discrimination, or intrusive profiling.

Avoid republishing copyrighted job text beyond what your use permits.

### Related Automation Lab Actors

Combine this Actor with related public recruiting data sources when that improves coverage:

- [Remote OK Jobs Feed Scraper](https://apify.com/automation-lab/remoteok-remote-jobs-feed)
- [Company Career Page Jobs Scraper](https://apify.com/automation-lab/company-career-page-jobs-scraper)
- [Breezy HR Jobs Scraper](https://apify.com/automation-lab/breezy-hr-jobs-scraper)
- [Gupy Jobs Scraper](https://apify.com/automation-lab/gupy-jobs-scraper)

Each source has different fields and coverage.

Use stable IDs and source URLs when combining feeds.

### FAQ

#### Can I search multiple terms in one run?

Yes. Add multiple strings to `searchQueries`.

The Actor deduplicates matching jobs by job ID.

#### Can I reuse filters from HiringCafe?

Yes. Add the public HiringCafe URL to `startUrls`.

The Actor preserves its encoded `searchState` object.

#### Does the Actor need residential proxies?

No automatic proxy or browser fallback is enabled.

The current public structured route works through direct HTTP and avoids unnecessary proxy transfer.

#### Does it include full descriptions?

It returns description context available in search results, usually a requirements summary.

Enable `includeDescriptionHtml` to retain HTML only when HiringCafe exposes it.

#### Can I export CSV or Excel?

Yes. Use the default dataset export options in Apify Console or API.

#### Can I schedule the Actor?

Yes. Save a Task with stable input and attach an Apify schedule.

#### Does it compare runs automatically?

No. Store snapshots in your destination and compare them by `jobId`.

#### Are duplicate jobs charged twice?

Not within one run. A stable job ID is saved and charged only once per run.

# Actor input Schema

## `searchQueries` (type: `array`):

Role, skill, or company searches, such as software engineer, Amazon, or data analyst.

## `startUrls` (type: `array`):

Optional hiringcafe.com search URLs. Encoded searchState filters from the URL are preserved.

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

Maximum number of unique jobs saved across all queries and URLs.

## `includeDescriptionHtml` (type: `boolean`):

Include raw description HTML when HiringCafe exposes it. Plain description context is returned by default.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer"
  ],
  "startUrls": [],
  "maxItems": 20,
  "includeDescriptionHtml": false
}
```

# Actor output Schema

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

Dataset containing all saved HiringCafe jobs.

# 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 = {
    "searchQueries": [
        "software engineer"
    ],
    "startUrls": [],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/hiringcafe-jobs").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 = {
    "searchQueries": ["software engineer"],
    "startUrls": [],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/hiringcafe-jobs").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 '{
  "searchQueries": [
    "software engineer"
  ],
  "startUrls": [],
  "maxItems": 20
}' |
apify call automation-lab/hiringcafe-jobs --silent --output-dataset

```

## MCP server setup

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

```

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/2vAPi2PjLTZzXkKPB/builds/JWyJgBxVxgW9l9Ger/openapi.json