HireLayer CV Extract · Resume Parsing API

Resume Parsing API that turns any CV into structured JSON

Send a resume file in one multipart request. HireLayer CV Extract returns candidate details, work history, education, languages and skills as normalized JSON in the same response, ready to store in your ATS or product.

Start for free Read the API docs

Try the parser demo

Endpoint: POST /api/v3/parser
Input: CV file · 13 formats
Response: Synchronous JSON
Billing: 1 credit per parsed CV

API requests processed: 1M+
In production since: 2024
Parse success rate: ~99.7%

HireLayer CV Extract

POST /api/v3/parser

200 OK

resume.pdf

Alex Morgan

Senior Software Engineer · Paris

Experience

Languages

TypeScriptReactNode.js

multipart

{

"info_candidate": { "full_name": "Alex Morgan",
"experience_level": "5 to 10 years" },

"work_experiences": [{ "job_title": "Senior Software Engineer",
"experience_duration": 52 }],

"languages": [{ "level": "Full Professional Proficiency (C1)" }],

"skills": [{ "skill_title": "TypeScript",
"skill_type": "Software skill" }]

}

Capabilities

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
Cover letters, IDs or blank scans uploaded in the CV slot end up as empty or misleading candidate profiles.

01
13 file formats, one endpoint
PDF, DOC, DOCX, ODT, PPT, PPTX, ODP, XLS, RTF, TXT, JPG/JPEG, PNG and BMP go through the same multipart request.
02
Normalized values, not just text
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
Documents that are not a CV, are unreadable or have no text return a classified 422 error instead of an empty profile.

Under the hood

A JSON field map built for candidate databases

info_candidate
Identity, contact and status
full_nameemailphone_numberjob_titlebirth_dateavailability_nowavailability_datedriver_license[]linkedin_urlgithub_url
info_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_duration
educations[]
Degrees and schools
degree_titleschool_namedegree_typestart_dateend_datelocation
skills[] · languages[]
Competencies
skill_titleskill_typestatusdomainsubcategorylanguagelevel
info_resume · rome_jobs[]
Document and classification
languagetextface_urlapplication_idrome_codeprediction_scorecertifications[]interests[]

Normalized vocabularies

