Guides / CV parsing
Explainer + a test you can run this afternoon

CV parser vs CV formatter: one fills a database, the other fills an inbox

A CV parser is software that reads a CV and turns it into structured data: name, job titles, employers, dates and skills, each stored in its own field in your ATS or CRM. A CV formatter takes the same file and produces a document, the candidate's CV in your agency's template, for a client to read. This guide explains how parsing works, where it breaks, how to test the parser you already own, and which of the two tools a given problem calls for.

the short version
  • A parser's output is data for your team to search. A formatter's output is a document for your client to read. They sit at different ends of the desk.
  • Parsing runs in four steps: extract the text, find the sections, pick out the entities, normalise them to a schema. Most errors start at step one, with layout: columns, tables, text boxes, scans.
  • Vendor accuracy figures describe the vendor's test set. Run the 10-CV torture test below on your own ATS and you'll know your number in under an hour.
  • You almost certainly own a parser already, because most ATSs embed one.

What a CV parser is

CV parsing (resume parsing, in the US) is the step that happens when you drag a file onto a candidate record and the fields fill themselves in. The parser reads free-form text written by a person, decides which words are a job title and which are an employer, and writes each one into the right box.

The point is search. A folder of 40,000 PDFs can only be searched as loose text. A database of 40,000 parsed records can answer "finance managers within 30 miles of Leeds with SAP and ACCA, moved jobs in the last three years". Everything your ATS does afterwards, including matching, filtering and reporting, depends on how well those fields were filled in.

What comes out is not a document. It looks like this:

What a parser returns (simplified JSON, fictional candidate)
{
  "name":      { "first": "Priya", "last": "Nair" },
  "email":     "priya.nair@example.com",
  "location":  { "city": "Leeds", "country": "GB" },
  "experience": [
    { "title": "Finance Manager", "employer": "Halden Foods",
      "start": "2021-03", "end": null, "current": true },
    { "title": "Financial Analyst", "employer": "Orrin Logistics",
      "start": "2017-09", "end": "2021-02" }
  ],
  "education": [ { "degree": "BSc Accounting", "year": 2016 } ],
  "skills":    [ "SAP S/4HANA", "IFRS", "Cash forecasting" ]
}

Nobody sends that to a client. Hold on to that thought; it is the whole of the parser-versus-formatter distinction, and we'll come back to it.

How a CV parser works

Whatever the vendor calls its technology, the pipeline has the same four stations.

CV_final_v7.pdf 1 · Extract text text layer, or OCR 2 · Find sections PROFILEEXPERIENCEEDUCATION which block is which? 3 · Pick out entities namejob titleemployerdatesskillskilldegree who, where, when 4 · Normalise Fin. Mgr→ Finance Manager 03/21 – to date→ 2021-03 · current SAP S4, S/4 Hana→ SAP S/4HANA one spelling per thing CANDIDATE RECORD Priya NairFinance ManagerHalden Foods2021-03 → currentSAP S/4HANA, IFRS searchable in your ATS
the four stations every CV parser runsFictional candidate. A mistake at station 1 is carried through all the others.
  1. Text extraction. A Word file or a "real" PDF carries a text layer the parser can read directly. A scan or a phone photo has none, so the parser runs OCR first to recognise the characters. Either way the parser has to decide the reading order: which piece of text comes after which.
  2. Sectioning. The text is cut into blocks and each block gets a label: contact details, profile, experience, education, skills. Headings help ("Work History"), but candidates write "Where I've been" and "My toolbox", so parsers also look at what's inside the block.
  3. Entity extraction. Inside each block the parser tags the individual facts. In "Finance Manager, Halden Foods, Mar 2021 – to date", three separate things have to be recognised and tied together as one job.
  4. Normalisation. Values are cleaned and mapped to a fixed schema so records are comparable: dates to one format, "Fin. Mgr" to "Finance Manager", two spellings of a skill to one. Many parsers also map titles and skills to a taxonomy, which is what makes "accountant" find "finance manager" in a search.

Rules, machine learning, LLMs: three generations of parser

Vendors rarely tell you which approach sits under the bonnet, and most commercial products blend all three. It still helps to know how each one behaves, because they fail differently.

ApproachHow it decidesGood atTypical failure
Rule-basedHand-written patterns and dictionaries: "a line after the heading Experience that contains a year range is a job".Emails, phone numbers, standard layouts. Fast, cheap and it gives the same answer every time.Anything the rule-writer didn't foresee: a new heading, an unusual date, another language.
Statistical / MLA model trained on many labelled CVs predicts the label for each word or line.Varied wording and layouts close to what it was trained on.CV styles that were rare in the training data, such as a niche sector or a less common language.
LLM-basedA large language model reads the CV and is asked to return the fields.Odd layouts, unusual phrasing, implied information, custom fields.Slower and costlier per document, answers can vary between runs, and it may infer a value that isn't on the page.

