# Hiring Cafe Jobs Scraper (`automation-lab/hiring-cafe-jobs-scraper`) Actor

Extract Hiring Cafe job listings with companies, locations, salaries, skills, source platforms, and apply URLs for recruiting and market research.

- **URL**: https://apify.com/automation-lab/hiring-cafe-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 job listing saveds

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Hiring Cafe Jobs Scraper

Extract structured job listings from Hiring Cafe without opening a browser.

This actor reads public Hiring Cafe search pages, parses the server-rendered job payload, and saves clean rows with titles, companies, locations, salaries, source platforms, apply URLs, requirements, benefits, and tags.

### What does Hiring Cafe Jobs Scraper do?

Hiring Cafe Jobs Scraper turns Hiring Cafe searches into exportable datasets.

Use it to collect job-market data from public Hiring Cafe pages.

It accepts search terms such as `software engineer`, `data analyst`, or `product manager`.

It also accepts Hiring Cafe URLs if you already configured filters in the website.

The actor returns one dataset item per job listing.

Each item includes normalized metadata that is ready for spreadsheets, dashboards, CRMs, or enrichment workflows.

### Who is it for?

Recruiters can monitor new hiring activity for target roles.

Talent sourcers can find companies hiring for specific skills.

Job-board operators can enrich their own listings with source URLs.

Labor-market analysts can track role demand across companies and locations.

Sales teams can identify companies that are actively growing teams.

Developers can use it as a simple Hiring Cafe jobs API.

### Why use this actor?

Hiring Cafe search pages contain rich structured job data.

Manually copying those jobs is slow and error-prone.

This actor automates the collection step.

It is HTTP-first, so runs are lightweight and cost-efficient.

It saves data in Apify datasets, so you can export JSON, CSV, Excel, XML, or RSS.

### Data you can extract

| Field | Description |
| --- | --- |
| `jobId` | Stable Hiring Cafe/source identifier |
| `title` | Job title |
| `companyName` | Employer name |
| `companyWebsite` | Company website when exposed |
| `location` | Formatted workplace location |
| `country` | Country from Hiring Cafe metadata |
| `remoteType` | Remote, hybrid, office, or related workplace type |
| `employmentType` | Commitment or role type |
| `seniority` | Seniority level when available |
| `salaryMin` | Minimum compensation |
| `salaryMax` | Maximum compensation |
| `currency` | Compensation currency |
| `datePosted` | Estimated publish date |
| `sourcePlatform` | Original ATS/source platform |
| `applyUrl` | Direct apply/source URL |
| `descriptionText` | Plain-text description or summary |
| `requirements` | Requirements summary |
| `benefits` | Benefits inferred from metadata |
| `tags` | Skills, tools, activities, languages |
| `industry` | Company industry/category |

### How much does it cost to scrape Hiring Cafe jobs?

This actor uses pay-per-event pricing.

You pay a small start event for each run.

You then pay per job listing saved to the dataset.

Small test runs are cheap because you can set `maxItems` to a low number.

Large exports scale with the number of jobs you collect.

### How to scrape Hiring Cafe jobs

1. Open the actor on Apify.

2. Enter one or more search queries.

3. Set the maximum number of jobs to save.

4. Optionally paste Hiring Cafe search URLs with your own filters.

5. Run the actor.

6. Download the dataset as JSON, CSV, Excel, or via API.

### Input options

#### Search queries

Use `searchQueries` for keywords.

Examples:

- `software engineer`
- `data analyst`
- `founding engineer`
- `product manager`
- `sales development representative`

#### Start URLs

Use `startUrls` when you already have a Hiring Cafe URL.

This is useful for searches configured in the Hiring Cafe interface.

The actor will parse the public server-rendered payload on those pages.

#### Maximum jobs

Use `maxItems` to control cost and runtime.

The default prefill is intentionally low for the first run.

Increase it after you confirm the output matches your workflow.

#### Include description HTML

Set `includeDescriptionHtml` to true if you need raw HTML.

Plain text is included whenever Hiring Cafe exposes description content.

### Example input

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

### Example output

```json
{
  "jobId": "grnhse___twilio___7647708",
  "title": "Software Engineer",
  "companyName": "Twilio",
  "companyWebsite": "twilio.com",
  "location": "United States",
  "country": "United States",
  "remoteType": "Remote",
  "employmentType": "Full-time",
  "seniority": "Mid-level",
  "salaryMin": 120000,
  "salaryMax": 180000,
  "currency": "USD",
  "sourcePlatform": "grnhse",
  "applyUrl": "https://job-boards.greenhouse.io/twilio/jobs/7647708",
  "tags": ["Python", "AWS", "APIs"],
  "isExpired": false,
  "scrapedAt": "2026-05-24T00:00:00.000Z"
}
```

### Tips for best results

Start with one query and `maxItems` around 25 to preview the data.

Use specific role names for cleaner results.

Use multiple queries when you need broader market coverage.

Deduplication is handled by job id inside a run.

If a query returns fewer jobs than requested, Hiring Cafe may expose fewer public SSR results for that search.

### Integrations

Send the dataset to Google Sheets for recruiter review.

Connect it to a CRM to create hiring-signal leads.

Feed results into a warehouse for job-market trend analysis.

Use Apify webhooks to trigger downstream workflows when a run finishes.

