We tested how accurately our own CV parser reads a CV, and it scored about 99 out of 100 on word-for-word field accuracy across five different layouts. The lowest single CV scored 96.2 out of 100, and three of the five scored 99.2 or higher. More importantly, the layouts that normally break a parser, a two-column CV and a CV with a sidebar, scored 99.8 and 99.2.
"How accurate is CV parsing?" is one of the most common questions recruiters ask before trusting a tool with candidate data, and almost no vendor answers it with real numbers. This post does. We ran five real CV files through RefineCV's live production parser and scored every extracted field against a hand-authored answer key, then we list exactly which fields it got wrong.
Key takeaways
- In our own test, RefineCV's parser scored about 99 out of 100 on word-for-word field accuracy across five different CV layouts. The lowest single score was 96.2 and three of the five were 99.2 or higher.
- The two layouts that break most parsers, a two-column CV and a CV with a sidebar, scored 99.8 and 99.2. Columns and sidebars are the formatting choices that most often scramble data in an ATS, so this is the result that matters most for recruiters.
- Names, contact details, employment history (company, title, dates), education and certifications came back at or near 100 on every CV. These are the fields a client reads first, and they are the ones the parser is most reliable on.
- The small deductions were explainable: on the hardest CV the parser inferred an age the document never stated, missed one degree major, and listed a few skills that appeared in the job descriptions but not the skills section. You see and edit every field before export, so none of this is baked into the output.
- This is a first-party test on five hand-checked CVs, not an independent benchmark. We publish it, and exactly which fields were missed, because no one else publishes real per-field parsing numbers. Treat it as a transparent sample, not a universal accuracy rate.
The result
Across five CVs, RefineCV's parser averaged 98.8 out of 100 on word-for-word field accuracy in the run shown, and about 99 across repeat runs. No single CV scored below 96.2, and the two layouts that most often defeat a parser, a two-column CV and a CV with a sidebar, scored 99.8 and 99.2. The fields a client reads first, name, contact details, employment history, education and certifications, came back at or near 100 on every CV.
How we tested it
We did not use a marketing demo. We ran five CV files through the same production parser RefineCV uses on live uploads, a dual-model AI pipeline (GPT-OSS-120B plus DeepSeek V3.1 running in parallel on every CV), and scored the result field by field.
Each CV has a hand-authored answer key: a person read the source document and typed the correct value for every field, from the first name to each job's start month. The scorer then compares the parser's output to that key word for word. Exact fields like names, dates and emails are scored as right or wrong. Longer fields like job descriptions are scored on word overlap with a penalty for anything extra the parser added. The five CVs were chosen to cover the layouts recruiters actually receive: a clean single-column CV, a dense CV, a two-column CV, a CV with a sidebar, and a complex CV with five employers and heavy formatting.
One honest caveat on the method: the models are non-deterministic, so the scores move by about a point if you run the test again. The numbers below are from one representative run. We are also testing five CVs, not five thousand, so read this as a transparent, checkable sample rather than a universal accuracy figure.
Scores by CV layout
Here is every CV, its score, and what the parser missed. The "what it missed" column is the honest part: these are the exact fields that cost points.
| CV layout | Faithfulness score | What it missed |
|---|---|---|
| Simple (single-column PDF) | 99.8 / 100 | One employment-history detail |
| Dense (packed one-column DOCX) | 98.8 / 100 | A skills item and an education detail |
| Two-column (DOCX) | 99.8 / 100 | A skills item and an education detail |
| Sidebar (PDF) | 99.2 / 100 | One language and a skills item |
| Complex (five employers, TXT) | 96.2 / 100 | Inferred an age, missed one degree major, added related skills |
Almost no CV parsing vendor publishes a real accuracy number, let alone which fields it gets wrong. We publish both because a checkable, first-party result is worth more to a recruiter deciding what to trust than a round marketing claim. This is five hand-checked CVs, not an independent benchmark, so treat it as a transparent sample.
Why a parser scores below 100
No parser scores a perfect 100 on every CV, and ours did not either. The useful part is that the misses were small and the kind you can see and fix before a CV goes to a client.
On the complex CV, three things cost points. The parser reported an age of 38 when the CV only gave a date of birth and never stated an age, so it inferred a number the document did not contain. It left one degree major blank even though it read the degree and university correctly. And it returned more skills than the printed skills section listed, pulling in terms like C++ and Google Cloud that appeared in the job descriptions but not the skills list. A strict word-for-word test counts those extra skills as a deduction.
The pattern across all five CVs is the same. The fields a client judges a candidate on, name, contact details, employment history, education and certifications, came back at or very near 100. The deductions landed on secondary fields: an inferred age, an occasional skill, one language entry. Because RefineCV shows every parsed field for review and lets you edit before export, a miss like an inferred age is visible and editable, not something that silently reaches your client.
What this means for recruiters
For a recruiter the headline is not the average, it is which layouts held up. Columns, sidebars and tables are the formatting choices most likely to scramble data in an ATS, because they break the top-to-bottom, left-to-right reading order a parser expects. That is why a CV that looks fine on screen can arrive at a client's ATS with the job titles detached from the dates.
In this test the two-column CV scored 99.8 and the sidebar CV scored 99.2, so the layouts that usually cause the most trouble were read correctly. That matters more than the single complex CV that scored 96.2, because columns and sidebars are common and the complex failure modes (an inferred age, an extra skill) are visible on review.
The deeper point still holds: parsing extracts data, it does not format it. Even a CV parsed at 100 still needs a clean, branded rebuild before it is client-ready. For how parsing fits the wider workflow, see our guide to CV parsing for recruiting, and for the technology behind it, CV parsing technology explained.
Frequently asked questions
How accurate is CV parsing?
It depends on the parser and, more than anything, on how the CV is formatted. In our own field-by-field test across five layouts, RefineCV's parser averaged about 99 out of 100 on word-for-word accuracy, with individual CVs scoring between 96.2 and 99.8. Accuracy is highest on core fields (name, contact details, employment history, education) and dips on secondary fields like skills or an inferred age. Clean single-column CVs parse most reliably; heavy tables, columns and graphics are what usually cause data loss.
Which CV layouts are hardest for a parser to read?
Multi-column designs, sidebars, tables, and contact details placed in a header or footer are the formatting choices most likely to cause data loss, because they break the top-to-bottom, left-to-right order a parser expects. In our test the two-column and sidebar CVs still scored 99.2 and 99.8, but across the industry these layouts are the usual cause of scrambled or missing fields in an ATS.
What does a CV parsing accuracy score actually measure?
In our test it measures word-for-word agreement between the parser's output and a hand-authored answer key, field by field. Exact fields like names, dates and emails are scored right or wrong. Longer fields like job descriptions are scored on word overlap, with a penalty for extra words the parser added. The overall score is the average across every field in the CV, so a single wrong secondary field only moves it by a point or two.
Does CV parsing make a CV client-ready?
No. Parsing extracts candidate data into structured fields, but it does not format a document. Even a CV parsed perfectly still needs a formatting step to rebuild it into a clean, branded, client-ready layout. RefineCV parses the CV, lets you review and edit every field, then rebuilds it into your branded template and exports a PDF or Word file.
Can I trust an AI CV parser with candidate data?
Trust it to do the first pass, then review it. In our test the fields a client judges a candidate on came back at or near 100, but a parser can still infer a value the CV never stated or miscategorise a secondary field. The safe workflow is to use a tool that shows you every parsed field and lets you correct it before the CV leaves your hands. RefineCV is built this way: you see and edit the extracted data before export.
The bottom line
CV parsing is accurate enough to trust with the first pass and still worth reviewing before a CV reaches a client. In our test the core fields were read at or near 100, the awkward two-column and sidebar layouts held up, and the few misses were visible, editable secondary fields rather than silent errors in the data that matters. The right workflow is a parser that shows its work: it extracts the data, you review and correct it, then it rebuilds the CV into a clean branded document.
Related reading: CV parsing for recruiting, how to make a candidate CV ATS-friendly, and our guide to the best CV formatting software for recruitment agencies.
See the parsed fields before anything reaches your client
RefineCV parses each CV, shows you every extracted field to review and edit, then rebuilds it into your branded template and exports a PDF or Word file. Start free with 10 CVs, no credit card. Then $0.40 per CV, or $50 per month for 200.
Sources
- RefineCV parsing faithfulness scorecard (2026): First-party test described in this post: five hand-authored golden CVs scored field-by-field against the live production parser.