Resume length check
The resume length check API answers one deceptively simple question: is this resume the right length for this candidate?
Run — free
Recruiters spend seconds on a first scan, and common guidance is blunt — one page for anyone under ten years of experience, two at most beyond that. Send a word count and a years-of-experience figure and you get back a clear verdict — too_short, appropriate or too_long — together with the recommended page and word limits, an estimated page count and a plain-language explanation. It is the same deterministic rule set recruiters quote, exposed as a single call you can drop into a job board, a CV builder or an applicant tracking system.
Why resume length still matters
Hiring research keeps repeating the same finding: recruiters give a resume a handful of seconds before deciding whether to read on. Length is the first filter they apply, often unconsciously. A two-page document from a candidate three years out of college signals poor judgement about what matters; a half-empty page from a senior engineer signals thin experience. The widely quoted rule of thumb is simple: one page if you have under ten years of professional experience, two pages maximum once you pass that mark, and never pad a resume just to fill space. Because a page of typical resume formatting holds roughly five hundred words, the rule translates cleanly into word counts — about five hundred and fifty words for junior and mid-level candidates, eleven hundred for senior ones, and a floor of around two hundred words below which any resume looks sparse. This resume length check encodes exactly that translation so you can apply it automatically, at scale, before a human ever sees the document.
How the verdict is computed
The check takes two numbers: the total word count of the resume and the candidate's years of professional experience. Years of experience must be zero or positive — a negative value is rejected as invalid input, since it can only come from a data-entry or parsing bug upstream. From there the logic is a deterministic lookup. Under ten years of experience the ceiling is one page, expressed as five hundred and fifty words to allow for denser formatting; at ten years or more the ceiling rises to two pages, or eleven hundred words. Independent of seniority, anything under two hundred words is flagged as too short. The response reports the verdict, the recommended minimum and maximum word counts, the recommended maximum pages, and the estimated page count of the submitted resume computed at five hundred words per page and rounded to two decimals. A human-readable advice string explains the verdict and, when the resume is too long, states exactly how many words to trim. Nothing is random and nothing calls a model: the same input always produces the same output.
Where to use it in a hiring pipeline
The most common integration is a CV builder or job board that wants to coach candidates before submission: run the check on save, show the verdict inline, and link to trimming guidance when the document runs long. Applicant tracking systems use it as a lightweight quality gate, tagging over-length resumes for review instead of rejecting them outright. Outplacement and career-coaching platforms batch it across their client base to prioritise who needs editing help first. Because the check is deterministic and stateless, it is safe to call on every keystroke-driven save and cheap enough to run across an entire talent pool nightly. The same code that answers the paid API runs free in the browser widget on this page, so candidates can test their own resumes without an account and you only pay when you automate the call. At $0.002 per request, screening ten thousand resumes costs about as much as a coffee — and the output is stable enough to store in an audit trail next to each application.
What you can do with it
Coach candidates inside a CV builder
Run the check whenever a user saves their resume and show the verdict inline, with concrete trimming advice when the document is too long for their experience level.
Quality gate in an applicant tracking system
Flag over-length or suspiciously thin resumes automatically so recruiters can focus on candidates whose documents pass basic hygiene.
Batch triage for career-coaching platforms
Score an entire client roster overnight and prioritise editing sessions for the candidates whose resumes need the most work.
FAQ
What does it cost?
$0.002 per request. It is also free to run in your browser on this page.
What inputs does it need?
Just two numbers: the resume's total word count and the candidate's years of professional experience. Years of experience must be zero or positive; a negative value is rejected as invalid input.
What are the length rules?
Under ten years of experience the ceiling is one page (about 550 words). At ten years or more it rises to two pages (about 1100 words). Anything under 200 words is flagged as too short.
Does it read the resume itself?
No. You supply the word count, so you stay in control of the document. The check only evaluates the length against the experience level.
Is the result deterministic?
Yes. The rule set is fixed and stateless — the same word count and years of experience always return the same verdict.
What does 'estimated_pages' mean?
It is the word count divided by 500 (a typical full resume page), rounded to two decimals, so you can reason in pages even though the input is in words.
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
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, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/life/resume-length-check \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"word_count":620,"years_experience":4}'const res = await fetch("https://api.kit.forhosting.com/life/resume-length-check", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"word_count": 620,
"years_experience": 4
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/resume-length-check",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"word_count": 620,
"years_experience": 4
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/resume-length-check", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"word_count":620,"years_experience":4}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"word_count":620,"years_experience":4}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/resume-length-check", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"word_count": 620,
"years_experience": 4
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.resume_length_check",
"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
Published price — no tokens, no invented credits. A failed task is never charged.
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. |