# Hcareers Hotel & Restaurant Job Finder by Category (`dataspryva/hcareers-hotel-and-restaurant-job-finder`) Actor

Search Hcareers hospitality job listings by keyword, location, state/province, or 26 job categories, with employment-type and remote filters, full descriptions, and parent-brand details.

- **URL**: https://apify.com/dataspryva/hcareers-hotel-and-restaurant-job-finder.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** Jobs, Travel, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

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

## Hcareers Hotel & Restaurant Job Finder by Category

[Hcareers](https://www.hcareers.com) is the dedicated job board for hotels, resorts, restaurants, casinos and the wider hospitality industry. This actor searches it by keyword, city, state/province, any of its 26 job categories or 49 hotel brands, walks the site's entire jobs index, fetches specific job postings, and scrapes employer profiles — returning pay ranges, perks, apply links, photos, full descriptions and property details. No login, proxy, or cookies required.

### What this actor does

- **Four modes:** `search` (keyword / location / state / category / brand browsing), `allJobs` (the complete open-jobs index, with an optional `updatedSince` date for incremental runs), `byUrls` (specific job postings), and `employers` (company profiles, with their open jobs)
- **Complete filter surface:** 26 hospitality job categories, 49 live state/province pages (US + Canada), 49 hotel-brand pages, free-text city search, remote-only, and employment-type filtering
- **Rich job records:** advertised pay with parsed `salaryMin`/`salaryMax`/`salaryPeriod`, perks, the application link (employer ATS when available), photo galleries, and the employer's property profile
- **Employer data:** company description, address, property type, property/job counts, parent brand details and sister properties
- **Empty fields are omitted** — a field the listing genuinely lacks is left out, never sent as `null`

### Output per job

- `jobId`, `jobUrl`, `title`
- `employer`, `employerLogoUrl`, `employerProfileUrl`
- `brand`, `brandLogoUrl`, `brandProfileUrl` — parent hotel group, when the property is managed by one
- `location`, `locationRaw`, `locationCity`, `locationState`, `locationPostalCode`, `locationCountry`
- `category` — set when a category filter was used
- `employmentType`, `employmentTypeBadges[]`, `isRemote`
- `compensationRaw` — pay exactly as advertised; `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` — parsed from the advertised text (`HOUR`, `YEAR`, `MONTH`, …) only when the listing states it; `compensationAmount` — structured amount when the site provides one
- `perks` — advertised perks (e.g. signing bonus)
- `applyUrl` — the job's application link (employer's ATS, or Hcareers' own application flow)
- `description` (plain text), `descriptionHtml`, `photoUrl`, `photoUrls[]`
- `industry`, `datePosted`, `closingDate` — ISO 8601, `postedRelative` (e.g. `"6 days ago"`)
- `employerAbout`, `employerAddress`, `employerPropertyType`, `employerPropertyCount`, `employerJobCount`, `brandAbout`
- `recordType: "job"`, `scrapedAt`

### Output per employer (mode = `employers`)

- `employerName`, `employerProfileUrl`
- `about`, `address`, `propertyType`, `propertyCount`, `jobCount`
- `brandName`, `brandProfileUrl`, `brandAbout`
- `properties[]` — sister properties with `name`, `location`, `jobCount`, `url`
- `recordType: "employer"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `allJobs` / `byUrls` / `employers` |
| `keywords` | string | – | Free-text search terms (mode=search) |
| `location` | string | – | City/region/landmark (mode=search) |
| `state` | select | – | US state or Canadian province with live pages (mode=search). Oregon, Puerto Rico and Quebec are kept for older saved tasks; they have no current postings |
| `category` | select | – | One of 26 hospitality job categories (mode=search) |
| `brand` | select | – | One of 49 hotel brands or groups (mode=search) |
| `remoteOnly` | bool | `false` | Remote-eligible positions only (mode=search) |
| `employmentTypes` | array (enum) | `[]` | Full-Time / Part-Time / Temporary / On-Call / Seasonal (mode=search) |
| `jobUrls` | array | – | Job URLs or job IDs (mode=byUrls) |
| `employerUrls` | array | – | Employer profile URLs or slugs (mode=employers) |
| `includeEmployerJobs` | bool | `true` | Also collect the employer's open jobs (mode=employers) |
| `fetchFullDescription` | bool | `true` | Visit each job's detail page for the full record (mode=search) |
| `updatedSince` | string | – | Date or timestamp incremental cutoff, e.g. `2026-10-11` or `2026-10-11T08:30:00` (mode=allJobs) |
| `maxItems` | int | `24` | Hard cap on emitted records (1–5000) |

#### Example: kitchen jobs in California, full-time

```json
{
  "mode": "search",
  "category": "chefs-kitchen",
  "state": "CA",
  "employmentTypes": ["Full-Time"],
  "maxItems": 50
}
```

#### Example: every open job, refreshed weekly

```json
{
  "mode": "allJobs",
  "updatedSince": "2026-10-11",
  "maxItems": 5000
}
```

#### Example: Marriott-brand remote roles

```json
{
  "mode": "search",
  "brand": "marriott-hotels",
  "remoteOnly": true,
  "maxItems": 100
}
```

#### Example: specific postings and employer profiles

```json
{
  "mode": "employers",
  "employerUrls": ["omni-hotels-resorts"],
  "includeEmployerJobs": true,
  "maxItems": 200
}
```

### Use cases

- **Hospitality recruitment intelligence** — track hiring activity by brand, state, category and property
- **Compensation benchmarking** — aggregate advertised pay ranges by role, category, brand or region
- **Job feeds for career sites** — refresh a hospitality job board with structured records and working apply links
- **Employer/competitor research** — follow which properties a management group is staffing and where
- **Labor-market datasets** — incremental exports of the whole board for analysis and dashboards

### FAQ

**Does this require an Hcareers account?** No — every listing, company profile and job detail page used is public.

**What's the difference between `search` and `allJobs`?** `search` supports filters and returns what matches; `allJobs` walks Hcareers' complete jobs index, so it is the way to export every open posting (with `updatedSince` for incremental refresh — a date or an exact timestamp). Hcareers does not print a job category on posting pages, so `allJobs` records carry no `category`; use `search` with a category filter when you need that field.

**Why is pay missing on some jobs?** Many hospitality employers don't advertise pay at all. When they do, `compensationRaw` carries the exact text and `salaryMin`/`salaryMax`/`salaryPeriod` are parsed from it; if the text can't be parsed faithfully, only the raw text is returned. Pay mentioned only informally somewhere inside the free-text description (often ambiguous — a price or discount, not a wage) is deliberately not guessed into the structured fields.

**Why does `applyUrl` sometimes point back to hcareers.com?** Some employers accept applications through Hcareers' own application flow (which asks applicants for a free account); others link straight to their ATS. The actor returns whichever the posting uses.

**Why do some jobs show a `brand` and others don't?** Independent properties have no parent group. When a hotel is managed by a brand or management company, Hcareers surfaces it as "A property of: …" and the actor includes it.

**What is the property profile?** Each job's detail page includes the employer's company description, address, property type, and property and job counts; the actor copies these to `employer*` fields. Mode `employers` returns the same data as its own record, with sister properties.

**Can I combine category, state, brand and keywords?** Yes — filters combine with AND logic in `search` mode.

**Is this affiliated with Hcareers?** No, this is a third-party actor using only publicly visible pages.

**How fresh is the data?** Every run reads live pages, so listings reflect the site at run time; new postings appear on the same day they're added.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `keywords` (type: `string`):

Free-text search terms (job title, skill, employer/brand name). Leave empty to browse by category/state/brand only. (mode=search)

## `location` (type: `string`):

City, region, or landmark to search near (e.g. `New York, NY`, `Miami Beach`). (mode=search)

## `state` (type: `string`):

Restrict to a US state or Canadian province. Oregon, Puerto Rico and Quebec are kept for older saved tasks; they have no current Hcareers postings. (mode=search)

## `category` (type: `string`):

Restrict to a specific hospitality job category. (mode=search)

## `brand` (type: `string`):

Restrict to jobs at properties of a specific hotel brand or group. (mode=search)

## `remoteOnly` (type: `boolean`):

Only remote-eligible positions. On its own this uses Hcareers' dedicated remote list; combined with other filters it keeps only remote matches of the combined search. (mode=search)

## `employmentTypes` (type: `array`):

Keep only jobs whose listing badges match one of the selected types. (mode=search)

## `jobUrls` (type: `array`):

Direct Hcareers job posting URLs or job IDs, e.g. `https://www.hcareers.com/jobs/4239412-bell-person` or `4239412`.

## `employerUrls` (type: `array`):

Hcareers employer profile URLs or slugs, e.g. `https://www.hcareers.com/omni-hotels-resorts` or `grand-casinos`.

## `includeEmployerJobs` (type: `boolean`):

Also collect each employer's open job postings beside its profile. (mode=employers)

## `fetchFullDescription` (type: `boolean`):

In mode=search, visit each job's detail page for the full description, pay, apply link, photos and property profile. Always on for mode=allJobs and mode=byUrls. (mode=search)

## `updatedSince` (type: `string`):

Optional cutoff for incremental runs — a date `2026-10-11` or a full timestamp `2026-10-11T08:30:00`. Only jobs whose Hcareers index entry changed on/after it are returned.

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

Hard cap on emitted records (jobs plus employer profiles).

## Actor input object example

```json
{
  "mode": "search",
  "keywords": "chef",
  "remoteOnly": false,
  "employmentTypes": [],
  "jobUrls": [],
  "employerUrls": [],
  "includeEmployerJobs": true,
  "fetchFullDescription": true,
  "maxItems": 24
}
```

# Actor output Schema

## `jobs` (type: `string`):

Dataset containing all scraped job postings and employer profiles.

# 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 = {
    "mode": "search",
    "keywords": "chef",
    "remoteOnly": false,
    "employmentTypes": [],
    "jobUrls": [],
    "employerUrls": [],
    "includeEmployerJobs": true,
    "fetchFullDescription": true,
    "maxItems": 24
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/hcareers-hotel-and-restaurant-job-finder").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 = {
    "mode": "search",
    "keywords": "chef",
    "remoteOnly": False,
    "employmentTypes": [],
    "jobUrls": [],
    "employerUrls": [],
    "includeEmployerJobs": True,
    "fetchFullDescription": True,
    "maxItems": 24,
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/hcareers-hotel-and-restaurant-job-finder").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 '{
  "mode": "search",
  "keywords": "chef",
  "remoteOnly": false,
  "employmentTypes": [],
  "jobUrls": [],
  "employerUrls": [],
  "includeEmployerJobs": true,
  "fetchFullDescription": true,
  "maxItems": 24
}' |
apify call dataspryva/hcareers-hotel-and-restaurant-job-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/hcareers-hotel-and-restaurant-job-finder"
        }
    }
}
```

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/7RmIU4jIs8a7yOKmM/builds/TJjUQ7nV32MbcqsSD/openapi.json