Binge-watching calculator
Ten 45-minute episodes at 1.5× speed take 5 hours, a little over a fifth of a day. Enter the episodes left, how long each one runs and your playback speed to see the total in hours and in 24-hour days. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Episodes
- 10
- Episode minutes
- 45
- Speed
- 1.5
- Total minutes
- 300
- Hours
- 5
- Days
- 0.2083333333
Binge-watching a series is a time-budget problem: multiply the episode count by each episode's length, then divide by the playback speed you will actually use. Before you start a new season on a Friday night you need to know whether you are looking at a single evening, a full weekend, or the better part of a week. This binge-watching calculator accepts three positive finite numbers — how many episodes remain, how many minutes each episode runs, and the playback speed — and returns the total watch time in hours and in 24-hour days. A ten-episode season of forty-five-minute episodes at one-and-a-half times speed is five hours, a little over two-tenths of a day.
How binge-watch hours and days are computed from three numbers
The identity is the same one every streaming player uses internally. Gross runtime in minutes is the episode count multiplied by the length of one episode in minutes. Watch time in minutes is that product divided by playback speed.
Hours are watch minutes divided by sixty. Days are hours divided by twenty-four, using a continuous twenty-four-hour day rather than a civil calendar or a bedtime cutoff. Playback speed is a positive multiplier: 1.0 is the original soundtrack, 1.25 and 1.5 are the common settings people use to finish a season faster, and 2.0 halves the clock.
A value below 1.0 — slow motion, language study, or a restored frame rate — lengthens the watch, which is why the field is not clamped to at least one. Fractional episode counts are accepted because leftover half-episodes, recap specials, and two-part finales are real; the arithmetic does not force an integer.
Where a binge-watching calculator earns its keep
Households planning a weekend marathon need hours so they can leave room for meals and sleep, and they need days so a twelve-hour prestige limited series is not mistaken for one night. Streaming recap writers and editors building an air-date calendar need a deterministic conversion from episode count and runtime to a wall-clock budget they can pin in a spreadsheet. Students learning a language at 0.75x need the same formula with a speed below one, not a tool that silently refuses anything other than 1x or 2x.
Club programmers and hospitality teams running a themed movie night can turn a stack of episodes into a start-to-finish clock without opening a calculator app for every title. Keep all three inputs positive and finite, pin hours and days in your tests, and you get a reproducible watch budget for a Friday-night plan, an editorial calendar, a language-lab worksheet, or an edge worker without standing up a streaming catalogue of your own.
What you can do with it
Plan a weekend series marathon
Turn a ten-episode, forty-five-minute season at 1.5x into five hours so you know whether Friday night is enough or you need Saturday too.
Compare 1x, 1.5x, and 2x playback
Keep the same episode count and length, change only speed, and see how much wall-clock time a faster soundtrack actually saves.
Editorial calendars and recap desks
Convert a season bible of episode counts and runtimes into hours and days a writer can block on a recap or live-tweet schedule.
FAQ
What is playback speed and how does it change the total?
Speed is a positive multiplier on the original soundtrack. 1.0 is real time, 1.5 shortens the watch by one third, 2.0 halves it, and a value below 1.0 (for example 0.75 for language study) lengthens it.
What happens if an input is zero, negative, or missing?
A binge with no episodes, a zero-length episode, or a zero playback speed is not a watch, and those failures are not billed.
Are episode lengths in minutes or hours?
Hours and days appear only in the result after the watch clock is converted.
Can I count half an episode or a two-part finale?
Yes. The episode count accepts decimals, because leftover half-episodes, recap specials and two-part finales are real. The calculation does not force you to round to a whole number of episodes.
Does it subtract skipped intros or opening credits?
No. It assumes you play every listed episode in full at one constant speed. If you usually skip the intro, your real viewing time will be a little shorter than the result.
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/life/binge-watching \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"episodes":10,"episode_minutes":45,"speed":1.5}'const res = await fetch("https://api.kit.forhosting.com/life/binge-watching", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"episodes": 10,
"episode_minutes": 45,
"speed": 1.5
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/life/binge-watching",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"episodes": 10,
"episode_minutes": 45,
"speed": 1.5
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/life/binge-watching", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"episodes":10,"episode_minutes":45,"speed":1.5}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"episodes":10,"episode_minutes":45,"speed":1.5}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/life/binge-watching", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"episodes": 10,
"episode_minutes": 45,
"speed": 1.5
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "life.binge_watching",
"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.
Limits
max_episodes | 1000000 |
max_episode_minutes | 1000000 |
max_speed | 100 |
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
Zero, negative, missing, or non-finite inputs fail with invalid_input and are not billed. Use the page in your browser at no charge, or call the API at $0.002 per successful request when a spreadsheet, editorial calendar, or coaching worksheet needs the identical figure.
How binge-watch hours and days are computed from three numbers
The response echoes the cleaned episodes, episode_minutes, and speed, then returns total_minutes, hours, and days, plus a formula string that restates the identity so a user interface can show the rule next to the number. This endpoint does not fetch episode lists from a catalogue, does not subtract opening-credit skips, and does not apply time zones. It answers one question: if you sit down and play every listed episode at a constant speed, how many hours and how many twenty-four-hour days is that watch.
Input contract, playback speed, response fields, and validation errors
Errors always name the canonical field so the web form can mark the right control. Zero and negative values fail because a binge with no episodes, a zero-length episode, or a zero playback speed is not a watch — and a zero speed would be a division by zero. Magnitudes above the documented ceilings fail so a typo cannot blow the isolate. A familiar check is ten episodes of forty-five minutes at speed 1.5, which yields three hundred watch minutes, five hours, and 0.208333333333 days. A twenty-four-episode half-hour sitcom at 1x is five hundred twenty-eight minutes, 8.8 hours, and 0.366666666667 days. POST a JSON body with three required positive finite numbers: episodes, the count of episodes you will watch; episode_minutes, the runtime of one episode in minutes; and speed, the playback multiplier. Aliases episode_count, n, and count are accepted for episodes; minutes, episode_length, length, and duration for episode_minutes; and playback_speed, playback, and rate for speed. Each field may arrive as a JSON number or as a numeric string; booleans, objects, empty strings, NaN, and Infinity fail with invalid_input. On success the body includes the echoed inputs, total_minutes as the watch clock, hours as total_minutes divided by sixty, days as hours divided by twenty-four, and a formula string. Missing fields and non-positive values are invalid_input and are not billed. Successful API calls use the published $0.002 base price; the free browser path runs the same solve function without consuming prepaid balance.
Technical questions
How do I calculate how long it takes to binge-watch a series?
Send three positive numbers: episodes, episode_minutes, and speed. The API returns total_minutes = episodes × episode_minutes / speed, then hours = total_minutes / 60 and days = hours / 24.
What does the binge-watching calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.