That last failure deserves a second look. A rule-based parser that can't find an end date leaves the field empty. A language model may fill it with something plausible. For a database you search, a blank is annoying. A confident wrong value is worse, because nobody goes looking for it.

Where CV parsing fails, and why

A CV is designed to be looked at. A parser doesn't look, it reads a stream of text. Most parsing errors come from the gap between how a page appears and the order its text is stored in the file.

The classic case is the two-column CV. On the left is what the candidate sent. On the right is what a parser gets if it reads straight across the page, joining each line of the main column to the sidebar line that happens to sit beside it.

Priya Nair
Finance Manager

Experience

Finance Manager
Halden Foods · 2021 – present
Led month-end close across 4 entities

Financial Analyst
Orrin Logistics · 2017 – 2021
Built the weekly cash forecast

Education

BSc Accounting, Univ. of Leeds, 2016

Contact

priya.nair@example.com
+44 7700 900123
Leeds, UK

Skills

SAP S/4HANA
IFRS reporting

Languages

English, Hindi

Certificates

ACCA (2019)

what a person sees: two tidy columns

# reading order: straight across the page
PRIYA NAIR CONTACT
Finance Manager priya.nair@example.com
EXPERIENCE +44 7700 900123
Finance Manager Leeds, UK
Halden Foods · 2021 – present SKILLS
Led month-end close across 4 entities SAP S/4HANA
Financial Analyst IFRS reporting
Orrin Logistics · 2017 – 2021 LANGUAGES
Built the weekly cash forecast English, Hindi
EDUCATION CERTIFICATES
BSc Accounting, Univ. of Leeds, 2016 ACCA (2019)

what the parser saw: one column, shuffled

same file, two readingsAn illustration of the failure, with a fictional candidate. Highlighted text is sidebar content that landed mid-sentence.

Feed that stream into stations 2 to 4 and the record comes out like this:

FieldWhat got filedVerdict
Emailpriya.nair@example.comRight (emails have an unmistakable shape)
NamePriya Nair ContactWrong
Current job titleFinance Manager LeedsWrong
Current employerHalden Foods SkillsWrong
Skills(empty)Missing: the heading was swallowed by a date line, so the section was never found
Second roleFinancial Analyst IFRS reportingWrong, and now she'll never appear in a search for "IFRS" as a skill

In fairness to today's products: column detection is now a headline feature. Textkernel's parser page lists automatic detection of single- and multi-column layouts, and Bullhorn's notes on its 2026 parser upgrade say multi-column designs are read more accurately than before (sources in the vendor section). Good parsers get the simple sidebar right most of the time. The same mechanism still catches them on the stranger layouts below.

Ten causes worth knowing by name

▯▯

Columns and sidebars

Reading order goes across instead of down. Headings and values from two columns get stitched together.

▦

Tables

A CV laid out in a Word table is read cell by cell. Dates in one column and employers in another lose their pairing.

☐

Text boxes and shapes

Text inside a floating box may be stored at the end of the file, far from where it appears, or skipped by the extractor.

⎯

Headers and footers

Some extractors ignore them. If the candidate's name and phone number live in the page header, the record arrives without either.

▨

Scans and photos

No text layer, so everything depends on OCR. A skewed photo turns "l" into "1" and "rn" into "m", and email addresses stop working.

✎

Creative templates

Icons in place of labels, skill "bars", timelines drawn as graphics. A five-dot rating for Excel carries no text at all.

Ω

Other languages

Section headings, date words and name order all change. Mixed-language CVs, such as English with a German education section, are harder still.

31/12

Date formats

03/04/2021 is 3 April in London and 4 March in Chicago. Add "to date", "Summer 2019" and year-only ranges, and tenure calculations drift.

⇄

Title and employer swaps

"Halden Foods, Finance Manager" or "Finance Manager, Halden Foods"? Contractors placed through an agency add a third name to confuse things.

◌

Hidden text

White-on-white keywords are invisible to you and perfectly readable to a parser. They go straight into the skills field. See how to spot AI-manipulated CVs.

How to test CV parser accuracy yourself: the 10-CV torture test

Every vendor publishes an accuracy figure, and every figure is true for the CVs it was measured on. Affinda, for example, states "over 95% accuracy on core candidate fields" on its resume parser page. Notice the careful wording: core fields, scored their way, on their sample. The only number that describes your desk is one you measure on your own candidates. It takes about an hour.

Step 1: pick ten real CVs

