Resume Parser + Job Match: CVs to JSON with a 0-100 match score

Resume Parser + Job Match is an Apify Actor that turns a list of resumes or CVs (PDF, DOCX or plain text) into structured JSON (contact details, job titles, work history, education and skills) and, if you give it a job posting, scores every resume against it from 0 to 100 with an explainable breakdown. It uses deterministic rules, not an LLM, it never logs resume content, and you pay only for resumes it parses ($0.005 each, or $5 per 1,000).

What does Resume Parser + Job Match do?

You give it a list of resumes, each as plain text or as a URL to a PDF, DOCX or TXT file, plus an optional job (title, description, location). For every resume it returns one dataset row with:

• Contact: name, email, phone, location, country, links (LinkedIn, GitHub, portfolio)
• Career: current_title, current_company, total_experience_years (overlapping jobs merged), seniority, function, and every experience entry with title, company, start and end dates, duration and bullets
• Education: education entries and highest_education_level
• Skills: normalised skills, plus skills_detail (category, mentions, sections, last year used), certifications, languages
• Match (when a job is given): match_score 0-100, matched_skills, missing_skills, match_breakdown and match_reasons in plain English
• warnings when something could not be found, for example a scanned PDF with no text layer

Export the dataset as JSON, CSV or Excel, or read it from the Apify API.

When should I use it?

• Screen a pile of applications: paste the job, add the CV links, sort by match_score.
• Fill an ATS, CRM or spreadsheet from CV files without retyping.
• Job boards and talent marketplaces: turn uploaded CVs into searchable candidate records.
• Automations: call it from Make, Zapier, n8n or the Apify API when new applications arrive.

For one resume at a time inside your own app, use the Resume Parser + Job Match API instead. It runs the same parser behind a REST endpoint.

Input

{
  "resumes": [
    { "id": "candidate-001", "text": "Alex Morgan\nSenior Backend Engineer\nalex.morgan@example.com\n\nEXPERIENCE\nSenior Backend Engineer, Acme Analytics\nJan 2021 - Present\n- Python, Django, AWS" },
    { "id": "candidate-002", "url": "https://example.com/cvs/sam-taylor.pdf" }
  ],
  "jobTitle": "Senior Backend Engineer",
  "jobDescription": "5+ years of experience. Python, Django, PostgreSQL, AWS, Docker, Kubernetes.",
  "jobLocation": "Remote - US"
}

Field	Required	Description
resumes	yes	List of {"text": ...} or {"url": ...} items, with an optional id copied to the output. A bare string also works. Up to 500 per run.
jobTitle	no	Job to score every resume against. Leave all job fields empty to parse only.
jobDescription	no	Posting text or HTML; required skills and years of experience are read from it.
jobLocation	no	Location or remote policy, e.g. Remote - US, used for location eligibility.
jobCompany	no	Company name, removed from the title if repeated there.

Files must be text-based PDF, DOCX or TXT, up to 5 MB; the first 10 pages of a PDF are read.

Output

The first row of a run with the prefilled example input (fictional candidate; some fields shortened):

{
  "id": "candidate-001", "source": "text",
  "name": "Alex Morgan", "email": "alex.morgan@example.com",
  "current_title": "Senior Backend Engineer", "current_company": "Acme Analytics",
  "total_experience_years": 9.4, "seniority": "senior", "function": "engineering",
  "highest_education_level": "bachelor",
  "skills": ["Python", "AWS", "Django", "Docker", "Kubernetes", "PostgreSQL"],
  "match_score": 100, "matched_skills": ["AWS", "Django", "Docker", "Kubernetes", "PostgreSQL", "Python"],
  "missing_skills": [],
  "match_reasons": ["6 of 6 skills named in the posting appear in the CV", "seniority matches (senior)",
                    "same function (engineering)", "9.4 years of experience meets the 5+ asked for",
                    "candidate in US, which the posting allows"]
}

A SUMMARY record in the run's key-value store lists how many resumes were parsed and which were skipped and why.

How is the match score calculated?

Component	Weight	Score
skills	0.45	Share of the posting's skills found in the CV
seniority	0.20	1.0 same level, 0.6 one step apart, 0.2 two steps, else 0
function	0.15	1.0 same, 0.75 same function but different specialty, else 0
experience	0.15	1.0 if years meet the posting's minimum, else years / minimum
location	0.05	1.0 if the CV's country is inside the posting's allowed countries or regions

A component with no data on either side is left out and the other weights are rescaled, so missing information never counts against the candidate.

How much does it cost?

It's pay per event: $0.005 per resume ($5 per 1,000), including the match score, plus a little Apify platform usage. Empty, unreadable (corrupt, encrypted, scanned) or unparseable inputs are skipped and not charged. If you set a maximum spend on the run, it stops when that limit is reached.

Privacy

Resume text, file URLs and parsed fields are never written to the run log; the log names only the position of a skipped input and the reason. The Actor sends nothing to any other service (it only downloads the file URLs you give it), and the results stay in your own Apify storage under your account's retention settings.

FAQ

How do I parse resumes in bulk into a spreadsheet? Put each CV's file URL (or its text) in resumes, run the Actor, and export the dataset as CSV or Excel. Each row is one candidate.

How do I rank candidates against a job description? Fill in jobTitle and jobDescription (and jobLocation if location matters). Every row gets a match_score from 0 to 100; sort by it and read missing_skills and match_reasons to see why.

Does it use ChatGPT or another LLM? No. It uses deterministic rules, so the same CV always gives the same result and there are no model costs or invented details.

Can it read scanned PDFs or photos of a CV? No, there is no OCR. A PDF without a text layer is skipped and not charged; send text-based PDFs, DOCX or plain text.

How accurate is it? On 15 fictional test CVs in different layouts (US, UK, skills-first, dates-first, two-column, no headings, junior, staff, career changer, nurse, sales, HR) it found the contact details, current title, experience entries and education in all 15. Known weak spots: when a title has no level word, seniority is inferred from years of experience; healthcare and other non-office roles get the function other; scanned PDFs are not read. It was tested on English-language CVs.

How does it compare with Affinda, Textkernel (Sovren) or RChilli? Those are full commercial parsers with broader language and document coverage; Affinda's self-serve price is $0.10 per document, and Textkernel and RChilli are sold by quote. This Actor is a low-cost, predictable option at $0.005 per resume that also scores the match.

Related

• Resume Parser + Job Match API: the same parser as a REST API, with monthly plans on RapidAPI.