# Breezy HR Jobs Scraper - Pay Ranges & Apply Links (`starbright_overlap/breezy-hr-jobs-scraper`) Actor

Scrape live job postings from any Breezy HR career site, or search 2,800 known Breezy employers in one run. Titles, locations, employment type, pay ranges and apply links.

- **URL**: https://apify.com/starbright\_overlap/breezy-hr-jobs-scraper.md
- **Developed by:** [Sulle H](https://apify.com/starbright_overlap) (community)
- **Categories:** Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 job 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Breezy HR Jobs Scraper — 2,800 Career Sites, Pay Ranges Included

Point it at a company and get every open role on its **Breezy HR** board. Or leave the company list
empty and search a bundled registry of **2,800 live Breezy career sites** (47,301 open
postings at last count) in a single run.

```json
{ "companies": ["https://10-4-truck-recruiting.breezy.hr"] }
```

```json
{ "keywords": ["sales"], "remoteOnly": true, "maxJobs": 300 }
```

No login, no cookies, no proxies, no API key.

### Why most tools cannot find Breezy boards

Every other applicant tracking system in this family puts the company in the **path** —
`apply.workable.com/acme`, `jobs.lever.co/acme`. Breezy puts it in the **subdomain**:
`acme.breezy.hr`. A crawler that harvests board URLs by reading path segments finds Breezy boards
nowhere, which is why public lists of Breezy employers are so thin.

This registry was built by harvesting subdomains out of the Wayback Machine index and validating
each one against the live API. Boards that answered with real postings went in; the rest did not.

There is a second trap worth knowing if you build your own: **Breezy answers `403`, not `404`, for
a subdomain with no board on it.** Every other platform here uses 403 to mean "slow down", so a
shared retry path treats a dead board as throttling and backs off for tens of seconds on every one.
Getting that wrong turned a 36-minute validation pass into a projected 14 hours.

### What you get

| Field | Description |
|---|---|
| `provider` | Always `breezy` — the same schema the multi-ATS Actors below emit |
| `company` / `companySlug` | Employer name and its Breezy subdomain |
| `jobId` | Breezy posting id — stable, so it works as a dedupe key across runs |
| `title` | Job title |
| `location` | Display location as Breezy renders it, e.g. `Exeter, NH` |
| `department` | Department label |
| `employmentType` | Full-time, part-time or contract |
| `remote` | Breezy's own remote flag |
| `postedAt` | Publication date, ISO 8601 |
| `applyUrl` | Direct application link on the employer's board |
| `salary` | Pay range as the employer wrote it — see below |
| `scrapedAt` | When this row was read |

### Breezy publishes pay, and almost nobody else does

Of the seven applicant tracking systems covered by this family of Actors, **Breezy is one of only
two whose public listing endpoint carries a pay range** — as a plain string, exactly as the employer
typed it:

```
"$70,000 – $85,000 / year"
"$28 – $100 / hour"
```

It stays a string rather than parsed numbers, because employers disagree about period, currency and
whether the figure includes equity, and turning that into a number would mean guessing. About half
of Breezy postings carry one; the rest come back `null` because the employer left it blank.

For salary benchmarking or a job board that promises transparent pay, this is the cheapest real
source in the set.

### What Breezy does not publish

**There is no description text on this endpoint.** `descriptionText` is `null` on every row — the
listing API returns title, location, department, type, salary and a link, and nothing more. Any tool
claiming full Breezy descriptions from this endpoint is either fetching each posting page
separately, at one request per job, or making it up.

If body text is the requirement, Greenhouse, Workable and Ashby do publish it — the
[Career Site Job Feed](https://apify.com/starbright_overlap/ats-job-feed) covers those in this same
output schema.

### Who hires on Breezy

Breezy is a small-and-mid-market product. The employers here are agencies, regional operators,
startups and specialist firms rather than the Fortune 500 — the sort of roles that never reach a
large aggregator because nobody is paying to syndicate them.

That is the point of scraping it directly: for a niche job board or a sourcing list, Breezy is
coverage your competitors do not have.

### Input

| Option | What it does |
|---|---|
| `keywords` | Keep only titles containing one of these. Case-insensitive. |
| `excludeKeywords` | Drop titles containing any of these, e.g. `senior`, `intern`. |
| `locations` | Keep only locations containing one of these. |
| `remoteOnly` | Keep only postings Breezy flags remote. |
| `postedWithinDays` | Freshness filter, 90 days by default. |
| `companies` | Subdomains or board URLs. Leave empty to search all 2,800. |
| `maxBoards` | How many boards to scan, largest-first. |
| `maxJobs` | Hard cap on rows, so a run costs what you expect. |

### Finding a company slug

The board lives at `<slug>.breezy.hr`, so the slug is the subdomain. Paste the whole URL if you
prefer — the Actor pulls the subdomain out. Companies that embed Breezy into their own careers page
still load it from that host, so it is in the page source.

Or run without `companies` and read the `companySlug` column.

### Recipes

**Cover the long tail.** Large aggregators skew towards employers who pay to be listed. A Breezy
sweep returns roles from smaller companies that are genuinely hiring and genuinely unindexed.

**Benchmark pay across the long tail.** Roughly half of Breezy postings carry a pay range, and these
are employers no salary survey covers. One run gives you a table of role, location and range.

**Watch one company.** One slug, run on a schedule, diff `jobId` between runs. New ids are
openings; missing ids are roles that closed.

### Use it as an API

Most people who rely on this Actor never open the Apify console after the first run — they call it
from their own code and read the rows straight back. One request in, job rows out, no polling and no
dataset id to chase:

```bash
curl -X POST "https://api.apify.com/v2/acts/starbright_overlap~breezy-hr-jobs-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["sales"], "remoteOnly": true, "maxJobs": 200}'
```

```python
import requests

rows = requests.post(
    "https://api.apify.com/v2/acts/starbright_overlap~breezy-hr-jobs-scraper/run-sync-get-dataset-items",
    params={"token": "YOUR_TOKEN"},
    json={"keywords": ["sales"], "remoteOnly": True, "maxJobs": 200},
    timeout=300,
).json()

for r in rows:
    print(r["company"], "—", r["title"], "—", r["applyUrl"])
```

```javascript
const rows = await (await fetch(
  'https://api.apify.com/v2/acts/starbright_overlap~breezy-hr-jobs-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN',
  { method: 'POST', headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({"keywords": ["sales"], "remoteOnly": true, "maxJobs": 200}) },
)).json();
```

Your token is at **Settings → Integrations** in the Apify console. Keep `maxJobs` set to what you
actually need — it is the cap that decides what the call costs.

#### Running it on a schedule instead

If you want the rows to arrive without asking, add a **Schedule** from the Actor page (Actions →
Schedule) and point a webhook at your endpoint. A daily schedule plus the `postedWithinDays` filter
is the usual setup for a job board or an alerting pipeline.

### Pricing

Pay per result — you are charged per job row delivered. A board that fails or returns nothing costs
you nothing. Platform usage is included rather than billed on top, so the per-result price is the
whole price.

### Beyond Breezy

Companies move between applicant tracking systems, and most job-data projects need more than one:

- **[Career Site Job Feed](https://apify.com/starbright_overlap/ats-job-feed)** — the same engine
  across Workday, Greenhouse, SmartRecruiters, Workable, Lever, Ashby and Breezy: 27,000+ employer
  boards in one run, identical output schema.
- **[New Job Alerts](https://apify.com/starbright_overlap/new-jobs-feed)** — the same coverage, but
  each run returns only what appeared since the previous run, so you are not diffing datasets
  yourself.

Rows from all of them share one schema, so you can union the datasets without a mapping layer.

### Notes

- **A dead slug never aborts the run.** Failures are collected into a `FAILED_BOARDS` record in the
  key-value store, with the reason for each.
- **`companySlug:jobId` is a stable key.** It does not change while a posting is open, which makes
  it safe for detecting what opened and closed between runs.
- **No login, no proxies, no API key.** Breezy publishes this endpoint openly. Private boards are
  invisible to every scraper, including this one.

# Actor input Schema

## `keywords` (type: `array`):

Keep only jobs whose title contains at least one of these. Case-insensitive. Leave empty for every job.

## `excludeKeywords` (type: `array`):

Drop jobs whose title contains any of these, e.g. `senior`, `intern`.

## `locations` (type: `array`):

Keep only jobs whose location contains one of these, e.g. `london`, `new york`, `germany`.

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

Keep only postings flagged remote by the ATS or with a remote-looking location.

## `postedWithinDays` (type: `integer`):

Freshness filter. Defaults to 90 days because some employers leave postings open for years — measured across the registry, 15% of Greenhouse and about half of the largest SmartRecruiters boards are over a year old. Set a large number such as 3650 to include everything. Postings with no publication date (most Workday rows) are always kept.

## `companies` (type: `array`):

Board slugs, e.g. `american-logistics-authority`. Leave empty to search all 2,800 known breezy employers.

## `maxBoards` (type: `integer`):

Boards are scanned largest-first, so a capped run still returns the most jobs. Raise it to sweep all 2,800 boards.

## `maxJobs` (type: `integer`):

Hard cap on results, so a run costs what you expect. Defaults to 500 — enough to evaluate the feed on free-tier credits. Clearing the box falls back to that, so type a large number such as 500000 to sweep everything.

## `concurrency` (type: `integer`):

Higher is faster but more likely to hit ATS rate limits.

## `maxJobsPerCompany` (type: `integer`):

Keeps one huge employer from filling the whole run. Boards are scanned largest-first, so without this the first few boards use up the entire result budget. Raise it when you want depth on a few employers rather than breadth across many.

## Actor input object example

```json
{
  "keywords": [
    "engineer"
  ],
  "remoteOnly": false,
  "postedWithinDays": 90,
  "maxBoards": 200,
  "maxJobs": 500,
  "concurrency": 8,
  "maxJobsPerCompany": 25
}
```

# Actor output Schema

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

Every posting matching your filters, normalized across all six ATS platforms.

## `failedBoards` (type: `string`):

Written only when a board was unreachable or rate-limited. The run itself is unaffected.

# 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 = {
    "keywords": [
        "engineer"
    ],
    "postedWithinDays": 90,
    "maxJobs": 500,
    "maxJobsPerCompany": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("starbright_overlap/breezy-hr-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 = {
    "keywords": ["engineer"],
    "postedWithinDays": 90,
    "maxJobs": 500,
    "maxJobsPerCompany": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("starbright_overlap/breezy-hr-jobs-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 '{
  "keywords": [
    "engineer"
  ],
  "postedWithinDays": 90,
  "maxJobs": 500,
  "maxJobsPerCompany": 25
}' |
apify call starbright_overlap/breezy-hr-jobs-scraper --silent --output-dataset

```

## MCP server setup

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