# BambooHR Jobs Scraper - ATS Job Listings (`benthepythondev/bamboohr-jobs-scraper`) Actor

Scrape BambooHR career boards by company subdomain. Get job title, company, department, location, employment type, posted date and job URL.

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

## Pricing

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

## BambooHR Jobs Scraper - ATS Job Listings

Scrape public BambooHR career boards and export job listings as structured data. Enter BambooHR company subdomains such as `g2`, and the actor returns job title, company, department, employment type, location, posted date, description, direct job URL and source API URL.

### What is the BambooHR Jobs Scraper?

BambooHR is an HR and applicant tracking platform used by many small and mid-market companies. Each company can expose a public careers board on a subdomain such as `company.bamboohr.com`. This actor reads those public job boards through BambooHR's lightweight JSON endpoints and turns the results into an Apify dataset.

The actor is designed for reliability. It does not use a browser, login, paid proxy or scraping workaround for the normal public BambooHR career API. That makes it cheap to run, fast to schedule and safe for daily Apify auto-tests.

### Common use cases

Use this actor to monitor hiring activity at target companies, build job datasets, enrich company intelligence, find recruiting leads, track department growth, watch competitor job postings, collect roles for a niche job board, or feed open positions into a CRM.

Sales teams can watch accounts for expansion signals. Recruiters can monitor companies that use BambooHR. Market researchers can collect hiring trends from a curated list of companies. Job board operators can aggregate openings from BambooHR-powered career pages.

### Input

Provide BambooHR company subdomains or BambooHR career URLs.

