ATS parsing: what an ATS reads from your resume, and how to test it

Published 28 September 2026

ATS parsing: what an ATS reads from your resume

ATS parsing is the step where an applicant tracking system reads your resume file and copies its contents into fields: your name, email, phone, each job with its company, title and dates, your education and your skills. Recruiters search, filter and sort on those fields. If a fact did not make it into a field, the recruiter's search cannot find it, even though it is sitting right there in your PDF. So the useful question is simple: what does a parser actually get out of your file? You can check that yourself in about a minute, and this page shows how.

It covers what parsing extracts, the layouts that trip it up, a step-by-step way to test your own CV, and what to do if you are the developer building the ATS rather than the person applying to one. We build ResumeJSON, a resume parsing API with a free online parser, so read the testing section as written by an interested party.

What ATS parsing actually extracts

An ATS does not store your resume as a picture of a page. It keeps the original file for a human to open later, and alongside it a structured record built by its parser. That record usually looks something like this:

The parser's job is to decide which text belongs in which row. Nothing in a PDF says "this line is a job title". The parser infers it from position, wording and patterns, and every inference can go wrong.

The record is what gets searched. When a recruiter types "Kubernetes" into the ATS search box, the system is matching against the parsed fields and the extracted text, not reading your layout the way a person would.

How an ATS parses a resume, step by step

Every parser runs roughly the same three steps. Our longer explainer on what resume parsing means goes into each one; the short version:

1. Get the text out of the file. A DOCX is a zip of XML, and the text comes out in order. A PDF stores fragments of text at coordinates on a page, so a two-column layout can come out interleaved. A scanned PDF or a photo has no text at all and needs optical character recognition or a model that reads images.
2. Find the sections and fields. The parser decides where experience starts, which line is the employer and which is the title, and which string is a phone number.
3. Normalise the values. "Mar 2021 to present" becomes a start date of 2021-03 and a flag saying the job is current. "BSc" and "Bachelor of Science" become the same degree.

Most failures start in step 1. If the text comes out in the wrong order, no later step can put it back.

The layouts that break ATS parsing

These are the patterns that most often produce a wrong or empty field. None of them is forbidden; each one is a risk you can test for.

• Two or three columns. Text extraction may read straight across the page, gluing a sidebar skill onto a job title on the same line.
• Contact details in the header or footer area of a Word file. Some extractors skip headers and footers, so the email never reaches the record.
• Text inside images, icons or charts. A skill bar drawn as a graphic carries no text. A phone icon with no number beside it is nothing to a parser.
• Tables used for layout. Cells can come out in an order that splits a job's dates from its title.
• Unusual section names. "Where I've been" is harder to recognise than "Experience".
• Dates in inconsistent formats. "2019 to now", "Jan 20" and "03/2021" in one document make date normalisation guess.
• A scanned or photographed resume. Without a text layer, everything depends on the OCR step. Our OCR resume parser article covers what happens there.

A single-column layout, standard section headings and one date format remove most of these risks at once. That is the whole of the usual "ATS-friendly resume" advice, and it holds because of how step 1 works.

How to test your resume's ATS parsing

You cannot run your file through a particular employer's ATS before you apply. What you can do is run it through a parser and read the record it produces. If a parser gets your job titles, dates and skills right, your layout is readable. If it scrambles them, another parser may well scramble them too.

1. Export the exact file you will upload. Test that file, not the design file it came from.
2. Open a parser that shows you the fields. Our free resume parser takes a PDF, DOCX, plain text, or a photo or scan of the page, needs no signup, and does not store the document. It returns the parsed record as JSON.
3. Check the contact block first. Is your name in the name field, and are your email and phone there exactly as you wrote them?
4. Walk the work history, one entry at a time. Each job should have its own company, title, start date and end date, and your current job should be marked current. A title glued to the wrong company, or a date missing, is the thing to fix.
5. Check education the same way. Institution, degree and field should land in separate fields.
6. Read the skills list. Are the skills you care about in it? If a key skill appears only inside a graphic, it will not be.
7. Change one thing and re-run. If the work history came out wrong, move the sidebar content below the main column, or rename a section heading, and parse again. One change at a time tells you which one mattered.

Here is what a clean result looks like for a short, single-column CV:

{
  "basics": {
    "full_name": "Jane Doe",
    "email": "jane@example.com",
    "location": "Berlin"
  },
  "work": [
    { "company": "Acme GmbH", "title": "Senior Backend Engineer",
      "start_date": "2021-03", "end_date": null, "is_current": true }
  ],
  "education": [
    { "institution": "TU Berlin", "degree": "BSc", "field_of_study": "Computer Science" }
  ],
  "skills": ["Go", "PostgreSQL", "Kubernetes"]
}

If yours looks like that, with your own facts in the right places, a parser can read your resume.

What a test like this cannot tell you

Be clear about the limits. Every ATS uses its own parser, and they differ. A clean result from one parser is good evidence that your layout is readable, not a guarantee about any specific employer's system. A test also says nothing about ranking: whether a recruiter's search or screening rules score you well depends on the job, the keywords they use and their own settings, which no outside tool can see.

When a manual check is enough

For most people applying to a handful of jobs, the manual version works well:

• Save your resume as plain text from Word, or copy all the text out of the PDF and paste it into a text editor.
• Read it top to bottom. If the order makes sense and every job, date and skill is present as text, most parsers will do fine with it.

That catches the biggest problem, text coming out in the wrong order or not at all. A parser adds the next layer: whether the fields land where they belong. Use it when your layout has columns, when you are not sure about your dates, or when you are sending one file to many employers and want to check it once, properly.

ATS parsing for developers building the ATS

If you are on the other side, building a job board, an ATS or a matching tool, ATS parsing is a feature you need to supply. You have three options: write your own on top of a text extractor, run an open source model, or call a parsing API. Our how to build an ATS guide covers where parsing fits in the data model, and the CV parser API comparison lists the hosted options and what each returns.

The questions that matter when you choose:

ResumeJSON returns a documented JSON record for PDF, DOCX, text and images of the page; the field reference and plans are public, and you can try the same parser in the browser before writing any code.

Summary

• ATS parsing turns your resume into searchable fields. What misses a field is invisible to search.
• Most failures come from getting the text out of the file: columns, graphics, headers and scans.
• You can test your own file by running it through a parser and checking the contact block, each job, education and skills.
• A clean result means your layout is readable. It does not predict how any one employer ranks you.

Try your resume in the free resume parser and read the record it returns.