For applicant tracking systems
Call HireLayer from your upload service and get the CV back as candidate, experience, education, language and skill fields mapped to your schema. Then add a criterion-by-criterion fit view for each job, so recruiters see why a candidate is on top.
The problem
Your customers judge the ATS on the first minutes of an application: how long it takes to apply, and how usable the record is when a recruiter opens it.
A form that asks for work history after the CV upload adds a step to every application. Your customers see it in their funnel, then raise it at renewal.
Applicants send PDFs, Word files, slides and phone photos. Keeping an in-house parser reliable across formats and languages becomes a product of its own.
Cover letters, ID scans and blank exports land in the CV slot. Without a check, they create candidate records that nobody can search.
Recruiters on your platform get asked why a candidate ranks first. A single opaque number does not survive that conversation with a hiring manager.
How it fits
Your ATS stays the system of record. Calls happen server-side, at two moments your product already has: when a CV is uploaded, and when a recruiter reviews applications for a job.
Your upload service receives the file with the application, from your career page or a job board integration.
Send the file with application_id set to your application id. V3 returns the JSON in the same response.
POST /
Map the fields to your candidate model and index info_resume.text for full-text search. Show the applicant a review step if your flow has one.
When a recruiter publishes a job, turn its description into weighted criteria they can adjust before matching.
POST /
Send the CV text with the stored criteria. Save score, summary and evaluated_criteria with the application.
POST /
Your interface shows the statuses next to the CV. Knockout rules on mandatory criteria remain your product’s logic.
Want to see the full response for a real CV before writing any code?
Open the parser demo
Customer story
Wink is an applicant tracking system used by more than 500 companies. Imported CVs arrive as filled candidate profiles, and every job gets its candidates matched and ranked.
Jules DesclousCo-founder | Product · WinkFigures published by Wink on wink-lab.com.
Field mapping
Every field below is part of the V3 response. Map them once, and each new application arrives with its record already filled in.
| Response field | Your ATS field | What you get |
|---|---|---|
| info_candidate.full_name · email · phone_number | Contact details | first_name and last_name are also returned separately. |
| info_candidate.job_title | Current title | The title the candidate presents, as written. |
| info_candidate.experience_level | Seniority filter | One of five brackets, from “0 to 1 year” to “More than 10 years”. |
| work_experiences[] | Employment history | ISO dates, contract_type, currently_active and experience_duration in months. |
| educations[].degree_type | Education level | EQF levels such as “Level 7”, with school and dates. |
| languages[].level | Language proficiency | Normalized to CEFR levels A1 to C2. |
| skills[] | Skill tags | Typed as hard, soft or software skill, with a raw or normalized status. |
| info_candidate.location | Location filters | City, region, ISO country code and coordinates. |
| info_resume.text | Full-text index | Also the candidate_text input for Match and Rank. |
Guard the CV slot
DOCUMENT_NOT_A_RESUME, DOCUMENT_UNREADABLE and DOCUMENT_TEXT_EMPTY come back as HTTP 422, so your form can ask for another file instead of saving an empty record.
Technical example
A TypeScript sketch of the call your upload service makes. It handles documents that are not CVs, then stores the fields on the application.
// Runs in your upload service, never in the browser
const form = new FormData()
form.append('file', new Blob([cvBuffer]), fileName)
form.append('application_id', application.id)
const res = await fetch('https://onlineresumeparser.com/api/v3/parser', {
method: 'POST',
headers: { 'X-API-Key': process.env.HIRELAYER_API_KEY! },
body: form,
})
if (res.status === 422) {
// DOCUMENT_NOT_A_RESUME, DOCUMENT_UNREADABLE, DOCUMENT_TEXT_EMPTY…
const { code } = await res.json()
return askApplicantForAnotherFile(code)
}
const cv = await res.json()
await candidates.update(application.id, {
fullName: cv.info_candidate.full_name,
email: cv.info_candidate.email,
currentTitle: cv.info_candidate.job_title,
seniority: cv.info_candidate.experience_level,
history: cv.work_experiences,
languages: cv.languages,
resumeText: cv.info_resume.text,
})APIs used
Start with the core APIs, add the others when a feature needs them. All five share one API key and one credit balance.
Resume Parsing API
Fills the candidate record on upload and rejects files that are not CVs.
Job Parsing API
Turns each job description into weighted criteria recruiters can edit.
Candidate & Job Matching API
Adds a fit panel to each application, with evidence per criterion.
Candidate Ranking API
Orders up to 10 applicants for one job when a recruiter reviews a stage.
Skills Matching API
Maps raw skill labels to catalog terms, so filters stay consistent.
Outcomes
Applicants confirm prefilled fields instead of typing their history a second time.
Each CV becomes filterable fields and indexed text. Older applications can be backfilled by sending their stored files through the same call.
Each criterion carries a status and a sentence of evidence from the CV, so the result can be checked, not just trusted.
The same API key and credit balance cover parsing, job criteria, matching, ranking and skills.
FAQ
One multipart POST from your upload service, then a mapping from the JSON to your candidate model. V3 answers synchronously, so a first version needs no queue or callback. A webhook_url can be added if you prefer callbacks.
Yes. Send your reference as application_id with the file. It comes back in info_resume.application_id, so the response can be written to the right application.
Treat an HTTP 422 response as a prompt for the applicant: ask for a CV and keep the application open rather than creating a candidate with empty fields. The error code tells your form whether the file was not a CV, unreadable or without text.
Yes. The do_not_store_data flag is set per request, so your intake service can turn it on for employers whose policies require it and leave the default, false, for the others.
Yes. Match explains every criterion and gives it a status, and the total is a weighted average of those statuses, from 1 for ideal down to 0 for not_valid. Your candidate screen can show that breakdown next to the score instead of a bare number.
Create an account to get an API key and send your first application CV. The free plan includes 50 credits a month, shared by all five APIs.