```json
{
  "companies": [
    "g2",
    "https://g2.bamboohr.com/careers/list"
  ],
  "maxResults": 50
}
````

### Output

Each dataset item represents one job.

```json
{
  "id": "148",
  "title": "Senior Software Engineer",
  "company": "G2",
  "company_subdomain": "g2",
  "department": "Engineering",
  "employment_type": "Full Time",
  "location": "Chicago, IL, United States",
  "city": "Chicago",
  "state": "IL",
  "country": "United States",
  "remote": false,
  "posted_at": "2026-07-01",
  "description": "Clean text job description.",
  "url": "https://g2.bamboohr.com/careers/148",
  "source": "bamboohr",
  "source_url": "https://g2.bamboohr.com/careers/list"
}
```

### Output fields

- `id` - BambooHR job id.
- `title` - job title.
- `company` and `company_subdomain` - company name and BambooHR tenant.
- `department` - department label when provided.
- `employment_type` - full-time, part-time, contract or other label from BambooHR.
- `location`, `city`, `state`, `country` - location fields.
- `remote` - true when the location text indicates remote work.
- `posted_at` - open or created date when available.
- `description` - cleaned plain-text description.
- `url` - direct BambooHR job page.
- `source_url` - API endpoint used.

### Why use this actor?

Hiring data is commercially valuable. It can reveal growth, budget, technology adoption and market movement before those signals appear in formal reports. BambooHR boards are especially useful for smaller companies that may not post every job to large aggregators. This actor makes those postings easy to collect and schedule.

### Example workflows

Run the actor daily against a list of account companies and alert when new roles appear. Track department counts over time to spot hiring pushes. Export jobs to a database and classify titles by function. Send job URLs into an enrichment pipeline that extracts seniority, skills or compensation signals from descriptions.

For sales intelligence, connect the dataset to a CRM and create an activity when a target account starts hiring in a relevant department. For recruiting, monitor companies in your niche and contact candidates or hiring managers when new roles appear. For market research, group jobs by department and country to see where companies are investing.

For content and SEO teams, the actor can power job-market reports. Run it against a curated list of companies, aggregate job titles by function, and publish hiring trend summaries. For investors and analysts, public hiring pages can be an early indicator of expansion, contraction or strategic focus.

### Integration ideas

Use Apify schedules to run this actor daily or weekly. Send results to Make, Zapier, n8n, Airtable, Google Sheets, BigQuery or your own API. Compare each run with the previous dataset by `id` and `company_subdomain` to detect new or removed jobs. Trigger notifications only when new jobs appear so alerts stay useful.

You can also combine this actor with other ATS scrapers. BambooHR covers one slice of the hiring ecosystem; Greenhouse, Lever, Workday, Ashby and SmartRecruiters cover others. A portfolio of ATS actors gives broader hiring intelligence while keeping each actor simple and reliable.

### Best practices

Use known BambooHR subdomains. Not every company uses BambooHR, and some old subdomains redirect to BambooHR's marketing site or have zero open roles. Keep a curated company list and remove tenants that repeatedly return no jobs. Use `maxResults` to keep scheduled runs small and reliable.

Start with a small list and verify output quality before scaling. Some tenants expose rich descriptions and department labels, while others expose only minimal fields. Use the `source_url` field when debugging because BambooHR has both a newer careers list endpoint and an older embed endpoint. If a tenant returns zero jobs, confirm in a browser whether the company still uses BambooHR or has migrated to another ATS.

### Data quality notes

Location fields come directly from BambooHR's public job object. If a company enters custom or partial location data, the actor preserves what is available. The `remote` field is a practical text signal based on the location string, not a formal BambooHR remote-work guarantee. Descriptions are stripped to plain text so they can be searched, exported and classified more easily.

### Notes and limits

The actor reads public BambooHR career endpoints. It does not access private HR data, applicant data or authenticated BambooHR accounts. Some BambooHR tenants may disable public listings, redirect to another ATS, or return zero jobs. The actor returns only jobs exposed by the public careers board.

Because BambooHR tenants are company-specific, discovery matters. This actor is strongest when you already have target company subdomains or career URLs. It is not a web-wide company discovery crawler. That design keeps it fast, predictable and suitable for scheduled monitoring.

### FAQ

Does it require a BambooHR login?

No. It reads public career board data only.

Can I scrape multiple companies?

Yes. Add multiple subdomains in the `companies` input.

Does it use a browser?

No. It uses direct JSON endpoints, which keeps runs fast and inexpensive.

Can I schedule it?

Yes. Schedule it in Apify and compare runs to detect newly posted jobs.

### You might also like

- Greenhouse Jobs Scraper - scrape Greenhouse boards.
- Lever Jobs Scraper - scrape Lever jobs.
- ATS Jobs Aggregator - collect multiple ATS sources.

### Keywords

BambooHR jobs scraper, BambooHR careers API, ATS scraper, job listings scraper, hiring signal data, recruiting leads, job board data, Apify jobs scraper, BambooHR job export.

# Actor input Schema

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

BambooHR subdomains or BambooHR career URLs. Example: g2 for https://g2.bamboohr.com/careers/list.

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

Maximum number of jobs to return across all companies.

## Actor input object example

```json
{
  "companies": [
    "g2"
  ],
  "maxResults": 10
}
```

# 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 = {
    "companies": [
        "g2"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/bamboohr-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 = {
    "companies": ["g2"],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/bamboohr-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 '{
  "companies": [
    "g2"
  ],
  "maxResults": 10
}' |
apify call benthepythondev/bamboohr-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BambooHR Jobs Scraper - ATS Job Listings",
        "description": "Scrape BambooHR career boards by company subdomain. Get job title, company, department, location, employment type, posted date and job URL.",
        "version": "1.0",
        "x-build-id": "3dEvGHePg5aaKuVjx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~bamboohr-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-bamboohr-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~bamboohr-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-bamboohr-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~bamboohr-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-bamboohr-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": {
                    "companies": {
                        "title": "BambooHR company subdomains",
                        "type": "array",
                        "description": "BambooHR subdomains or BambooHR career URLs. Example: g2 for https://g2.bamboohr.com/careers/list.",
                        "default": [
                            "g2"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of jobs to return across all companies.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```