Next spaced repetition interval calculator
The next spaced repetition interval calculator turns a learner's previous review gap and current ease factor into the next scheduled gap in days.
Run — free
It applies the familiar multiplication rule used by simple spaced repetition systems, then rounds the result to the precision you choose. The output is deterministic and includes the inputs and formula, making it suitable for study tools, flashcard schedulers, spreadsheets, and auditable learning workflows. No account, network lookup, clock, or hidden learner profile is required to calculate one interval.
Enter the previous interval and ease factor
Start with the number of days that separated the learner's two most recent scheduled reviews. Enter that value as previous_interval_days. It may be a whole number, such as 6, or a fractional number when your application schedules at finer granularity. Then provide ease_factor, the multiplier chosen by your learning system after the latest review. A factor above 1 lengthens the gap, while a factor below 1 shortens it. For example, an interval of 6 days and an ease factor of 2.5 produce 15 days before rounding. Both values must be finite and positive. The calculator intentionally does not infer an ease factor from a grade, button press, lapse count, or response time, because those rules differ among study systems. It performs one transparent scheduling step with values your application has already selected. This separation makes the result easy to reproduce in an SDK, spreadsheet, test fixture, or queue worker without copying an entire flashcard algorithm or relying on undocumented defaults.
Understand multiplication and rounding
The calculation is previous_interval_days multiplied by ease_factor. After multiplication, the result is rounded to decimal_places, which defaults to 2 and can range from 0 through 6. Choose 0 when your scheduler stores only whole calendar days; choose a higher precision when another layer converts fractional days into hours or timestamps. Rounding happens once, after multiplication, so intermediate truncation cannot quietly shorten a long learning plan. The response repeats previous_interval_days, ease_factor, decimal_places, and the formula alongside next_interval_days. Those fields make logs self-explanatory and help reviewers distinguish a scheduling decision from a display conversion. The calculator does not force a minimum one-day interval: a small valid product can remain below one day when decimal precision allows it. It also does not add bonuses, caps, fuzz, overdue adjustments, or special first-review steps. If your product uses those policies, apply them explicitly before or after this calculation and record that policy separately. Identical JSON input always returns identical JSON output.
Use the result in a durable review workflow
Treat next_interval_days as a scheduling interval, not as a calendar date. A calling application can add it to the completion time of the latest successful review, while deciding for itself how to handle time zones, weekends, missed sessions, or daily cutoffs. This capability never reads the current date, which prevents the same request from changing merely because it ran later. In a flashcard service, store the returned interval with the rating and ease factor that produced it; that small audit trail makes future schedule changes explainable. In a classroom dashboard, calculate intervals in a batch only after validating that each learner record contains the intended prior interval and factor. In a spreadsheet migration, compare the returned formula fields with existing columns before replacing legacy values. The browser version is useful for manual checks, and the API costs $0.002 per successful item when automation needs the same deterministic contract. Validation failures clearly identify the unsupported field and should be corrected rather than silently substituted with a default learning policy.
What you can do with it
Schedule a flashcard review
Multiply a card's stored interval by the ease factor selected after a successful recall, then save the returned interval for the next scheduling step.
Check a study spreadsheet
Recalculate selected rows with explicit rounding and compare the results with formulas maintained in a curriculum or learner-tracking workbook.
Test a learning application
Use deterministic outputs as fixtures when verifying that a scheduler passes the correct prior interval and ease factor between services.
FAQ
What formula does the calculator use?
It calculates previous_interval_days multiplied by ease_factor, then rounds the product to decimal_places.
Does it calculate an ease factor from a review grade?
No. Supply the ease factor selected by your own grading or scheduling policy; this capability performs only the interval multiplication step.
Can the next interval be less than one day?
Yes. Positive fractional intervals are preserved when the chosen decimal_places setting has enough precision to represent them.
How is the result rounded?
The product is rounded once to 0 through 6 decimal places. The default is 2 decimal places.
Does the calculator choose a review date?
No. It returns an interval in days and does not read the clock. Your application can add that interval to its chosen review completion time.
What does the API request cost?
Each successful API item costs $0.002. The same deterministic calculation can also run 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
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/next-spaced-interval \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"previous_interval_days":6,"ease_factor":2.5}'const res = await fetch("https://api.kit.forhosting.com/edu/next-spaced-interval", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"previous_interval_days": 6,
"ease_factor": 2.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/edu/next-spaced-interval",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"previous_interval_days": 6,
"ease_factor": 2.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/edu/next-spaced-interval", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"previous_interval_days":6,"ease_factor":2.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"previous_interval_days":6,"ease_factor":2.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/edu/next-spaced-interval", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"previous_interval_days": 6,
"ease_factor": 2.5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "edu.next_spaced_interval",
"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. |