# Hiring Cafe Jobs Scraper (`jungle_synthesizer/hiring-cafe-scraper`) Actor

Scrape global job postings from Hiring Cafe (hiringcafe.com) — an AI-powered job search engine.
Extract job title, company, location, salary, remote policy, seniority level, visa sponsorship,
commitment type, and more from thousands of live listings.

- **URL**: https://apify.com/jungle_synthesizer/hiring-cafe-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Jobs, Automation
- **Stats:** 5 total users, 0 monthly users, 67.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 record scrapeds

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

## Hiring Cafe Jobs Scraper

Scrape global job postings from [Hiring Cafe](https://hiringcafe.com) — an AI-powered job search engine aggregating listings from Ashby, Greenhouse, Lever, and 100+ other boards. Returns job title, company details, salary, location, remote policy, visa sponsorship, seniority level, and more for thousands of live listings worldwide.

### Hiring Cafe Scraper Features

- Extracts 35+ structured fields per job posting — title, salary, location, remote policy, seniority, and more
- Returns AI-normalised job titles alongside the raw listing title (useful when "Principal SWE III" means "Senior Engineer")
- Collects company metadata — employee count, industries, funding stage, HQ country, and website
- Captures salary data when disclosed — min/max range, currency, and original frequency (hourly, yearly)
- Flags visa sponsorship availability per posting, which most job board APIs bury or omit entirely
- Fast and low-memory
- Handles pagination automatically across 300+ pages of results
- Stops at `maxItems` so test runs don't bill you for the whole corpus

### Who Uses Hiring Cafe Data?

- **Recruiters** — monitor which companies are actively hiring in target verticals before cold-outreach
- **Salary researchers** — aggregate disclosed compensation ranges by role, location, and seniority for benchmarking
- **Job seekers and career coaches** — track remote and visa-sponsoring positions at scale across dozens of ATS sources
- **Market analysts** — identify hiring trends by company size, funding stage, or sector
- **HR tech teams** — build curated job feeds from a single consolidated source rather than scraping 100+ boards separately

### How It Works

1. The scraper fetches the Hiring Cafe home page to extract the current Next.js build identifier — the key that unlocks the site's structured SSR data API.
2. It requests the data API page by page, each response containing up to 150 job objects with full AI-processed metadata.
3. Each job hit is transformed into a clean, flat record — company data merged in, salary normalised to yearly, list fields flattened to pipe-separated strings for easy CSV export.
4. Records are saved until `maxItems` is reached or the feed is exhausted.

### Hiring Cafe Scraper Input

```json
{
  "maxItems": 100
}
```

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `maxItems` | integer | required | Maximum number of job records to return. Set to a small number for testing. |

### Hiring Cafe Scraper Output Fields

```json
{
  "job_id": "ashby___acme-corp___a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "requisition_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "job_url": "https://jobs.ashbyhq.com/acme-corp/a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "job_title": "Senior Software Engineer",
  "job_title_raw": "Sr. Software Engineer (Backend) - Platform Team",
  "posted_at": "2026-06-01T09:00:00.000Z",
  "company_name": "Acme Corp",
  "company_website": "https://acmecorp.com",
  "company_size": 500,
  "company_industries": "Software | Cloud Infrastructure",
  "company_hq_country": "US",
  "company_funding_type": "Series B",
  "company_funding_year": 2023,
  "location_countries": "US | CA",
  "location_states": "California, US | Ontario, CA",
  "location_cities": "San Francisco, CA | Toronto, ON",
  "location_formatted": "San Francisco, CA or Toronto, ON (remote)",
  "geo_latitude": 37.7749,
  "geo_longitude": -122.4194,
  "workplace_type": "Hybrid",
  "seniority_level": "Senior Level",
  "job_category": "Engineering",
  "commitment": "Full Time",
  "role_type": "Individual Contributor",
  "visa_sponsorship": false,
  "salary_min_yearly": 160000,
  "salary_max_yearly": 220000,
  "salary_currency": "USD",
  "salary_listed_frequency": "Yearly",
  "salary_is_transparent": true,
  "min_experience_years": 5,
  "requirements_summary": "5+ years backend engineering; Go or Rust preferred; distributed systems experience; AWS; strong systems design skills.",
  "technical_tools": "Go | Rust | AWS | Kubernetes | PostgreSQL",
  "source": "ashby",
  "board_token": "acme-corp",
  "is_expired": false,
  "scraped_at": "2026-06-02T10:30:00.000Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `job_id` | string | Unique job identifier (source + board_token + requisition id) |
| `requisition_id` | string | Original requisition/job ID assigned by the employer's own ATS |
| `job_url` | string | Direct application URL |
| `job_title` | string | AI-normalised core job title |
| `job_title_raw` | string | Original raw title from the posting |
| `posted_at` | string | Estimated posting date/time (ISO 8601) |
| `company_name` | string | Company name |
| `company_website` | string | Company homepage URL |
| `company_size` | integer | Employee headcount (approximate) |
| `company_industries` | string | Industries (pipe-separated) |
| `company_hq_country` | string | HQ country code (ISO) |
| `company_funding_type` | string | Latest funding type (e.g. Series A, Bootstrapped) |
| `company_funding_year` | integer | Year of latest funding round |
| `location_countries` | string | Workplace countries (pipe-separated ISO codes) |
| `location_states` | string | Workplace states/regions (pipe-separated) |
| `location_cities` | string | Workplace cities (pipe-separated) |
| `location_formatted` | string | Human-readable formatted workplace location |
| `geo_latitude` | number | Workplace latitude (primary location, when geocoded by the source) |
| `geo_longitude` | number | Workplace longitude (primary location, when geocoded by the source) |
| `workplace_type` | string | Workplace/remote policy classification (Remote, Hybrid, On-site, Field) |
| `seniority_level` | string | Seniority (Entry Level, Mid Level, Senior Level, etc.) |
| `job_category` | string | Job category/function |
| `commitment` | string | Employment type (Full Time, Part Time, Contract) |
| `role_type` | string | Role type (Individual Contributor, Manager) |
| `visa_sponsorship` | boolean | Whether visa sponsorship is offered |
| `salary_min_yearly` | number | Minimum annual salary (normalised to yearly) |
| `salary_max_yearly` | number | Maximum annual salary (normalised to yearly) |
| `salary_currency` | string | Salary currency code (USD, EUR, GBP, etc.) |
| `salary_listed_frequency` | string | Original salary frequency (Yearly, Hourly, Monthly) |
| `salary_is_transparent` | boolean | Whether the listing discloses actual compensation figures |
| `min_experience_years` | number | Minimum years of industry/role experience required, when stated |
| `requirements_summary` | string | AI-generated summary of key requirements |
| `technical_tools` | string | Required tools and technologies (pipe-separated) |
| `source` | string | Job board source (ashby, greenhouse, lever, etc.) |
| `board_token` | string | Company board token on the source platform |
| `is_expired` | boolean | Whether the posting has expired |
| `scraped_at` | string | ISO 8601 timestamp of when the record was scraped |

### 🔍 FAQ

#### How do I scrape Hiring Cafe job postings?

Hiring Cafe Jobs Scraper handles it. Set `maxItems` to however many records you need, run it, and the output lands in your dataset as structured JSON. No browser, no configuration beyond that.

#### How much does the Hiring Cafe Jobs Scraper cost to run?

Billing is per record at a very low per-item rate — well under a cent per job in typical runs. The `maxItems` field caps your spend precisely if budget matters.

#### What data can I get from Hiring Cafe?

Hiring Cafe Jobs Scraper returns 35+ fields per posting: job title (raw and AI-normalised), company details (size, funding, industries), salary range when disclosed, location with coordinates, remote policy, seniority level, visa sponsorship status, and a machine-generated requirements summary. Coverage is global — listings from every continent show up in the feed.

#### How many jobs are available on Hiring Cafe?

The live corpus is roughly 12,000+ active listings, refreshed continuously. Set `maxItems` to a smaller number for targeted pulls, or leave it large to sweep the full feed.

***

### Need More Features?

Custom filters by location, seniority, or company size? Incremental runs? [File an issue](https://console.apify.com/actors/issues) or get in touch.

### Why Use Hiring Cafe Jobs Scraper?

- **Richer output than most alternatives** — AI-normalised titles, company funding data, and requirements summaries in one payload, which beats manually joining three data sources after the fact.
- **Global coverage** — Listings from 100+ ATS platforms (Ashby, Greenhouse, Lever, SAP SuccessFactors, and more) in a single, consistently structured feed.

***

**Further reading:** [Job Postings Data: How to Get Listings From 12 Boards Across 10 Markets](https://orbtop.com/articles/job-postings-data-by-market/)

# Actor input Schema

## `sp_intended_usage` (type: `string`):

What will this data feed? E.g. lead lists, KYB checks, price tracking.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

We'll personally help with your use case. No spam.

## `resumeCursor` (type: `string`):

Leave empty for a fresh crawl. To CONTINUE a previous run where it stopped — without paying again for records you already received — paste the `resumeCursor` value from that run's Output (the run's OUTPUT key). Resume promptly: the previous run's data expires with your account's retention window (free tier: your ~10 most recent runs).

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

Maximum number of job records to scrape. Leave empty to scrape all available jobs.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/hiring-cafe-scraper").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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/hiring-cafe-scraper").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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "maxItems": 10
}' |
apify call jungle_synthesizer/hiring-cafe-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jungle_synthesizer/hiring-cafe-scraper"
        }
    }
}
```

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/cpnUbdltz2Z4YLKgB/builds/ix2zjW8uuIl3P1C0l/openapi.json