# Breezy HR Scraper \[Only $5💰] | Job Boards | Careers (`ahmed_jasarevic/boards-breezy-hr-scraper`) Actor

Scrape Breezy HR job boards for recruiting and talent-market research: job title, company, location, remote status, job type, salary, department, description HTML, apply URL and posted date.

- **URL**: https://apify.com/ahmed_jasarevic/boards-breezy-hr-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.80 / 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.
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

## Boards Breezy HR Scraper

Scrape every open job posting from any Breezy HR career board for recruiting, talent-market research and job-board products: job title, company, location and remote status, job type, salary, department, full description HTML, apply URL and posted date.

This actor does not need a browser. Breezy boards serve all of their open positions at a public `<board>/json` endpoint, so one request discovers the complete job list; the actor falls back to a CheerioCrawler HTML crawl when that endpoint is unavailable.

### Main Use Cases

- Recruiting and sourcing from company career sites that run on Breezy HR
- Talent-market research and salary benchmarking across many employers
- Building job-board and job-aggregator feeds
- Tracking open roles and hiring activity for target companies
- Lead generation for staffing and recruiting agencies
- Monitoring competitor hiring and role mix over time

### How It Works

The actor uses two complementary sources, cheapest first:

| Step | Surface | What it does |
| --- | --- | --- |
| 1. JSON discovery | `<board>/json` | Return every open position in one request (title, company, location, remote status, job type, salary, published date), including boards that hide jobs behind pagination on the HTML page. |
| 2. HTML crawl (Cheerio) | Board and job pages (`/p/*`) | Fall back to the HTML listing and read the full description HTML from each job page. Jobs are deduplicated by URL. |
| 3. Push rows | Dataset | One clean JSON record per job. |

With `fetchDescriptions: false`, results are pushed straight from the discovered data and the job pages are never visited, which is significantly faster.

### Extract Breezy HR Jobs Without An Official API

Breezy HR does not expose a public, documented jobs API that third parties can call; the keyless `<board>/json` feed that each Breezy career site serves is what the board itself loads. This actor reads that feed and, when a board does not serve it, falls back to the HTML listing so no job on the board is missed.

### Analyze Job Boards, Salaries And Remote Roles

Each row carries the salary string (when the posting includes one), the job type (full-time, part-time, contract), the department, the location and any remote status, plus the full description HTML and the apply URL. That is the dataset for salary benchmarking, remote-role trend analysis, department mix and detailed job-description text mining.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `startUrls` | array | No | `https://team-201.breezy.hr/` | Breezy HR board URLs to start with. |
| `maxItems` | integer | No | `1000` | Maximum jobs pushed to the dataset. Free users are capped at 10. |
| `fetchDescriptions` | boolean | No | `true` | Visit every job page for the full description HTML. Turn off for a much faster metadata-only run. |
| `maxRequestsPerCrawl` | integer | No | `100` | Maximum requests (allow one per job when descriptions are enabled). |
| `maxConcurrency` | integer | No | `2` | Maximum concurrent requests. |
| `proxy` | object | No | Apify Proxy off | Proxy configuration used for the requests. |

### Output Fields

One item per job:

- `jobTitle`, `company`, `location`: role title, company name and location (may include remote status).
- `jobType`, `salary`, `department`: job type, salary range (when available) and department.
- `descriptionHtml`, `applyUrl`, `postedDate`, `url`: full description HTML, apply link, posted date (ISO 8601 from the board JSON feed) and job posting URL.

Dataset view: `overview`.

### Example Input And Output

Example input:

```json
{
  "startUrls": [{ "url": "https://company.breezy.hr/" }],
  "maxItems": 100,
  "fetchDescriptions": true,
  "maxConcurrency": 2
}
```

Example output row:

```json
{
  "jobTitle": "Senior Backend Engineer",
  "company": "Example Company",
  "location": "Remote (US)",
  "jobType": "Full-time",
  "salary": "$140,000 - $170,000",
  "department": "Engineering",
  "descriptionHtml": "<p>We are hiring a Senior Backend Engineer...</p>",
  "applyUrl": "https://company.breezy.hr/p/abcdef123456-senior-backend-engineer/apply",
  "postedDate": "2026-09-28T14:32:00.000Z",
  "url": "https://company.breezy.hr/p/abcdef123456-senior-backend-engineer"
}
```

### Integrations & Automation

Results are written to Apify datasets, so you can export them as JSON, CSV or Excel, read them through the Apify API, or push them onward with webhooks. Connect the actor to Zapier or Make to load rows into an ATS, a CRM, a spreadsheet or a BI tool.

For job monitoring, schedule the actor daily on your target boards so each run records new and removed postings over time. A weekly schedule is usually enough for slower market research. Recurring runs also help the actor surface better in the Apify Store.

### Related Actors

