HireLayer Resume Parser · Resume Parsing API
Resume Parsing API that turns any CV into structured JSON
Send a resume file in one multipart request. HireLayer Resume Parser returns candidate details, work history, education, languages and skills as normalized JSON in the same response, ready to store in your ATS or product, and keeps the resume under an application_id to score or search later.
- Endpoint
- POST /api/v4/resumes/parse
- Input
- CV file · 15 formats
- Response
- Synchronous JSON
- Billing
- 1 credit per resume
- API requests processed
- 2M+
- In production since
- 2024
- Parse success rate
- ~99.7%
What the Resume Parsing API extracts
Problems it solves
Every CV uses a different layout
Columns, tables, scans and office formats put the same information in different places. Manual entry does not scale with application volume.
Free text cannot be filtered
“Since 2019”, “C1 English” or “5 yrs” mean little to a database. Search, filters and reporting need normalized values.
Wrong uploads pollute records
IDs, job ads or blank scans uploaded in the CV slot end up as empty or misleading candidate profiles.
01
15 file formats, one endpoint
PDF, DOC, DOCX, ODT, PPT, PPTX, ODP, XLS, RTF, TXT, HTML, Markdown, JPG/JPEG, PNG and BMP go through the same multipart request.
02
Normalized values
Experience brackets, EQF education levels, CEFR language levels, canonical contract types and ISO country codes.
03
Location and mobility
City, postal code, region and coordinates, plus the other cities a candidate says they can work in.
04
Typed skills
Each skill is classified as a hard, soft or software skill, with a domain, a subcategory and a raw or normalized status.
05
Occupation codes
rome_jobs maps the profile to ROME occupation codes with a prediction score, useful for French labour-market classification.
06
Document guardrails
A document that may not be a CV comes back with a warning; an unreadable file or one without text returns a 422 instead of an empty profile.
A JSON field map built for candidate databases
Every group sits in resume, next to application_id.
info_candidate
Identity, contact and status
full_nameemailphone_numberjob_titlebirth_dateavailability_nowavailability_datedriver_license[]linkedin_urlgithub_urlinfo_candidate.location · mobility
Where the candidate is and can work
citypostal_coderegioncountry_codelatitudelongitudecan_work_in_other_citiesother_cities[]work_experiences[]
Career history
company_namejob_titledescriptioncontract_typestart_dateend_datecurrently_activeexperience_durationeducations[]
Degrees and schools
degree_titleschool_namedegree_typestart_dateend_datelocationskills[] · languages[]
Competencies
skill_titleskill_typestatusdomainsubcategorylanguagelevelinfo_resume · rome_jobs[]
Document and classification
languagetextface_urlurlrome_codeprediction_scorecertifications[]interests[]
Normalized vocabularies
These fields always use the same values, so you can build filters and reports on them. Except skill_type, each one can also be null when the CV does not say.
| Field | Values |
|---|---|
experience_level | 0 to 1 year · 1 to 3 years · 3 to 5 years · 5 to 10 years · More than 10 years |
education_level | Level 1 to Level 8 (EQF) · Other |
languages[].level | CEFR A1 to C2, with a label |
contract_type | Permanent contract · Fixed-term contract · Temporary assignment · Internship · Apprenticeship · Freelance · Volunteering · Other |
skill_type | Hard skill · Soft skill · Software skill |
Parse a resume with one request, in cURL or Python
Values below come from the API reference example. Field names and shapes match the live contract.
curl -X POST https://hirelayer.co/api/v4/resumes/parse \
-H "X-API-Key: $HIRELAYER_API_KEY" \
-F "file=@resume.pdf"import os
import requests
with open("resume.pdf", "rb") as file:
response = requests.post(
"https://hirelayer.co/api/v4/resumes/parse",
headers={"X-API-Key": os.environ["HIRELAYER_API_KEY"]},
files={"file": ("resume.pdf", file, "application/pdf")},
timeout=150,
)
response.raise_for_status()
data = response.json()
print(data["resume"]["info_candidate"]){
"application_id": "file_d7e21d373637a897b17b8fdf63122807",
"request_id": "8a4adbed-13fe-42cb-a5d5-5b1890b4dd81",
"stored": true,
"already_stored": false,
"resume": {
"info_resume": {
"language": "EN",
"face_url": "https://files.hirelayer.co/faces/elias-moreau-resume-face.jpg"
},
"info_candidate": {
"full_name": "Elias MOREAU",
"email": "elias.moreau@example.com",
"job_title": "AI Engineer",
"experience_level": "5 to 10 years",
"education_level": "Level 7",
"availability_now": true,
"location": { "region": "Île-de-France", "country_code": "FR" }
},
"work_experiences": [
{
"company_name": "Novalys AI",
"job_title": "AI Engineer",
"start_date": "2024-01-01",
"end_date": "2025-12-31",
"experience_duration": 24
}
],
"languages": [
{ "language": "English", "level": "Full Professional Proficiency (C1)" }
],
"skills": [
{
"skill_title": "Node.js",
"skill_type": "Software skill",
"status": "normalized",
"domain": "Software Development",
"subcategory": "Backend development"
}
]
},
"warnings": [],
"credits_used": 1
}- application_id
- The stored resume’s id: derived from the file, or yours when you send application_id.
- resume.info_resume.face_url
- The candidate photo, cropped from the CV, or null.
- resume.languages[].level
- Normalized to CEFR levels A1 to C2.
- already_stored · credits_used
- The same file sent again returns the stored resume, for 0 credits.
Where teams use CV parsing
HireLayer Resume Parser is used by recruiting software and recruiting services. Each use case links to the full workflow.
- 01
CV upload that prefills a profile
Parse the file at signup, prefill experience, education and skills, then let the candidate confirm before saving.
Resume Parser for Job boards & career sites - 02
Structured intake in an ATS
Parse each application CV from your upload service and attach your application reference as application_id.
Resume Parser for ATS platforms - 03
Search by availability and mobility
Store availability_now, availability_date and mobility cities so consultants can filter a pool for a job order.
Resume Parser for Staffing & temp agencies
Integrate the resume parser in your backend
Call the API from your backend and keep the key server-side. Your product keeps its records, interface and review process.
STEP 01
Upload from your backend
Post the file to /api/v4/resumes/parse from a server-side service with your API key and, if you have one, your own application_id.
STEP 02
Map the field groups
Store resume.info_candidate, work_experiences, educations, languages and skills in your profile model. Keep application_id, and request_id for support.
STEP 03
Chain the next product
Send the application_id to HireLayer Resume Scorer to score the resume against a job, and normalize raw skills with HireLayer Skills Normalizer.
Technical specifications
- Authentication
- X-API-Key header
- Content-Type
- multipart/form-data
- Fields
- file (required) · application_id · webhook_url · do_not_store_data
- File size
- About 4.5 MB (6 MiB encoded)
- Response time
- About 25 to 35 s; set a 150 s client timeout
- Callback
- webhook_url: 202 at once, the signed result posted to it
- Billing
- 1 credit per resume; 0 when the file is already stored
No backend to write? Use Resume Parser from Make, Power Automate, ChatGPT, Claude, Google Sheets or your ATS.
Where Resume Parser fits in the HireLayer pipeline
Each product works on its own. Chain them when a workflow needs CV data, job criteria, a search and a decision aid together.
- CV filePDF, DOCX, image…Resume ParserResume Parsing API→ application_id · resumeJob RecommendationsJob Recommendation APIresume → closest open jobsResume ScorerCandidate & Job Matching APIjob + resumes → score · verdict
- Job descriptionText or fileJob Criteria ExtractorJob Parsing API→ job_id · criteria[]Talent Pool SearchTalent Pool Search APIjob → closest stored resumesResume ScorerCandidate & Job Matching API+ precise_ranking → ranking_reason
- Free-text skillsFrom CVs, jobs or usersSkills NormalizerSkills Matching API→ taxonomy skill ids
Store skill ids on profiles and jobs for search and facets.
Resume Parser and Job Criteria Extractor store what they read. The searches find the closest resumes or jobs; Resume Scorer explains the fit. One API key and one credit balance cover every call.
Resume Parsing API questions
Answers based on the current API contract.
Which resume formats does the Resume Parsing API accept?
Is resume parsing synchronous?
What happens if someone uploads a document that is not a CV?
Does the Resume Parsing API return language levels?
Does the Resume Parsing API extract the candidate photo?
Which resume languages can it parse?
Does the Resume Parsing API handle scanned PDFs and phone photos?
Does HireLayer parse scanned CVs from candidates in multiple languages?
Can I stop parsed data from being retained?
What is the difference between resume parsing software and a resume parsing API?
How is the Resume Parsing API billed?
Make your first call to HireLayer Resume Parser today.
Create an account to get an API key. Credits are shared across all six HireLayer products.
Related HireLayer products
- Candidate & Job Matching APIHireLayer Resume ScorerScore resumes against a job, criterion by criterion.
- Skills Matching APIHireLayer Skills NormalizerResolve free-text skills to one shared taxonomy.
- Talent Pool Search APIHireLayer Talent Pool SearchFind the stored resumes closest to a job.
Solutions using Resume Parser
Resume Parser in production
Guides for Resume Parser
- Free online resume parserParse one of your own CVs in the browser, no account needed.
- Best resume parsing software in 2026Six vendors compared on price, output, connectors and security.
- Resume parser benchmark on 10 test resumesHireLayer, Textkernel, RChilli and Affinda scored field by field.
- HireLayer vs HrFlow.ai benchmarkBoth parsers scored field by field on 30 unseen resumes.
- Compare resume parser APIs with a fair benchmarkA reproducible test plan for quality, latency and cost.
- Resume parser API pricing per 1,000 CVsCompare price models and calculate your effective cost.
- What is a resume parser?How CV parsing works, with a real CV-to-JSON example.
- Parse a resume PDF into JSON with Python or Node.jsCompare PDF extraction, OCR and a parser API, with working code.
- Parse a resume to JSON in PythonOne requests call, typed dataclasses, safe retries and a batch of files.
- Convert a resume to JSON ResumeMap a parsed PDF or DOCX resume onto JSON Resume 1.7.0 in Python.
- Resume parser API integration guideSend files from your backend, map the JSON and handle errors.
- Bulk resume parsing with a reliable pipelineQueues, retries, deduplication and cost controls at scale.
- Measure and improve resume parsing accuracyScore each field on a labeled test set from your own CVs.
- Resume parser APIs that extract the photoSix APIs compared on the candidate photo field and format.