ForHosting KIT · Developer Utilities

Daily flashcard review load calculator

Estimate how much flashcard work is waiting before adding another batch of new material.

● BetaFree · in your browser

Use it from WebAPIEmailTelegramApp soon

Enter the number of new cards planned, the repetitions already due, the expected same-day repetitions for each new card, and your average answer time. The calculator separates new-card learning from scheduled review, then reports total repetitions, minutes, hours, and the share created by new cards. Add a daily time budget to see whether the plan fits and how many new cards the remaining time can support.

Count repetitions instead of counting cards

A card is not always a single unit of work. A previously learned card that is due today usually creates one scheduled repetition, while a new card may appear several times during its first learning session. For that reason, enter due reviews as the number of repetitions shown by the deck for today and enter new cards separately. The repetitions-per-new-card setting should include the initial presentation and any expected same-day learning steps. For example, a value of three means that each new card is expected to be answered three times today, not three extra times after its introduction. Use a value that resembles the learning configuration and actual behavior of your study system. The calculator multiplies new cards by this setting, then adds the due repetitions. It does not predict future lapses, tomorrow's queue, or the scheduling behavior of a particular application. This narrow definition keeps the estimate transparent: every reported repetition can be traced directly to a supplied count or a stated assumption.

Turn the queue into a realistic time estimate

Estimate seconds per repetition from actual study sessions when possible. Include the time needed to read the prompt, recall an answer, reveal the response, and choose a grade. Do not include long breaks unless you deliberately want a calendar-time estimate rather than focused study time. The calculator applies the same average to new and due repetitions, which is a useful planning simplification but not a claim that every card is equally difficult. New cards, complex prompts, typed answers, and failed reviews may take longer. If those differences are substantial, run a conservative scenario with a slower average as well as an optimistic one. The result reports minutes and hours rounded to two decimal places, while all card and repetition counts remain whole numbers. It also reports the percentage of today's repetitions caused by new-card learning. A high new-work share is a clear signal that reducing new cards can quickly lower today's queue, even though existing due work remains unchanged.

Use a time budget to keep the deck manageable

Supplying a daily time budget adds a capacity check. The calculator compares estimated focused study time with that budget, reports the difference, shows utilization, and computes the maximum number of new cards that fit after the due queue is covered. That maximum uses the same repetition and speed assumptions as the main estimate and rounds down, so it never recommends a partial card. If due reviews alone consume the budget, the maximum is zero. Treat this result as a planning boundary, not as a guarantee: unexpected lapses and unusually difficult material can increase real study time. A negative budget difference identifies an overloaded plan, while a positive difference is spare estimated capacity. When a deck repeatedly exceeds the available time, first consider pausing or reducing new cards and clearing due work steadily. Avoid using the estimate as pressure to rush answers; response quality matters to spaced repetition. Revisit the average speed and repetitions-per-new-card assumptions after changing card format, learning steps, or subject difficulty. API requests cost $0.002, and the browser calculation uses the same deterministic arithmetic.

What you can do with it

Set a sustainable new-card limit

Compare the due queue with available study time before deciding how many new cards to introduce.

Plan a study session

Convert the visible queue into estimated repetitions, minutes, and hours for a daily schedule.

Compare deck settings

Test how different learning-step counts or answer speeds change the expected daily workload.

FAQ

Why can one new card create several repetitions?

A new card may be introduced and repeated through multiple same-day learning steps, so its first-day workload can exceed one answer.

Should the repetition setting include the first presentation?

Yes. Enter the total expected answers for each new card today, including its initial presentation.

Does this predict future review queues?

No. It estimates the current day's load from supplied counts and assumptions; it does not simulate future scheduling, retention, or lapses.

What happens if due reviews already exceed my time budget?

The result marks the plan as over budget and reports zero as the maximum new cards that fit after due work.

How much does an API calculation cost?

Each API request costs $0.002. The same deterministic calculation is also available in the browser.

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/edu/flashcard-review-load

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/flashcard-review-load \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"new_cards":20,"due_reviews":180}'

const res = await fetch("https://api.kit.forhosting.com/edu/flashcard-review-load", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "new_cards": 20,
    "due_reviews": 180
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/edu/flashcard-review-load",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "new_cards": 20,
    "due_reviews": 180
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/edu/flashcard-review-load", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"new_cards":20,"due_reviews":180}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"new_cards":20,"due_reviews":180}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/edu/flashcard-review-load", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "new_cards": 20,
  "due_reviews": 180
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "edu.flashcard_review_load",
  "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.002

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.

Read the full KIT documentation →