# BreezyHR Jobs Scraper - Public Career Site Jobs (`benthepythondev/breezyhr-jobs-scraper`) Actor

Scrape public BreezyHR career portals for current jobs, companies, locations, remote status, salary ranges, descriptions and direct application URLs.

- **URL**: https://apify.com/benthepythondev/breezyhr-jobs-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Jobs, Automation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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/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

## BreezyHR Jobs Scraper - Public Career Site Jobs

Collect current job openings from public BreezyHR career portals and export them as structured data. The Actor visits the company career pages you provide, discovers their published positions, and reads the public Schema.org `JobPosting` data on each listing. Results include job title, employer, location, remote status, employment type, posting dates, salary data, description, and the direct application URL.

This Actor is designed for people who already know which companies or BreezyHR portals they want to monitor. It does not require a Breezy account, an API key, a browser, or a proxy. You provide one or more public career portal URLs and receive a clean dataset that can be exported as JSON, CSV, Excel, XML, or RSS through Apify.

### What is BreezyHR?

BreezyHR is an applicant tracking system used by companies to publish job openings and manage recruiting workflows. Employers can expose a public career portal on a `breezy.hr` subdomain or on a custom domain. Public positions contain applicant-facing information that candidates can view before applying.

The BreezyHR Jobs Scraper focuses only on those public career pages. It does not access candidate records, private hiring pipelines, employer dashboards, or authenticated Breezy APIs.

### What data can you extract?

Each dataset item represents one current public job and can include:

- Stable job ID derived from the public position URL
- Job title
- Hiring company name and public company URL
- Company logo when the employer publishes one
- Clean plain-text job description
- Employment types such as full-time, part-time, or contract
- Date posted and listing expiration date when supplied
- Structured street, city, region, postal code, and country fields
- Applicant location requirements for remote jobs
- Human-readable combined location
- Remote or telecommute indicator
- Structured salary currency, period, minimum, maximum, or fixed value
- Direct public job and application URL
- Source career portal and scrape timestamp

Fields are taken from public employer data. A field can be null when the company did not publish it.

### Common use cases

#### Company hiring monitoring

Run the Actor on a schedule to track when selected companies add or remove openings. This can support competitor research, account intelligence, staffing analysis, and market monitoring.

#### Niche job boards

Combine public jobs from several BreezyHR career portals into a focused feed. For example, you can monitor agencies, healthcare employers, startups, or companies in a specific region.

#### Recruiting and sales signals

Open roles can reveal where a company is investing. New engineering, sales, finance, or operations positions can be useful signals for research teams when combined with responsible human review.

#### Job alerts and workflow automation

Connect the dataset to Make, Zapier, n8n, Google Sheets, Slack, email, or a database. Schedule recurring runs and compare results by `job_id` or `url` to identify newly published roles.

#### Labor-market research

Normalize titles, locations, remote flags, employment types, and disclosed salary ranges across selected employers without manually opening every listing.

### Input

#### `careerUrls`

A list of public BreezyHR career portal roots. Example:

```json
{
  "careerUrls": [
    "https://there-is-talent.breezy.hr/",
    "https://shown-media.breezy.hr/"
  ],
  "maxResults": 25
}
````

Use the career portal root, not an employer dashboard URL. If you paste a public `/p/...` job link, the Actor normalizes it back to that company's portal root.

#### `query`

Optional space-separated keywords. Every word must appear somewhere in the normalized title, company, description, employment type, or location. Leave it empty to return all public jobs from the supplied portals.

#### `location`

Optional case-insensitive city, region, or country filter. The value is matched against the normalized public location fields.

#### `remoteOnly`

When enabled, only positions explicitly marked as telecommute by the employer are returned. A description that merely mentions flexible work does not automatically count as remote.

#### `includeDescription`

Enabled by default. The Actor converts the public HTML job description into readable plain text. Disable this option when you only need compact metadata.

#### `maxResults`

Maximum number of jobs saved across all supplied portals. The default is 10 so first runs and Apify quality tests finish quickly. The upper bound is 1,000.

### Input examples

#### Find remote openings

```json
{
  "careerUrls": ["https://shown-media.breezy.hr/"],
  "remoteOnly": true,
  "maxResults": 10
}
```

#### Search several employers for marketing work

```json
{
  "careerUrls": [
    "https://shown-media.breezy.hr/",
    "https://there-is-talent.breezy.hr/"
  ],
  "query": "marketing",
  "includeDescription": true,
  "maxResults": 50
}
```

### Example output

```json
{
  "job_id": "aa5aa1ecfe83",
  "title": "Content Writer",
  "company": "Shown Media",
  "company_url": "https://shown-media.breezy.hr",
  "description": "About Shown Media ...",
  "employment_types": ["FULL_TIME"],
  "date_posted": "2026-04-06",
  "valid_through": null,
  "locations": [
    {
      "name": null,
      "street": null,
      "city": null,
      "region": null,
      "postal_code": null,
      "country": "worldwide"
    }
  ],
  "applicant_locations": ["worldwide"],
  "location_text": "worldwide",
  "remote": true,
  "salary": {
    "currency": "USD",
    "unit": "YEAR",
    "min": 50000,
    "max": 85000,
    "value": null
  },
  "url": "https://shown-media.breezy.hr/p/aa5aa1ecfe83-content-writer",
  "source": "breezyhr",
  "career_site_url": "https://shown-media.breezy.hr/",
  "scraped_at": "2026-07-13T00:00:00+00:00"
}
```

### How it works

The Actor uses direct HTTP requests with bounded retries. It first reads each public career portal and deduplicates position links. It then loads detail pages in small concurrent batches and parses their structured `JobPosting` blocks. Filters are applied to normalized fields, and only unique matching jobs are pushed to the default dataset.

If a portal is invalid, private, empty, or all filters remove every job, the run fails explicitly instead of returning a misleading successful empty dataset. This behavior makes monitoring failures visible and protects automation workflows from silently accepting missing data.

### Pricing

The Actor uses pay-per-event pricing:

- A small Actor-start event is charged once per run.
- A result event is charged for each unique job written to the default dataset.

Use `maxResults` to control the maximum result cost. There are no proxy, browser, or external API-key requirements.

### Scheduling and integrations

Apify can run the Actor hourly, daily, weekly, or on a custom schedule. The default dataset can feed:

- Google Sheets or Excel reporting
- Make, Zapier, and n8n workflows
- Slack or email job alerts
- Data warehouses and databases
- Internal search, analytics, and research tools
- Webhooks and custom applications through the Apify API

For recurring monitoring, store `job_id` or `url` in your destination and compare each run with earlier results. This avoids treating an unchanged opening as a new alert.

### Reliability and responsible use

The Actor only reads public applicant-facing pages. Public career portals can change, positions can close, and employers can omit fields. Keep scheduled workflows tolerant of null values and review important decisions against the source listing.

Use the data lawfully and respect applicable privacy, employment, anti-discrimination, and marketing rules. Do not use job data to make automated high-impact decisions about individuals. This Actor does not collect candidate or applicant information.

### Frequently asked questions

#### Do I need a BreezyHR account?

No. The Actor reads public career portals and public job pages.

#### Can I search every BreezyHR company at once?

This Actor is intentionally portal-driven. Supply the companies you want to monitor. It does not claim to maintain a private index of every BreezyHR employer.

#### Does it support custom career domains?

It supports public pages that retain the BreezyHR portal and `JobPosting` structure. If a custom employer site replaces that structure entirely, use its underlying BreezyHR portal URL instead.

#### Why is a salary or location missing?

The employer did not publish that field in the public structured data. The Actor does not invent missing values.

#### Can I collect remote jobs only?

Yes. Enable `remoteOnly`. The Actor requires the employer's explicit telecommute marker.

#### What happens when no jobs match?

The run fails with a clear message. This prevents scheduled workflows from confusing a blocked, private, or over-filtered portal with a valid empty result.

#### How do I request support?

Open an issue from the Actor page and include the public career URL, a redacted input example, and the run ID. Do not post tokens or private credentials.

#### Was the dataset useful?

After a successful run with real output, please leave an honest review on the Actor page. Reviews help other users evaluate reliability and help prioritize future maintenance.

### Related Actors

- [Teamtailor Jobs Scraper](https://apify.com/benthepythondev/teamtailor-jobs-scraper)
- [Personio Jobs Scraper](https://apify.com/benthepythondev/personio-jobs-scraper)
- [Workable Jobs Scraper](https://apify.com/benthepythondev/workable-jobs-scraper)
- [Greenhouse Jobs Scraper](https://apify.com/benthepythondev/greenhouse-jobs-scraper)
- [ATS Jobs Aggregator](https://apify.com/benthepythondev/ats-jobs-aggregator)

Keywords: BreezyHR jobs scraper, Breezy jobs API, Breezy career portal scraper, ATS jobs data, company hiring signals, remote job monitoring, public job postings, recruiting intelligence, job board data, salary data, career site automation.

# Actor input Schema

## `careerUrls` (type: `array`):

Public BreezyHR career portal roots, such as https://there-is-talent.breezy.hr/. You can include more than one company.

## `query` (type: `string`):

Optional words that must all appear in the title, company, description, employment type or location.

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

Optional city, region or country filter.

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

Return only jobs marked as telecommute or remote by the employer.

## `includeDescription` (type: `boolean`):

Convert each public job description from HTML into clean text.

## `maxResults` (type: `integer`):

Maximum number of jobs to save across all career portals.

## Actor input object example

```json
{
  "careerUrls": [
    "https://there-is-talent.breezy.hr/"
  ],
  "query": "",
  "location": "",
  "remoteOnly": false,
  "includeDescription": true,
  "maxResults": 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 = {
    "careerUrls": [
        "https://there-is-talent.breezy.hr/"
    ],
    "query": "",
    "location": "",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/breezyhr-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 = {
    "careerUrls": ["https://there-is-talent.breezy.hr/"],
    "query": "",
    "location": "",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/breezyhr-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 '{
  "careerUrls": [
    "https://there-is-talent.breezy.hr/"
  ],
  "query": "",
  "location": "",
  "maxResults": 10
}' |
apify call benthepythondev/breezyhr-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BreezyHR Jobs Scraper - Public Career Site Jobs",
        "description": "Scrape public BreezyHR career portals for current jobs, companies, locations, remote status, salary ranges, descriptions and direct application URLs.",
        "version": "1.0",
        "x-build-id": "VPnladHuvlUHHKrFc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~breezyhr-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-breezyhr-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/benthepythondev~breezyhr-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-breezyhr-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/benthepythondev~breezyhr-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-breezyhr-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",
                "required": [
                    "careerUrls"
                ],
                "properties": {
                    "careerUrls": {
                        "title": "BreezyHR career portal URLs",
                        "type": "array",
                        "description": "Public BreezyHR career portal roots, such as https://there-is-talent.breezy.hr/. You can include more than one company.",
                        "default": [
                            "https://there-is-talent.breezy.hr/"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Optional words that must all appear in the title, company, description, employment type or location.",
                        "default": ""
                    },
                    "location": {
                        "title": "Location contains",
                        "type": "string",
                        "description": "Optional city, region or country filter.",
                        "default": ""
                    },
                    "remoteOnly": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "Return only jobs marked as telecommute or remote by the employer.",
                        "default": false
                    },
                    "includeDescription": {
                        "title": "Include descriptions",
                        "type": "boolean",
                        "description": "Convert each public job description from HTML into clean text.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of jobs to save across all career portals.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