Combine with company enrichment actors to add domains, LinkedIn pages, and contact data.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/hiring-cafe-jobs-scraper').call({
  searchQueries: ['software engineer'],
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/hiring-cafe-jobs-scraper').call(run_input={
    'searchQueries': ['data analyst'],
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

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

### MCP usage

Use this actor from Claude or other MCP-compatible tools through Apify MCP.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/hiring-cafe-jobs-scraper`

Example prompts:

- "Scrape 50 software engineer jobs from Hiring Cafe and summarize the top hiring companies."
- "Find data analyst jobs and return companies with remote roles."
- "Export Hiring Cafe product manager listings to a table with salary ranges."

### Scheduling

Schedule the actor daily to monitor new Hiring Cafe listings.

Use a small `maxItems` for frequent monitoring.

Use larger runs for weekly market snapshots.

### Data freshness

The actor reads live public Hiring Cafe search pages at run time.

Results reflect what Hiring Cafe exposes in the server-rendered search payload.

Dates and expiration status depend on Hiring Cafe source metadata.

### Limitations

The actor does not log in to Hiring Cafe.

It only extracts public page data.

Some job descriptions may be summaries rather than full raw descriptions.

Some salary fields may be null when compensation is not transparent.

### Troubleshooting

#### Why did I get fewer jobs than `maxItems`?

The public page may expose fewer SSR jobs for that query, or duplicates may have been removed.

Try another query or paste a Hiring Cafe URL with broader filters.

#### Why are salaries empty?

Many employers do not publish compensation ranges.

The actor only returns salary values when Hiring Cafe exposes them.

### Legality

This actor extracts publicly available information from Hiring Cafe pages.

You are responsible for using the data lawfully and respecting applicable terms, privacy rules, and regulations.

Do not use scraped data for spam or unlawful profiling.

### Related scrapers

Explore more automation-lab actors:

- https://apify.com/automation-lab/google-maps-reviews-scraper
- https://apify.com/automation-lab/trustpilot-review-scraper
- https://apify.com/automation-lab/linkedin-company-scraper
- https://apify.com/automation-lab/product-hunt-scraper

### FAQ

#### Can I scrape multiple queries in one run?

Yes. Add multiple strings to `searchQueries`.

#### Can I use Hiring Cafe filter URLs?

Yes. Paste them into `startUrls`.

#### Does it use a browser?

No. The actor uses HTTP and parses the Next.js data payload.

#### Can I export to CSV?

Yes. Apify datasets support CSV, JSON, Excel, XML, RSS, and API access.

#### Does it include apply links?

Yes. The `applyUrl` field contains the direct apply/source URL when available.

#### Does it deduplicate jobs?

Yes. Jobs are deduplicated by job id within each run.

### Changelog

Initial version extracts public Hiring Cafe job search results from server-rendered page data.

# Actor input Schema

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

Keywords to search on Hiring Cafe, such as role names, skills, or company names.

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

Optional Hiring Cafe search URLs. Use this when you already configured filters in the Hiring Cafe interface.

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

Maximum number of job listings to save across all queries and URLs.

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

Save raw HTML for descriptions when Hiring Cafe exposes it in the page payload. Plain text is always included when available.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer",
    "data analyst"
  ],
  "startUrls": [
    {
      "url": "https://hiring.cafe/?searchState=%7B%22searchQuery%22%3A%22product%20manager%22%2C%22page%22%3A1%7D"
    }
  ],
  "maxItems": 20,
  "includeDescriptionHtml": false
}
```

# Actor output Schema

## `overview` (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 = {
    "searchQueries": [
        "software engineer",
        "data analyst"
    ],
    "startUrls": [
        {
            "url": "https://hiring.cafe/?searchState=%7B%22searchQuery%22%3A%22product%20manager%22%2C%22page%22%3A1%7D"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/hiring-cafe-jobs-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 = {
    "searchQueries": [
        "software engineer",
        "data analyst",
    ],
    "startUrls": [{ "url": "https://hiring.cafe/?searchState=%7B%22searchQuery%22%3A%22product%20manager%22%2C%22page%22%3A1%7D" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/hiring-cafe-jobs-scraper").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 '{
  "searchQueries": [
    "software engineer",
    "data analyst"
  ],
  "startUrls": [
    {
      "url": "https://hiring.cafe/?searchState=%7B%22searchQuery%22%3A%22product%20manager%22%2C%22page%22%3A1%7D"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/hiring-cafe-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/hiring-cafe-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hiring Cafe Jobs Scraper",
        "description": "Extract Hiring Cafe job listings with companies, locations, salaries, skills, source platforms, and apply URLs for recruiting and market research.",
        "version": "0.1",
        "x-build-id": "8MxVNCE5m0n1MZJwh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~hiring-cafe-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-hiring-cafe-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~hiring-cafe-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-hiring-cafe-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~hiring-cafe-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-hiring-cafe-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search on Hiring Cafe, such as role names, skills, or company names.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Hiring Cafe search URLs",
                        "type": "array",
                        "description": "Optional Hiring Cafe search URLs. Use this when you already configured filters in the Hiring Cafe interface.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job listings to save across all queries and URLs.",
                        "default": 20
                    },
                    "includeDescriptionHtml": {
                        "title": "Include description HTML",
                        "type": "boolean",
                        "description": "Save raw HTML for descriptions when Hiring Cafe exposes it in the page payload. Plain text is always included when available.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