Pull them from your own inbox so the sector and languages match your work. One of each:

  1. The controlPlain single-column Word file, standard headings. If this one fails, stop here.
  2. Two columnsA PDF with a sidebar for contact details and skills.
  3. Table layoutBuilt in a Word table, dates in the left-hand column.
  4. Header contactName, phone and email only in the page header or footer.
  5. Scan or photoA scanned PDF or a phone picture of a printout.
  6. Designer templateIcons, skill bars, a timeline graphic, a photo.
  7. Another languageOne you really recruit in, ideally with accented characters.
  8. Awkward datesNumeric day/month dates, "to date", an overlap and a gap.
  9. Long contractor CVTwelve or more assignments, some through an agency.
  10. LinkedIn PDF exportThe "Save to PDF" file, which has its own two-column layout.

Step 2: score ten fields per CV

Upload each file the way your team normally would, then compare the record with the original. Score each field 1 if it is exactly right, 0 if it is blank, and mark it W if it is filled in but wrong. Ten CVs times ten fields makes 100 checks, so your total is already a percentage.

Parser torture test: scoring sheet (paste into a spreadsheet)
PARSER TESTED: [ATS / vendor]        DATE: [..]      TESTER: [..]
Score per field: 1 = exactly right · 0 = blank · W = filled in but wrong

Field                         | CV1 | CV2 | CV3 | CV4 | CV5 | CV6 | CV7 | CV8 | CV9 | CV10
------------------------------|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----
1  Full name                  |     |     |     |     |     |     |     |     |     |
2  Email                      |     |     |     |     |     |     |     |     |     |
3  Phone                      |     |     |     |     |     |     |     |     |     |
4  Location (city)            |     |     |     |     |     |     |     |     |     |
5  Current job title          |     |     |     |     |     |     |     |     |     |
6  Current employer           |     |     |     |     |     |     |     |     |     |
7  Current role start date    |     |     |     |     |     |     |     |     |     |
8  All roles found, in order  |     |     |     |     |     |     |     |     |     |
9  Highest qualification      |     |     |     |     |     |     |     |     |     |
10 Skills (no junk, none lost)|     |     |     |     |     |     |     |     |     |
------------------------------|-----|-----|-----|-----|-----|-----|-----|-----|-----|-----
Correct (count of 1s)         |     |     |     |     |     |     |     |     |     |
Wrong (count of Ws)           |     |     |     |     |     |     |     |     |     |

TOTAL CORRECT: [..] / 100      TOTAL WRONG (W): [..]      TOTAL BLANK: [..]
Contact fields (rows 1–4):     [..] / 40
Career fields  (rows 5–8):     [..] / 40   <- the ones your searches depend on
Worst CV type: [..]            Worst field: [..]

Step 3: read the result

Once you know the share of records that need a manual fix, the cost is simple arithmetic. Put your own numbers in:

120records to fix each month
8 hof correction time per month
96 hper year, if somebody does it

The defaults are placeholders, not benchmarks. Use the error share from your own torture test. The larger cost is usually the records nobody fixes.

Resume parsing software: who makes it

The market splits into four groups, and recruiters mostly meet the second one.

These are five of the long-standing specialists. The descriptions are taken from each vendor's own site on the day we checked (October 2026) and are their claims, not our test results. We haven't listed prices: most are usage-based or quoted, so check each vendor's pricing page.

VendorWhat its own site says
TextkernelResume and job-posting parser delivered as a REST API returning JSON. Resume parsing in 29 languages, column-layout detection, title and skill normalisation, with OCR and an LLM-based parser offered as add-ons. Listed on the Bullhorn, Oracle, Salesforce and SuccessFactors marketplaces.
RChilliResume parser covering 40+ languages with automatic language detection, enrichment from its own skill taxonomies, and listed integrations with Oracle HCM, SAP SuccessFactors, Salesforce and ServiceNow.
AffindaResume parser available as a hosted API or a self-hosted container, returning structured JSON. Says it handles 50+ languages and accepts scans and photographs as well as PDF and Word files.
DaXtraMultilingual resume and CV parsing across 40+ languages, positioned as working inside the ATS a recruiter already uses, taking CVs from email, job boards and career sites.
HireAbilityResume and CV parser that says it extracts 200+ data points, supports 50+ languages and dialects including mixed-language documents, and offers hosted, installed and private-cloud deployment.

If you run an agency, the practical takeaway is short: you are probably not shopping for one of these. You are choosing an ATS, and the parser comes with it. Ask the ATS vendor which engine they use, then run the torture test during the trial.

CV parser vs CV formatter: the distinction most buyers miss

Recruiters often arrive at parsing software while trying to solve a different problem: "candidate CVs look terrible and I need them in our template before they go to the client." Parsing sounds like the answer because it also involves software reading a CV. It solves a neighbouring problem.