- [bovi/greenhouse-lever-ashby-job-scraper](https://apify.com/bovi/greenhouse-lever-ashby-job-scraper)
- [viridian_layout_ea2/company-career-site-jobs](https://apify.com/viridian_layout_ea2/company-career-site-jobs)
- [benthepythondev/breezyhr-jobs-scraper](https://apify.com/benthepythondev/breezyhr-jobs-scraper)
- [devilscrapes/breezy-hr-jobs-scraper](https://apify.com/devilscrapes/breezy-hr-jobs-scraper)
- [scrapers_lat/breezy-hr-jobs-scraper](https://apify.com/scrapers_lat/breezy-hr-jobs-scraper)

### FAQ

#### Is there an official Breezy HR jobs API?

Breezy HR is an applicant tracking system (ATS) for employers, and its customer-facing API is scoped to a company's own account. There is no public, documented, third-party jobs API. Each Breezy career site, however, serves a keyless `<board>/json` feed of its published positions, which is what this actor and the board itself read.

#### What are the alternatives to this actor for Breezy HR job data?

Alternatives include other Apify Store actors that target Breezy boards (listed above), broader ATS job scrapers that cover Greenhouse, Lever and Ashby in one run, and paid job-feed APIs such as JobsPipe. This actor focuses on Breezy boards and reads the full description HTML when needed.

#### Do I need a browser or a proxy?

No. The public JSON feed is fetched over plain HTTP and the fallback crawl uses CheerioCrawler, so no browser is needed. The default runs without a proxy; you can attach an Apify proxy for very large runs.

#### Can I scrape descriptions as well as metadata?

Yes. `fetchDescriptions` defaults to true and visits each job page for the full description HTML. Set it to false for a much faster run that returns metadata only (title, company, location, type, salary, department, apply URL, posted date).

#### Does it handle boards that hide jobs behind pagination?

Yes. The `<board>/json` feed returns every open position in one request, including jobs that the HTML listing hides behind pagination. The HTML crawl remains the fallback and a second source of truth.

#### Can I monitor the same boards over time?

Yes. Schedule the actor on your target board URLs and keep them the same, so each run records the current set of open roles. Comparing runs shows newly opened and closed positions.

### SEO Keywords

breezy hr scraper, breezy hr jobs, breezy jobs scraper, breezy career site jobs, ats job scraper, job board scraper, scrape job postings, careers page scraper, remote jobs data, salary data, job posting data, recruiting leads, talent market research, job listing api, greenhouse lever ashby jobs, company career site jobs, hiring data, job feed, job scraper no login, job description html, department job data, job board api, staffing agency leads, job posting export, ats jobs data

### For AI Agents & LLM Apps

Purpose: return one job row per open position (title, company, location, type, salary, department, description HTML, apply URL) from Breezy HR career boards.

Minimal working input:

```json
{ "startUrls": [{ "url": "https://company.breezy.hr/" }] }
```

Variant that returns metadata only, much faster:

```json
{ "startUrls": [{ "url": "https://company.breezy.hr/" }], "fetchDescriptions": false, "maxItems": 500 }
```

Output fields: `jobTitle`, `company`, `location`, `jobType`, `salary`, `department`, `descriptionHtml`, `applyUrl`, `postedDate`, `url`.

Behaviors an agent should know:

- `fetchDescriptions` defaults to true; turning it off skips the per-job page visit and drops only `descriptionHtml`.
- Jobs are deduplicated by URL across the JSON feed and the HTML crawl.
- Leaving `maxItems` unset uses the default of 1000; free users are capped at 10. If descriptions are enabled, allow one request per job in `maxRequestsPerCrawl`.
- No browser and no proxy are required; the actor reads the public `<board>/json` feed first and falls back to HTML.

Billing: pay-per-event. `apify-actor-start` (about $0.00005) and one `apify-default-dataset-item` per job row (about $0.005, less at higher loyalty tiers).

### Legal & Compliance Disclaimer

This actor is independent and is not affiliated with, endorsed by or sponsored by Breezy HR or Breezy HR, Inc. It reads only the publicly available `<board>/json` feed and public career pages: it does not log in, does not bypass authentication and does not solve CAPTCHAs.

Users are responsible for complying with Breezy HR's Terms of Service, the terms of the boards they scrape, and applicable data-protection law in their own jurisdiction. Where the output contains personal data, that data must not be used for unsolicited commercial outreach in violation of applicable law.

# Actor input Schema

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

Breezy HR board URLs to start with (e.g., https://company.breezy.hr/).

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

Maximum number of jobs to scrape and push to the dataset. Free users are always capped at 10 items.

## `fetchDescriptions` (type: `boolean`):

Visit every job page to collect the full description HTML. Turn off to get all results much faster (without descriptions).

## `maxRequestsPerCrawl` (type: `integer`):

Maximum number of requests that can be made by this crawler. With descriptions enabled, allow one request per job (plus one per board page).

## `maxConcurrency` (type: `integer`):

Maximum number of concurrent requests.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://team-201.breezy.hr/"
    }
  ],
  "maxItems": 1000,
  "fetchDescriptions": true,
  "maxRequestsPerCrawl": 100,
  "maxConcurrency": 2,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://team-201.breezy.hr/"
        }
    ],
    "maxItems": 1000,
    "fetchDescriptions": true,
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/boards-breezy-hr-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 = {
    "startUrls": [{ "url": "https://team-201.breezy.hr/" }],
    "maxItems": 1000,
    "fetchDescriptions": True,
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/boards-breezy-hr-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 '{
  "startUrls": [
    {
      "url": "https://team-201.breezy.hr/"
    }
  ],
  "maxItems": 1000,
  "fetchDescriptions": true,
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/boards-breezy-hr-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/boards-breezy-hr-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/yb3BB3bZstbnTqf5a/builds/qbX8Gbbp5k301dFuZ/openapi.json