canonical: https://jentic.com/apis/jazzhr.com/jazzhr

# JazzHR API

The JazzHR API manages an applicant tracking workflow for small and mid-sized recruiting teams, exposing applicants, jobs, hires, recruiter activities, and questionnaire answers over a REST interface. It lets you find and create candidates, attach them to open jobs, log notes and activities against a record, and pull the list of who was hired for reporting. Requests carry an API key and return structured JSON that an integration can act on directly.

## For AI agents

Find and create job applicants, attach candidates to open jobs, post jobs, and read the list of hires in JazzHR. Covers 31 endpoints across applicants, jobs, activities, and questionnaires.

## Scope

Does not handle payroll, benefits administration, or employee performance reviews. Use for applicant tracking and recruiting only.

## Capabilities

- Find applicants and filter candidates by job, category, or recruiter
- Create new applicants and map them to an open job with the applicants2jobs endpoint
- Post jobs and read their status through the hiring pipeline
- Read the list of candidates who were hired for reporting
- Log recruiter notes and activities against a candidate record
- Collect questionnaire answers and read questionnaire questions for a job

## Use cases

### AI Recruiting Assistant via Jentic

An AI recruiting assistant reads open jobs, screens incoming applicants, and files notes without a developer wiring the JazzHR API by hand. Through Jentic the agent searches for the operation it needs by intent, receives the matching JazzHR endpoint and its input schema, and calls it with the API key injected at execution time. This lets a recruiter delegate candidate triage to an agent that works directly against live JazzHR data.

Example prompt: Search Jentic for 'find applicants by job', load the operation schema, call GET /applicants for the target job, and file a note on each new candidate

### Candidate Intake Automation

Recruiting teams that collect candidates from job boards and referral forms can push each new applicant straight into JazzHR and attach them to the right requisition. The API creates the applicant, maps them to an open job, and records the source, so no candidate is manually re-keyed. This keeps the pipeline current the moment an application arrives.

Example prompt: Call POST /applicants to create the candidate, then POST /applicants2jobs to attach them to the target job

### Hiring Pipeline Reporting

Talent operations teams need current numbers on jobs opened, applicants received, and hires made. The JazzHR API reads jobs, applicants, activities, and the dedicated hires list so a scheduled agent can assemble a weekly hiring report. Because the data comes straight from the ATS, the report reflects the live pipeline rather than a stale export.

Example prompt: Call GET /hires and GET /jobs, then summarize hires per job for the last 30 days

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/applicants` | Find applicants by parameters |
| POST | `/applicants` | Create an applicant |
| POST | `/applicants2jobs` | Map an applicant to a job |
| GET | `/jobs` | Find jobs by parameters |
| POST | `/jobs` | Create a job |
| GET | `/hires` | Find candidates who were hired |
| POST | `/notes` | Post a note against a record |
| GET | `/activities` | Find activities by parameters |

## Key resources

- **Applicants** — Find and create candidates, and map them to jobs
- **Jobs** — Find jobs and create new job openings
- **Hires** — Read the list of candidates who were hired
- **Activities** — Read recruiter activities against candidates and jobs
- **Questionnaires** — Read questionnaire questions and collect applicant answers

## Why Jentic

- **Setup:** Wiring the JazzHR API by hand means appending your apikey to every query string and threading applicant, job, and mapping ids through the right endpoints yourself. Through Jentic you install once, import JazzHR from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** JazzHR puts the record id in the URL path (`/applicants/{applicant_id}`, `/jobs/{job_id}`), so a rule can pin your agent to applicant and job lookups. You choose the operations it may call, so write operations like creating an applicant or posting a job are not included unless you add them.
- **Credential handling:** Your JazzHR API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'find applicants for a job' or 'list recent hires', and Jentic returns the matching JazzHR operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Greenhouse** — Applicant tracking and structured hiring for larger recruiting teams
- **Lever** — Applicant tracking plus candidate relationship management
- **BambooHR** — HR system of record for employee data once a candidate is hired

## FAQ

### What authentication does the JazzHR API use?

The JazzHR API authenticates with an API key passed as the apikey query parameter, as declared in its OpenAPI spec. Through Jentic the key is stored encrypted by your own Jentic One instance and injected at execution time, so it never enters the agent's prompt, logs, or context.

### Can I create applicants and attach them to jobs with the JazzHR API?

Yes. Call POST /applicants to create the candidate, then POST /applicants2jobs to map that applicant to a specific job. Both return JSON your agent can parse, so an intake flow can add a candidate and route them to the right requisition in one sequence.

### What are the rate limits for the JazzHR API?

The OpenAPI spec does not specify rate limits. Check the JazzHR API documentation at https://www.jazzhr.com/ for current limits before running high-volume candidate syncs.

### How do I read new hires with the JazzHR API through Jentic?

Search Jentic for 'list hires', which resolves to the GET /hires operation, and Jentic returns its input schema so your agent can filter and summarize hired candidates. Credentials are injected at call time from your own instance. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Can I limit what my agent is allowed to do with the JazzHR API?

Yes. Write a rule that allows only the read operations your agent needs, such as GET /applicants and GET /jobs, so it can screen and report but cannot create records, and every call it makes is logged by your own instance. If you later want it to file candidates, you add POST /applicants to the allowed set deliberately.

### Is there a JazzHR MCP server?

You don't need an MCP server to give your agent JazzHR. Jentic connects it directly from the API Directory: import JazzHR, store your key once, and your agent calls the applicant, job, and hire operations on demand without loading another server's tool definitions into its context.
