Script reading time by WPM
Script length is easier to plan when a word count becomes an understandable duration.
Run — free
This calculator estimates how long a script takes to read silently or deliver aloud, using either your own words-per-minute rate or a practical default for the selected mode. It also shows both silent and spoken benchmarks, making the difference visible at a glance. Use it for lessons, presentations, videos, podcasts, speeches, voice-over work, rehearsals, or any workflow where timing matters before recording or presenting begins.
Choose the timing mode that matches the real task
Silent reading and spoken delivery are different activities, so one universal words-per-minute figure can produce a misleading schedule. Silent readers can move quickly, skip familiar transitions, and recognize groups of words without articulating every sound. A presenter or narrator must pronounce the text, breathe, emphasize key points, and leave enough space for the audience to follow. Select silent mode when estimating review, proofreading, study, or private rehearsal. Select spoken mode for speeches, classroom delivery, narration, voice-over, podcasts, video scripts, and presentations. When you do not provide a custom rate, the calculator uses 238 WPM for silent reading and 150 WPM for spoken delivery. Those defaults are planning benchmarks, not claims about every reader. The response always includes both benchmark durations, even when you choose a custom speed, so you can see how the same word count behaves in each context. This comparison is especially useful when a script must first be reviewed privately and then performed aloud. It prevents a fast silent read from being mistaken for the final running time.
Use word count and WPM to produce a dependable estimate
Enter the script's word count, select silent or spoken mode, and optionally supply a positive WPM value measured from the intended reader. The core calculation is deliberately transparent: words divided by words per minute gives minutes. The result includes decimal minutes, rounded total seconds, and a clock-style duration that is convenient for production notes. For the most useful custom rate, time a representative sample rather than a single unusually easy paragraph. Read in the same style the final script requires, including ordinary pauses and natural emphasis, then divide the sample's word count by elapsed minutes. A speaker who delivers 300 words in two minutes has a measured rate of 150 WPM. Reusing that rate for later drafts gives a more personal forecast than a general benchmark. The calculator remains deterministic: identical inputs always return identical outputs, with no network request, randomness, or hidden language model judgment. It estimates continuous reading time only. Planned demonstrations, audience questions, slide changes, music, dramatic silence, applause, or editing transitions should be budgeted separately after the reading estimate is known.
Turn the estimate into a practical script revision
Treat the calculated duration as a baseline for editing and rehearsal. If a spoken script exceeds its slot, compare the allowed time with the current estimate before cutting material. At 150 WPM, removing 150 words reduces continuous delivery by about one minute; at another custom speed, use that speed as the corresponding words-per-minute target. Do not solve every overrun by telling the speaker to rush. Faster delivery can reduce clarity, weaken emphasis, and make technical or unfamiliar material harder to absorb. Instead, remove repetition, shorten transitions, simplify dense sentences, or move secondary detail into supporting material. If the script fits too comfortably, the spare time can support purposeful pauses, examples, interaction, or a calmer pace. For recordings, compare the estimate with the desired finished duration and then add known non-speech segments. For live events, include a buffer because room response and speaker variation rarely match a clean rehearsal exactly. Save the word count, chosen mode, WPM, and returned clock time with the draft so collaborators understand the assumption behind the schedule. Recalculate after meaningful edits; even a polished estimate becomes stale when the script changes.
What you can do with it
Plan a video or podcast
Estimate narration length before recording and reserve separate time for music, transitions, or demonstrations.
Fit a speech into its slot
Convert the current draft into a spoken duration and identify how many words need to be cut.
Compare review and performance time
See how quickly a script may be read silently versus how long clear delivery is likely to take.
FAQ
What does the calculation cost?
The API price is $0.002 per request, and the calculation uses one item.
What are the default reading speeds?
The defaults are 238 WPM for silent reading and 150 WPM for spoken delivery.
Can I use my own WPM?
Yes. Supply any finite positive WPM value, ideally measured from the intended reader using a representative sample.
Does spoken time include pauses or slide changes?
No. It estimates continuous delivery from word count and WPM; add planned non-speech time separately.
Why is spoken delivery usually slower than silent reading?
Speech requires articulation, breathing, emphasis, and listener-friendly pacing, while silent readers can process text without pronouncing it.
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/script-reading-time \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"word_count":900}'const res = await fetch("https://api.kit.forhosting.com/edu/script-reading-time", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"word_count": 900
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/edu/script-reading-time",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"word_count": 900
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/edu/script-reading-time", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"word_count":900}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"word_count":900}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/edu/script-reading-time", 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": 900
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "edu.script_reading_time",
"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. |