Skip to content

For applicant tracking systems

Turn every application CV into a structured ATS record

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.

An ATS application screen. The applicant's CV has been parsed into a candidate record with title, location, experience level, languages and skills. A fit panel lists three job criteria with their statuses and a weighted score of 0.87.

Where application intake breaks down

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.

  1. 01

    Applicants retype what their CV already says

    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.

  2. 02

    Parsing is expected, and costly to own

    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.

  3. 03

    Wrong files turn into empty records

    ID scans, job ads and blank exports land in the CV slot. Without a check, they create candidate records that nobody can search.

  4. 04

    A score without reasons is hard to defend

    Recruiters on your platform get asked why a candidate ranks first. A single opaque number does not survive that conversation with a hiring manager.

Where HireLayer sits in your application pipeline

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.

  1. Your system

    Step 1, your system: An applicant submits a CV

    Your upload service receives the file with the application, from your career page or a job board integration.

  2. HireLayer

    Step 2, HireLayer API: Parse the document

    Send the file with application_id set to your application id. The parsed resume comes back in the same response, under resume.

    POST /api/v4/resumes/parse

    • resume.info_candidate
    • resume.work_experiences[]
    • resume.educations[]
    • resume.languages[]
    • resume.skills[]
  3. Your system

    Step 3, your system: Prefill and store

    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.

  4. HireLayer

    Step 4, HireLayer API: Extract job criteria once per job

    When a recruiter publishes a job, send its description with your job id. HireLayer stores it with weighted criteria recruiters can adjust before scoring.

    POST /api/v4/jobs/extract-criteria

    • job_id
    • criteria[]
  5. HireLayer

    Step 5, HireLayer API: Explain fit for each application

    Send the application id with the job id. Save score, verdict, summary and criteria with the application.

    POST /api/v4/resumes/score

    • scores[].score
    • scores[].criteria[]
  6. Your system

    Step 6, your system: The recruiter decides

    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
Wink logo

Wink runs all six HireLayer APIs inside its ATS

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 · Wink
companies recruit with Wink
500+
job boards Wink publishes to
70+
saved per application by CV parsing
2 min+

Figures published by Wink on wink-lab.com.

Illustration: a CV file is sent to HireLayer Resume Parser. The response fills a candidate profile in Wink: photo from info_resume.face_url, contact details from info_candidate, experience from work_experiences, education from educations and skills from skills. Below, HireLayer Resume Scorer gives the candidate a fit of 0.87 for a Senior Full Stack Developer job, with one criterion met and one partial, and ranks them first of 10 applicants.

From parser JSON to your candidate schema

Every field below is part of the parsed resume, returned under resume. Map them once, and each new application arrives with its record already filled in.

Mapping between HireLayer parser response fields and typical ATS candidate fields
info_candidate.full_name · email · phone_numberContact detailsfirst_name and last_name are also returned separately.
info_candidate.job_titleCurrent titleThe title the candidate presents, as written.
info_candidate.experience_levelSeniority filterOne of five brackets, from “0 to 1 year” to “More than 10 years”.
work_experiences[]Employment historyISO dates, contract_type, currently_active and experience_duration in months.
educations[].degree_typeEducation levelEQF levels such as “Level 7”, with school and dates.
languages[].levelLanguage proficiencyNormalized to CEFR levels A1 to C2.
skills[]Skill tagsTyped as hard, soft or software skill, with a raw or normalized status.
info_candidate.locationLocation filtersCity, region, ISO country code and coordinates.
info_resume.textFull-text indexResume Scorer reads it from the stored resume, by application_id.
An application form showing an upload error: the file is an ID scan, and the applicant is asked to upload a CV. The API returned HTTP 422 with the error code resume_unreadable.

Guard the CV slot

A file that is not a CV, cannot be read or holds no text comes back as HTTP 422 with the code resume_unreadable, unbilled, so your form can ask for another file instead of saving an empty record.

An upload handler, end to end

A TypeScript sketch of the call your upload service makes. It handles documents that are not CVs, then stores the fields on the application.

application_id
Your own reference, sent with the file: the resume is stored under it.
422 · error.code
resume_unreadable, with a readable message you can turn into an upload message.
resume.info_resume.text
The CV text for your search index. Resume Scorer reads the stored resume by application_id.
Request · TypeScript/api/v4/resumes/parse
// 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://hirelayer.co/api/v4/resumes/parse', {
  method: 'POST',
  headers: { 'X-API-Key': process.env.HIRELAYER_API_KEY! },
  body: form,
})

if (res.status === 422) {
  // resume_unreadable: not a CV, unreadable or without text. Not billed.
  const { error } = await res.json()
  return askApplicantForAnotherFile(error.message)
}

const { resume: 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,
})

The HireLayer APIs behind this workflow

Start with the core APIs, add the others when a feature needs them. All six products share one API key and one credit balance.

What your customers get

  • A shorter application

    Applicants confirm prefilled fields instead of typing their history a second time.

  • Searchable records from the first minute

    Each CV becomes filterable fields and indexed text. Older applications can be backfilled by sending their stored files through the same call.

  • Fit a recruiter can challenge

    Each criterion carries a status and a sentence of evidence from the CV, so the recruiter can check the result.

  • One integration, six products

    The same API key and credit balance cover parsing, job criteria, scoring and ranking, the two searches and skills.

ATS platforms: frequently asked questions

What does a resume parser integration in an ATS involve?

One multipart POST from your upload service, then a mapping from the JSON to your candidate model. The parse answers synchronously, so a first version needs no queue or callback. A webhook_url can be added if you prefer signed callbacks.

Can the parser keep our application reference?

Yes. Send your reference as application_id with the file. It comes back as application_id in the answer, and the resume is stored under it, so the response can be written to the right application.

How should our application form react to a file that is not a CV?

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 resume_unreadable comes with a readable message, and the file is not billed.

Can retention differ between the employers using our ATS?

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.

Can recruiters in our ATS see why an applicant got their score?

Yes. Resume Scorer explains every criterion and gives it a status, met, partial, missing or unknown, with the evidence found in the CV, and the score is a weighted average of the criterion scores. Your candidate screen can show that breakdown next to the score instead of a bare number.

Map a real CV to your schema

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 six products.