CV parserCV formatter
InputA CV file, as it arrivedA CV file, as it arrived
OutputStructured fields (JSON, a candidate record)A finished document (PDF or Word) in your template
Who consumes itYour ATS, your search box, your consultantsThe client's hiring manager
What "good" meansEach fact in the right field, in a standard formEvery word the candidate wrote, in the right place on the page
How it failsSilently: a wrong field nobody opens until a search misses the candidateVisibly: a section in the wrong place, which a consultant sees on proof-read
What it dropsAnything without a field: wording, emphasis, bullet structureThe old layout, fonts and decoration
Where it livesInside the ATS/CRM, at intake, on every CVBeside the ATS, at submission, on the shortlist
VolumeThousands a monthThe handful you put forward per role

One honest complication: a formatter has to read the CV too. Any tool that moves a candidate's experience into a new template must first work out where the experience section is, so there is parsing-like work inside every formatter. The difference is the destination, and it changes what counts as an error. A parser can normalise "Fin. Mgr" to "Finance Manager", because a database wants consistency. A formatter that did the same would be altering the candidate's CV, and a client document should say what the candidate said.

Some parsing vendors sell both, as separate products, which is itself a clue. Textkernel's parser page mentions a separate Resume Formatter product next to the parser.

a parser will not…
  • Give you a document you can send to a client
  • Put your logo, fonts and section order on a CV
  • Preserve the candidate's own sentences and bullets
a formatter will not…
  • Fill in your ATS fields
  • Make your database searchable
  • Rank, match or screen anybody

Which one you need: a decision rule

the rule

Ask who reads the output next. If it's a search box, you have a parsing problem. If it's a hiring manager, you have a formatting problem.

That last case is where the two tools help each other. A CV that has been rebuilt into a clean single-column template gives any parser, yours or the client's, far less to trip over than the two-column original. Formatting does not fix a parser, but it removes most of the ten causes above from the documents you file and send.

Questions recruiters ask about CV parsing

What is CV parsing?

CV parsing is the automatic conversion of a CV or resume into structured data. Software reads the document, works out which text is the name, job titles, employers, dates, education and skills, and stores each one in its own field in an ATS or CRM. The result is a candidate record you can search and filter, without anyone retyping the CV.

How does a CV parser work?

A CV parser works in four steps. It extracts the raw text from the file, using OCR if the file is a scan. It splits that text into sections such as experience and education. It identifies entities inside each section, such as job titles, employers and dates. Finally it normalises those values and maps them to a fixed schema.

How accurate is a CV parser?

Accuracy depends on the field and on the layout of the CV. Names, emails and phone numbers on a plain single-column document are usually read reliably. Job titles, employers and dates on CVs with columns, tables, text boxes or scanned pages are where errors concentrate. Vendor figures rarely describe your own mix of CVs, so test with ten of your own.

What is the difference between resume parsing and resume formatting?

Resume parsing produces data: fields in a database that recruiters search and filter. Resume formatting produces a document: the candidate's CV rebuilt in the agency's branded template, ready to send to a client. Parsing serves your internal search. Formatting serves the hiring manager who reads the shortlist. Most agencies use both, at different points in the process.

Why does my ATS scramble two-column CVs?

In a two-column file the text is not always stored in the order a person reads it. A parser that reads straight across the page joins a line from the main column to a line from the sidebar, so a skills heading can end up inside a job title. Newer parsers detect columns, but sidebars, tables and text boxes still cause errors.

Do I need separate resume parsing software if I already have an ATS?

Usually not. Most applicant tracking systems and recruitment CRMs include a parser, often licensed from a specialist vendor, and it runs when you upload a CV or forward one by email. Standalone resume parsing software is mainly bought by software companies, job boards and large employers who need parsing inside a product or system they build themselves.

Can a large language model parse a CV?

Yes. A general-purpose language model can read a CV and return structured fields, and it copes well with unusual layouts and wording. The trade-offs are cost and speed per document, results that can vary between runs, and the risk of the model inferring a value that is not on the page. Some parsing vendors now offer an LLM-based option alongside their classic parser.

Where to go next

If the formatting side is your problem, our comparison of the best CV formatting software for recruitment agencies lists the tools in that category, ours included, with the trade-offs. If you are choosing the system the parser lives in, start with the recruitment agency software overview. And if the torture test turned up skills nobody can see on the page, read how to spot AI-manipulated CVs before you trust the skills field again.

Somewhere, a shortlist is due at five.

Upload one real CV, the ugliest you've got. CVReady puts it into your agency's template in about a minute, word for word. The first one is free and needs no card.