Zoho resume parser: what Zoho Recruit parses, and its limits

Published 1 October 2026

Zoho resume parser: how Zoho Recruit reads a CV, and where it stops

The Zoho resume parser is the Resume Parser built into Zoho Recruit. You upload a CV, it extracts names, contact details, skills, education and work experience, and it fills the matching fields of a candidate record in the Candidates module. It is included in every Zoho Recruit plan, and the fields it writes are yours to remap. If your candidates live in Zoho Recruit and a recruiter reads them there, it is probably all the parsing you need. If you need the parsed data outside Zoho, or before a candidate record exists, you need a parser of your own.

This article is for the developer or recruiter-ops person deciding between the two. Everything about Zoho Recruit below was read from Zoho's own help pages and API documentation, as of October 2026. We build ResumeJSON, a resume parsing API, so read the later sections as written by an interested party.

How the Zoho Recruit resume parser works

Zoho's help center describes the parser in one sentence:

The Resume Parser extracts information from candidate resumes, such as names, contact details, skills, education, and work experience, and automatically populates the corresponding fields in the Candidates module in Zoho Recruit.

There are three things worth knowing about that flow.

Parsing creates a candidate

The parser is wired to the Candidates module. You reach it through Candidates, Import, Import from Document, and the result of a parse is a candidate record, owned either by you ("Import My Candidates") or by someone you assign ("Import My Organization Candidates"). You choose what happens when the CV matches an existing candidate: Skip, Overwrite or Clone.

You decide where each field lands

Under Setup, Resume Management, Resume Parser Mapping you see every field the parser recognises beside the Zoho Recruit field it fills, and you can point any of them at a different field, including a custom one. Two details from Zoho's documentation matter in practice:

• A mapping change only affects future parses. Candidate records created before the change keep the old mapping.
• There is a test button. "Test Resume Parser" lets you upload a sample CV and preview the result before you import a batch.

Only profiles with the Resume Parser Mapping permission can change the mapping; Administrator and Standard have it by default.

A recruiter can review before saving

The Parsing Review screen shows the extracted fields before the record is created, so a person can correct a misread date or a split name and click Update. That is a good default for a recruiter importing a few CVs a day. It is also the first sign of what the parser is designed for: a human in Zoho, looking at a profile.

Zoho resume parser limits, file types and volumes

Zoho publishes its limits clearly. As of October 2026, the Resume Parser help page lists:

Note the word lifetime on the free and trial rows. A free Zoho Recruit account can parse 500 CVs in total, ever, which suits a small agency and does not suit a backlog. Paid plans are priced per user per month, and Zoho shows regional prices on its pricing page, so check that page in your own currency rather than relying on a figure quoted elsewhere.

Image files are not among the supported formats. A CV that arrives as a phone photo or a scanned JPEG has to be converted before Zoho can parse it; our article on OCR resume parsing covers what that involves.

The Zoho Recruit API: import_document

Zoho Recruit exposes the parser to code through one endpoint in API v2:

POST https://recruit.zoho.com/recruit/v2/Candidates/actions/import_document

Zoho's documentation states its purpose as "To import resumes individually to the parser". You send a filename and the document as base64 (or the file in the request body), authenticated with a Zoho OAuth token carrying the ZohoRecruit.modules.all or ZohoRecruit.modules.Candidate.Create scope.

Read that scope name again: Candidate.Create. The API call is the same import a recruiter does in the browser, one file at a time, and it produces a candidate in your Zoho Recruit account. There is no documented "parse this file and give me the fields" call that leaves no record behind, and you need a Zoho Recruit account, an OAuth client and a refresh token before the first request.

Zoho's parser and a standalone API, side by side

Neither column is better in general. They answer different questions.

When Zoho's own parser is enough

Stay with Zoho Recruit's parser when all of these hold:

• Every CV you care about ends up as a candidate in Zoho Recruit.
• A recruiter reads the profile in Zoho, and can fix a field in the Parsing Review screen.
• Your volume fits your plan, which on any paid plan it usually will.
• You would rather not run a second vendor, a second key and a second bill.

That describes most agencies and in-house teams using Zoho Recruit as their ATS. The parser is already paid for, it writes into fields you control, and Zoho's bulk ZIP import handles a migration. Adding another parser to repeat that work costs money and gains nothing.

When you need a parser outside Zoho

There are four cases where the parser inside Zoho Recruit does not reach.

You are building the form, not using the ATS

A careers page or job board that wants to autofill its application form has to parse the CV before the applicant submits. Calling import_document at that moment would create a candidate for every half-finished application. A standalone parse runs on the file alone, returns the fields, and lets the applicant correct them first.

Your code makes the decision

Automated resume screening and candidate matching need a typed record your code can filter on: a list of skills, dated work history, years of experience. Zoho's parser writes into candidate fields that were designed for a person to read, and reading them back means a second API call against your own mapping.

You serve more than one ATS

If your product sells to recruiters on Zoho Recruit, Lever and others, each ATS parses in its own way and exposes the result in its own shape. Our Lever resume parsing API article walks through the Lever side. Parsing once, in one schema, gives your code one record to read whichever system the candidate ends up in.

The CVs are not candidates yet

A folder of old CVs, a sourcing export, or files you only want to search: none of them should become Zoho records just to be read. Bulk resume parsing covers running a backlog through a parser once and keeping the results.

Using a parsing API together with Zoho Recruit

The two combine well. The pattern is: parse first, then create the candidate with the fields you already have.

1. Parse the file with the API of your choice and store the full JSON on your side.
2. Create the candidate through the Zoho Recruit API with the contact fields from the parse, and attach the original file so recruiters still see the CV.
3. Keep the rest where your code reads it. Skills, languages and certifications live in your database, or in custom fields if recruiters should see them.
4. Store the Zoho candidate id beside your record so the two can be joined later.

Step 1 with ResumeJSON is one request, with the file sent as multipart form data:

import { readFile } from 'node:fs/promises'

const form = new FormData()
form.set('file', new Blob([await readFile('cv.pdf')]), 'cv.pdf')

const res = await fetch('https://resumejson-resume-cv-parser-api.p.rapidapi.com/v1/parse', {
  method: 'POST',
  headers: {
    'x-rapidapi-key': process.env.RAPIDAPI_KEY,
    'x-rapidapi-host': 'resumejson-resume-cv-parser-api.p.rapidapi.com'
  },
  body: form
})

const { resume } = await res.json()
// resume.basics.full_name, resume.basics.email, resume.basics.phone
// resume.work[], resume.education[], resume.skills[], resume.languages[]

ResumeJSON reads PDF, DOCX, plain text and images of a page (JPEG, PNG or WebP), and returns null for a value the CV does not state rather than guessing one. As of October 2026 it is sold through RapidAPI, with a free Basic plan of 100 parses a month that is a hard cap and cannot bill you; the docs carry the paid plans and the full field reference. You can try a real CV in the free parser before writing any code.

Summary

• The Zoho resume parser lives inside Zoho Recruit. It turns an uploaded CV into a candidate record, with a field mapping you configure and a review screen for corrections.
• Its limits are published: DOC, DOCX and PDF up to 10 MB, 25 files per batch, and 500 parses in the lifetime of a free account.
• The API is import_document, which creates a candidate; there is no documented parse-only call.
• It is enough when every CV goes into Zoho Recruit and a recruiter is the reader.
• Add a standalone parser when you parse before a candidate exists, when code makes the decision, when you serve more than one ATS, or when the CVs are not candidates.

If you are designing what to store, how to build an ATS covers the data model, and extract information from a resume goes through every field a parser can return.