Vocabulary words to goal
If you know 2,500 words and aim for 5,000, you still have 2,500 to learn and you are 50 % of the way there. Enter what you know and your target to turn a vocabulary goal into a countable remainder that never drops below zero. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Known
- 2,500
- Target
- 5,000
- Words to learn
- 2,500
- Progress ratio
- 0.5
- Progress percent
- 50
Language learners, teachers, and product teams that ship spaced-repetition apps all face the same planning question: if you already know a few thousand words, how many more must you learn before you hit a published milestone such as five thousand, eight thousand, or ten thousand headwords. Guessing from a deck size or a CEFR brochure is noisy; a clear gap number turns a vague ambition into a countable study plan. This vocabulary words to goal calculator accepts your current known word count and a non-negative target size, subtracts them with a floor at zero so overshoot never invents a negative debt, and returns words still to learn together with a progress ratio and percent you can pin on a dashboard.
What words-to-goal measures and why the gap matters
A vocabulary goal is a target inventory size: the number of word families or lemmas you want to control for reading, exams, or daily conversation. Your known count is the inventory you already hold from study logs, SRS decks, or self-assessment. The difference between those two numbers is the learning debt that remains.
If the target is zero, the capability treats the goal as already satisfied and reports full progress rather than dividing by zero. None of these figures certify that you can use every word in fluent speech; they only answer the countable planning question how many more entries remain before your stated size. That answer is enough for weekly study quotas, content roadmaps that promise a milestone lexicon, and tutoring contracts that bill against remaining items rather than open-ended hours.
Where a vocabulary words to goal calculator earns its keep
Self-study learners use a vocabulary words to goal calculator when a textbook or CEFR guide names a headword target and their Anki or Memrise stats report a current known total; seeing the exact remainder turns motivation into a finite checklist. Classroom teachers and language schools set term-end vocabulary sizes and want students to enter two numbers rather than debate whether four thousand feels close enough to five thousand.
Curriculum designers building leveled readers need a deterministic oracle that says how many more lemmas a unit must introduce before a stated coverage goal. Validation failures do not consume balance. Use it wherever the product question is inventory remaining, not graded essay quality or lexical diversity of a pasted paragraph; those are different intents served by other tools.
What you can do with it
Personal SRS milestone planning
Enter your deck’s known-word total and a five-thousand or ten-thousand target to see exactly how many new cards remain before the milestone.
FAQ
What if I already know more words than my target?
The calculator never returns a negative learning debt.
Can known or target be zero?
Yes. Zero known with a positive target means the full target remains. A zero target is treated as already reached with full progress rather than a divide-by-zero error.
Does this analyze a text for unique words?
No. This tool only subtracts inventory counts. For distinct-versus-total word counts in a passage, use a unique words count calculator instead.
Does reaching my vocabulary target mean I am fluent?
No. The figures only count how many entries remain before the size you set; they do not certify that you can use every word in fluent speech. Treat the result as a study plan you can count.
Where do I get the number of words I already know?
Use the total from your study log, your flashcard deck statistics or an honest self-assessment. Count the same way for both numbers, for example word families or headwords, so the remainder compares like with like.
Related tools
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/edu/vocab-words-to-goal \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"known":2500,"target":5000}'const res = await fetch("https://api.kit.forhosting.com/edu/vocab-words-to-goal", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"known": 2500,
"target": 5000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/edu/vocab-words-to-goal",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"known": 2500,
"target": 5000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/edu/vocab-words-to-goal", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"known":2500,"target":5000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"known":2500,"target":5000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/edu/vocab-words-to-goal", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"known": 2500,
"target": 5000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "edu.vocab_words_to_goal",
"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. |
Technical notes
Failed validation is not billed; successful calls use the published $0.002 base price with no model tokens and no outbound network.
What words-to-goal measures and why the gap matters
When known sits below target, words_to_learn equals target minus known and grows or shrinks only when either input changes. When known already meets or exceeds target, the debt is zero and the response flags already_reached so progress bars can show completion without a negative remainder. Dividing known by target yields progress_ratio on a zero-to-one scale; multiplying by one hundred yields progress_percent for UI labels.
Input contract, response shape, and error behaviour
Example: known equals two thousand five hundred and target equals five thousand yields two thousand five hundred words still to learn, a progress ratio of one half, and progress percent of fifty. Keep requests to the two counts you care about, pin the rounded fields in tests, and you get reproducible goal arithmetic without standing up a full lexicography pipeline. POST a JSON body with two required finite non-negative numbers: known, how many vocabulary words you already know, and target, the size you want to reach. Aliases current, known_words, current_words, and vocabulary map to known; goal, target_words, and goal_words map to target so form builders and SDKs can keep familiar labels. Values may arrive as JSON numbers or as numeric strings; missing fields, empty strings, non-finite values, negatives, and magnitudes above one billion fail with invalid_input naming the field and are not billed. On success the body echoes known and target after stable rounding, returns words_to_learn as max of zero and target minus known, progress_ratio and progress_percent (capped at full completion when the goal is already met or the target is zero), already_reached as a boolean, a short formula string, a human-readable message, and method set to vocab_words_to_goal. Pair the gap with your own daily review rate if you need calendar estimates; this endpoint computes inventory remaining only and does not invent study schedules, difficulty weights, or frequency ranks.
Integration use cases
Classroom term vocabulary goals
Teachers set a term-end target size; students check words_to_learn weekly so progress talks stay numeric instead of vague.
App and LMS progress dashboards
Products call the API with stored known and goal fields to fill remaining-words widgets that match the free browser calculator.
Technical questions
How does the vocabulary words to goal calculator work?
Send non-negative known and target counts. The API returns words_to_learn = max(0, target − known), progress_ratio, progress_percent, and already_reached when known is already at or above the target.
What does the vocabulary words to goal calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.