ForHosting KIT · OCR & Data Extraction

Parse a CV

A resume is a wall of prose that hiring software can't search, filter or rank until someone retypes it. This endpoint reads the CV as a person would and hands back structured candidate data — name, contact details, work history, education, skills — in seconds, not minutes.

● StablePer request + per document$0.003

Run — $0.003 + $0.0135/document How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Run it online

Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.

Built for the pile, not the exception

Recruiters and ATS vendors rarely deal with one resume; they deal with hundreds arriving daily in every layout imaginable — two-column designer templates, plain text exports, scanned photocopies from a walk-in applicant. This endpoint is built for that pile. It doesn't assume a single format; it reads the document the way a recruiter's eye does, following headings and grouping like a human, then normalizes what it finds into a stable schema your database can trust.

What actually happens to the file

You send a resume file to POST /ocr/resume and get back a task_id immediately because the job runs asynchronously. When parsing finishes, you receive the extracted candidate profile through a signed webhook, or you can fetch it from a signed link that stays valid for 24 hours. Nothing sits around waiting for a browser tab to poll — your system just gets notified.

From typewritten pages to searchable JSON

The resume as a genre has barely changed in a century — name, experience, education, contact — but the containers keep multiplying: PDF exports from design tools, Word documents with tables, LinkedIn profile downloads, even phone photos of a printed copy. Reliable extraction means handling that variety without asking the candidate to reformat anything, which is exactly the layer this API exists to provide.

Where it slots into your pipeline

Feed it straight from your application form, your email intake, or a bulk upload of an old filing cabinet's worth of PDFs. The output maps cleanly onto typical applicant-tracking fields, so the next step — deduplication, keyword search, ranking against a job requisition — runs on structured data instead of regex guesses against raw text.

Pricing that matches the work

Each call costs $0.003 per request plus $0.0135 per document, billed only when parsing actually succeeds; a failed attempt is retried automatically up to three times and, if it still fails, you get a clear error and no charge. There's no free tier and no trial period by design — access requires prepaid balance, which keeps the endpoint fast and free of throwaway abuse traffic.

What you can do with it

ATS intake automation

Auto-populate candidate records the moment an applicant uploads a CV, instead of asking a recruiter to copy-paste each field by hand.

Bulk resume database migration

Convert a folder of thousands of legacy PDF resumes into structured rows for a new applicant tracking system in a single batch.

Skill-based candidate search

Extract normalized skills and job titles so recruiters can filter candidates by criteria instead of scrolling through raw documents.

Staffing agency screening

Parse incoming resumes from multiple job boards into one consistent format before they ever reach a human recruiter's inbox.

FAQ

What does the resume parser API return?

A structured JSON profile with contact information, work history, education, skills and dates extracted from the uploaded CV.

Which file formats can I upload?

Standard resume documents including PDF, Word files and scanned or photographed pages; the endpoint reads the layout regardless of the export tool used.

Is there a free tier for the resume parser api?

There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.

How do I get the parsed results?

Through a signed webhook when the async task finishes, or by fetching a signed link that stays valid for 24 hours.

Am I charged if parsing fails?

No. Failed tasks are retried automatically up to three times and are never billed; you only pay for a document that was successfully parsed.

Can I send resumes in bulk?

Yes, submit one request per document and each returns its own task_id, so you can process large batches concurrently.

How much does the resume parser api cost?

$0.003 per request plus $0.0135 per document processed, with published pricing and no hidden credits or tokens.

Does this endpoint work on scanned resumes?

Yes, it extracts text from scanned or photographed pages as well as native digital documents.

For developers — API access

Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.

API endpoint

POSThttps://api.kit.forhosting.com/ocr/resume

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/ocr/resume \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"input":"…"}'

const res = await fetch("https://api.kit.forhosting.com/ocr/resume", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "input": "…"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/ocr/resume",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "input": "…"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/ocr/resume", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => &#39;{"input":"…"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"input":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/ocr/resume", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "input": "…"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "ocr.resume",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.

Pricing

Per request$0.003

Per document$0.0135

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`max_mb`	25
`max_pages`	10

Errors

HTTP	Code	Meaning
`401`	`unauthorized`	Missing or invalid API key.
`402`	`insufficient_balance`	Your balance doesn't cover the task price.
`404`	`unknown_type`	That task type doesn't exist.
`429`	`rate_limited`	Too many requests. Use the webhook instead of polling.
`422`	`task_failed`	The task failed after 3 retries. You are never charged for it.

Read the full KIT documentation →