canonical: https://jentic.com/apis/hirelayer.co/hirelayer

# HireLayer API

The HireLayer API turns recruiting text into structured data: it parses resumes, extracts hiring criteria from job descriptions, scores and ranks candidates against a role, and resolves free-text skills to a shared taxonomy. Each call is synchronous and returns JSON, and five recruiting functions sit behind one API key. Use it to automate resume intake and candidate shortlisting without building separate parsing and matching services.

## For AI agents

Parse resumes, extract job criteria, score and rank candidates against a role, and resolve skills to a taxonomy, all behind one API key.

## Scope

Does not store candidates, schedule interviews, or post jobs to boards. Use for resume parsing, candidate matching, and skills resolution only.

## Capabilities

- Parse a resume into structured candidate fields from raw text or a file
- Extract structured hiring criteria from a job description
- Score how well a single candidate matches a given job
- Rank a pool of candidates against one job opening
- Resolve free-text skills to a normalized skills taxonomy
- Browse the supported skills taxonomy to align tags across systems

## Use cases

### Resume Intake and Structuring

Convert incoming resumes into structured candidate records so an applicant tracking workflow can index skills, experience, and contact details automatically. The parser accepts raw text or a file and returns normalized fields synchronously, which removes the brittle regex parsing many teams maintain. Recruiting tools use this as the first step in an intake pipeline before matching or storage.

Example prompt: POST `/api/v3/parser` with the resume content and store the structured candidate fields the response returns.

### Job-to-Candidate Matching

Rank a pool of candidates against a single role so recruiters see the strongest fits first. The API extracts structured criteria from the job description, then ranks candidates against it in one synchronous call per request. Hiring teams use this to shortlist applicants without hand-scoring every resume.

Example prompt: Call POST `/api/v1/jobs/extract-criteria` on the job description, then POST `/api/v1/matching/job-candidates/rank` with the candidate pool and return the ranked list.

### Skills Normalization

Map free-text skills from resumes and job posts onto one consistent taxonomy so filtering and reporting stay comparable across sources. The API resolves raw skill strings to taxonomy entries and exposes the full taxonomy for reference. Data teams use this to deduplicate skill tags before loading candidate records into a search index.

Example prompt: POST `/api/v1/skills/resolve` with the raw skill strings and reconcile each result against the taxonomy returned by GET `/api/v1/skills.`

### Agent-Driven Shortlisting

An AI agent builds a shortlist for an open role by parsing each applicant's resume and scoring it against the job, without a bespoke integration. Through Jentic the agent discovers the parsing and matching operations, loads their schemas, and chains the calls. This lets a recruiting assistant return a ranked shortlist directly from uploaded resumes.

Example prompt: Search Jentic for 'rank candidates for a job', parse each resume with POST `/api/v3/parser`, then POST `/api/v1/matching/job-candidate` to score and shortlist the strongest fits.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/api/v3/parser` | Parse a resume into structured fields |
| POST | `/api/v1/jobs/extract-criteria` | Extract hiring criteria from a job description |
| POST | `/api/v1/matching/job-candidate` | Score a candidate against a job |
| POST | `/api/v1/matching/job-candidates/rank` | Rank candidates for a job |
| POST | `/api/v1/skills/resolve` | Resolve free-text skills to the taxonomy |
| GET | `/api/v1/skills` | List the skills taxonomy |
| GET | `/api/v1/me` | Check an API key |

## Key resources

- **Parser** — Parse a resume into structured candidate fields
- **Job Criteria** — Extract structured hiring criteria from a job description
- **Matching** — Score one candidate against a job and rank a pool of candidates for a role
- **Skills** — Resolve free-text skills to the taxonomy and list the full skills taxonomy

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 70 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 81 / 100
  - Developer Experience & Jentic Compatibility: 72 / 100
  - AI-Readiness & Agent Experience: 61 / 100
  - Agent Usability: 94 / 100
  - Security: 50 / 100
  - AI Discoverability: 78 / 100
- **View full report:** https://jentic.com/apis/hirelayer.co/hirelayer/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring HireLayer by hand means attaching the X-API-Key header on every call and chaining the parse, extract-criteria, and ranking steps yourself. Through Jentic you install once, import HireLayer from the API Directory, store the key once, and your agent calls the recruiting operations in sequence.
- **Permission scoping:** HireLayer sends resumes, jobs, and candidate pools inside the request body, so a rule bounds which operations your agent may call rather than which record. You can grant only the parser and matching operations and leave skills management out of the agent's reach.
- **Credential handling:** Your HireLayer 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 'parse a resume' or 'rank candidates for a job', and Jentic returns the matching HireLayer operation with its input schema so the agent calls the right endpoint without reading the reference docs.

## Related APIs

- **HrFlow.ai API** — Resume parsing and candidate-job matching with its own taxonomy
- **Lever API** — Applicant tracking system to store parsed candidates
- **Ashby API** — ATS and recruiting workflow that consumes ranked candidates

## FAQ

### Is there a HireLayer MCP server?

You do not need an MCP server to give your agent the HireLayer API. Jentic connects it directly from the API Directory: import HireLayer, store your API key once, and your agent calls the parsing and matching endpoints. Operations are discovered on demand, so no extra server's tool definitions load into the agent's context.

### What authentication does the HireLayer API use?

The HireLayer API authenticates with an API key sent in the X-API-Key header, per its OpenAPI spec, and GET `/api/v1/me` lets you confirm a key is valid. Through Jentic the key is stored encrypted by your own Jentic One instance and injected at call time, so it never reaches the agent's prompt or logs.

### Can I rank candidates against a job with the HireLayer API?

Yes. POST `/api/v1/matching/job-candidate` scores a single candidate against a job, and POST `/api/v1/matching/job-candidates/rank` ranks a whole pool, both synchronously. You can first call POST `/api/v1/jobs/extract-criteria` to derive structured criteria from the job description.

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

The HireLayer spec describes pricing in terms of credits, where a successful call costs one credit, rather than a fixed requests-per-minute ceiling. The spec does not publish a numeric rate limit, so check the HireLayer documentation at https://hirelayer.co/api-docs for current limits.

### How do I parse a resume through Jentic?

Search Jentic with the query 'parse a resume', load the schema for POST `/api/v3/parser`, and execute it with the resume text or file to get structured fields back. 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 HireLayer API?

Yes. HireLayer carries the resume, job, and candidate pool inside the request body, so a rule bounds which operations your agent may call rather than which record it touches. Allow only the operations the task needs, such as the parser and the matching endpoints, and every call the agent makes is logged.