These fields always use the same values, so you can build filters and reports on them. 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 · degree_type`	Level 1 to Level 8 (EQF) · Other
`languages[].level`	CEFR A1 to C2, with a label
`contract_type`	Permanent · Fixed-term · Temporary assignment · Internship · Apprenticeship · Freelance · Volunteering · Other
`skill_type`	Hard skill · Soft skill · Software skill

Request and response

Parse a resume with one request

Values below come from the API reference example. Field names and shapes match the live contract.

HireLayer CV Extract docs

RequestPOST /api/v3/parser

curl -X POST https://onlineresumeparser.com/api/v3/parser \
  -H "X-API-Key: YOUR_API_KEY" \
  -F "file=@/path/to/resume.pdf" \
  -F "application_id=app_123"

Response200 OK · application/json

{
  "status": "success",
  "request_id": "req_01J9R8M4Y2A6K7D9P3N5Q1T8",
  "info_candidate": {
    "full_name": "Alex Morgan",
    "email": "[email protected]",
    "job_title": "Senior Software Engineer",
    "experience_level": "5 to 10 years",
    "education_level": "Level 7",
    "availability_now": false,
    "location": { "city": "Paris", "country_code": "FR" }
  },
  "work_experiences": [
    {
      "company_name": "Northstar Labs",
      "job_title": "Senior Software Engineer",
      "contract_type": "Permanent contract",
      "start_date": "2022-03-01",
      "currently_active": true,
      "experience_duration": 52
    }
  ],
  "languages": [
    { "language": "English", "level": "Full Professional Proficiency (C1)" }
  ],
  "skills": [
    {
      "skill_title": "TypeScript",
      "skill_type": "Software skill",
      "status": "normalized",
      "domain": "Engineering",
      "subcategory": "Web"
    }
  ]
}

info_candidate.experience_level: One of five brackets, from “0 to 1 year” to “More than 10 years”.
work_experiences[].experience_duration: Duration of the role in months, next to ISO dates.
languages[].level: Normalized to CEFR levels A1 to C2.
skills[].status: raw or normalized, so you know which labels to map.

Use cases

Where teams use CV parsing

HireLayer CV Extract 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.
CV Extract 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.
CV Extract 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.
CV Extract for Staffing & temp agencies

Integration

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/v3/parser from a server-side service with your API key and your own application_id.
STEP 02
Map the field groups
Store info_candidate, work_experiences, educations, languages and skills in your profile model. Keep request_id for support.
STEP 03
Chain the next API
Send info_resume.text to HireLayer Match or Rank as candidate_text, and normalize raw skills with HireLayer Skills.

Technical specifications

Authentication: X-API-Key header
Content-Type: multipart/form-data
Fields: file (required) · application_id · webhook_url · do_not_store_data
Request size: Up to 6 MiB encoded
Extracted text: Up to 100,000 characters
Versions: V3 synchronous (current) · V2 callback contract
Billing: 1 credit per successful parse

Where CV Extract fits in the HireLayer pipeline

Each API works on its own. Chain them when a workflow needs CV data, job criteria and a decision aid together.

Your inputStructureCompare

CV filePDF, DOCX, image…
CV ExtractResume Parsing API→ info_resume.text · skills[]MatchCandidate & Job Matching APIjob_text + candidate_text + matching_criteria
Job descriptionPlain job_text
Job ExtractJob Parsing API→ matching_criteria[]RankCandidate Ranking APIjob_text + up to 10 candidate_text
Free-text skillsFrom CVs, jobs or users
SkillsSkills Matching API→ catalog skill terms
Store normalized terms on profiles and jobs for search and facets.

Match takes criteria from Job Extract and CV text from Extract. Rank only needs the job text and each candidate’s CV text. One API key and one credit balance cover every call.

Questions

Resume Parsing API questions

Answers based on the current API contract.

Which resume formats does the Resume Parsing API accept?

PDF, DOC, DOCX, ODT, PPT, PPTX, ODP, XLS, RTF, TXT, JPG/JPEG, PNG and BMP. The encoded request must stay under 6 MiB, and documents above 100,000 extracted characters are rejected.

Is resume parsing synchronous?

Yes. V3 returns the parsed JSON in the HTTP response. You can also pass a webhook_url for a callback. The V2 endpoint remains available for integrations built on its callback-only contract.

What happens if someone uploads a document that is not a CV?

The API returns HTTP 422 with a code such as DOCUMENT_NOT_A_RESUME, DOCUMENT_UNREADABLE or DOCUMENT_TEXT_EMPTY, so your product can ask for another file instead of saving an empty profile.

Can I stop parsed data from being retained?

Set do_not_store_data to true in the request when parsed data must not be retained. It defaults to false.

How is the Resume Parsing API billed?

Each successful parse consumes one credit from the balance shared by all HireLayer APIs. Credits are deducted after a successful parser response.

HireLayer CV Extract

Make your first HireLayer CV Extract call today.

Create an account to get an API key. Credits are shared across all five HireLayer APIs.

Create an API account HireLayer CV Extract docs Try the parser demo

Works well with

All products

Resume Parsing API that turns any CV into structured JSON

What the Resume Parsing API extracts

Every CV uses a different layout

Free text cannot be filtered

Wrong uploads pollute records

13 file formats, one endpoint

Normalized values, not just text

Location and mobility

Typed skills

Occupation codes

Document guardrails

A JSON field map built for candidate databases

Identity, contact and status

Where the candidate is and can work

Career history

Degrees and schools

Competencies

Document and classification

Normalized vocabularies

Parse a resume with one request

Where teams use CV parsing

CV upload that prefills a profile

Structured intake in an ATS

Search by availability and mobility

Integrate the resume parser in your backend

Upload from your backend

Map the field groups

Chain the next API