Pause-adjusted speech duration
A 300-word talk at 150 words per minute is 120 seconds of speech, but 15 sentences with half-second pauses add 7.5 seconds, for 2 minutes 7.5 seconds on the clock. Enter words, sentences, rate and pause to time a script that breathes. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Word count
- 300
- Sentence count
- 15
- Words per minute
- 150
- Pause seconds
- 0.5
- Spoken seconds
- 120
- Pause total seconds
- 7.5
Speakers, teachers, and event producers who time a script from word count alone systematically undershoot the clock because they omit the silence between sentences. This pause-adjusted speech duration calculator adds a fixed pause after every sentence to the base spoken time from word count and speaking rate, so a three-hundred-word talk at one hundred fifty words per minute is one hundred twenty seconds of speech plus seven and a half seconds of pause when fifteen sentences each rest for half a second. Enter word count, sentence count, an optional words-per-minute rate (default one hundred fifty), and an optional pause in seconds per sentence (default one half). Zero or negative speaking rates are rejected as invalid input so planners never divide by zero. Negative word counts, sentence counts, and pauses are likewise rejected.
How pause-adjusted speech duration is computed
Spoken time from word count alone is the continuous-delivery estimate used by every naive speech timer: divide the word count by the speaking rate in words per minute and multiply by sixty to obtain spoken seconds. That identity is necessary but not sufficient for a talk that actually pauses. Human speakers mark clause and sentence boundaries with silence—a breath, a beat for the audience, a slide change—so a script timed only on spoken words finishes early and then stretches when the presenter honors punctuation.
A three-hundred-word script at one hundred fifty words per minute occupies one hundred twenty spoken seconds; fifteen sentences at half a second each add seven and a half seconds, for one hundred twenty-seven and a half seconds total, or two minutes and seven and a half seconds on the clock. A nine-hundred-word lecture at one hundred eighty words per minute occupies three hundred spoken seconds; forty sentences at three-quarters of a second add thirty seconds of rest, for five and a half minutes.
Zero sentences contribute zero pause so a word list or run-on still has a defined spoken time. Zero words with a positive sentence count is silence-only pause time, which is valid for a timed rest.
Who times talks with sentence pauses
Speech coaches and TED-style speakers embed the free browser path so a draft word count and sentence count become a clock time before they book a slot that cannot overrun. Teachers planning oral presentations recompute when a student adds twenty sentences of rhetorical questions and the pause load grows even though the word count barely moves. Conference producers compare two speakers at different rates: a fast one-hundred-eighty-word-per-minute delivery on the same nine-hundred-word script finishes sooner in spoken time but may still fill the slot once sentence pauses are added.
LMS plugins and rehearsal apps call the same pure module when a student sets a word count and a sentence count, then recompute when the coach slows the target rate from one hundred fifty to one hundred twenty words per minute. Event producers can preview that three hundred words at one hundred fifty words per minute plus fifteen half-second pauses is just over two minutes and reserve a slightly longer slot. Failed validation does not consume balance, which keeps exploratory scripts cheap when developers intentionally send a zero speaking rate.
Prefer this capability when you already know the word count, sentence count, and speaking rate and only need the linear spoken-plus-pause identity; if you need automatic transcription, forced alignment, or measured silence from a recording, layer those tools outside this pure arithmetic.
What you can do with it
Keynote and TED-style slot planning
Speakers convert a draft word count and sentence count into a pause-adjusted clock time before booking a slot that cannot overrun.
Classroom oral presentations
Teachers recompute duration when a student adds sentences—and therefore pauses—even if the word count barely changes, then coach rate or length.
FAQ
How is pause-adjusted speech duration calculated?
Defaults are 150 words per minute and 0.5 seconds of pause per sentence.
What is the default speaking rate and sentence pause?
Override either field to model a faster speaker or a longer dramatic rest.
Why does my speech run longer than the word count suggests?
Because a plain word-count timer ignores the silence between sentences. Every breath, beat or slide change adds time, so 15 sentences resting half a second each turn 120 seconds of speech into 127.5 seconds.
How do I time the same script for a faster or slower speaker?
Change only the speaking rate. The spoken part grows or shrinks with the rate, while the pause time stays the same because it depends on the number of sentences, not on how fast the words come.
Does adding sentences change the time if the word count barely moves?
Yes. Each sentence brings its own pause, so splitting long sentences or adding rhetorical questions raises the total even when the script has almost the same number of words.
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/pause-adjusted-speech \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"word_count":300,"sentence_count":15}'const res = await fetch("https://api.kit.forhosting.com/edu/pause-adjusted-speech", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"word_count": 300,
"sentence_count": 15
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/edu/pause-adjusted-speech",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"word_count": 300,
"sentence_count": 15
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/edu/pause-adjusted-speech", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"word_count":300,"sentence_count":15}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"word_count":300,"sentence_count":15}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/edu/pause-adjusted-speech", 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": 300,
"sentence_count": 15
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "edu.pause_adjusted_speech",
"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
How pause-adjusted speech duration is computed
This calculator adds a uniform pause after every sentence: pause_total_seconds equals sentence_count times pause_seconds (default one half second per sentence). The pause-adjusted duration is spoken_seconds plus pause_total_seconds.
Input contract, response shape, and error behaviour
Prefer plain numbers over unit-suffixed strings; numeric strings are accepted only when they match a strict finite number pattern without commas or labels like “wpm”. POST a JSON body with two required finite numbers and two optional rate fields. word_count (aliases words, total_words, n) is the non-negative count of spoken words in the script. sentence_count (aliases sentences, n_sentences) is the non-negative count of sentences that will each receive a pause. words_per_minute (aliases rate, wpm, speaking_rate) is the positive speaking rate; when omitted the service uses one hundred fifty, a widely cited conversational and presentation rate. pause_seconds (aliases pause, pause_per_sentence, sentence_pause) is the non-negative pause after each sentence in seconds; when omitted the service uses one half second. Absolute values stay within one trillion so intermediate products remain finite in IEEE double precision on the Worker isolate and in the browser. On success the response echoes rounded word_count, sentence_count, words_per_minute, and pause_seconds; sets spoken_seconds to word_count divided by words_per_minute times sixty; pause_total_seconds to sentence_count times pause_seconds; total_seconds, total_minutes, and total_hours to the pause-adjusted duration in those units; clock_hours, clock_minutes, and clock_seconds to a clock breakdown of the same total; pause_share_percent to the fraction of total time spent in pause (zero when the total is zero); formula to the documented identity; method equal to pause_adjusted_word_rate; and message to a short English summary for UI badges. Validation failures—missing fields, non-finite numbers, values outside absolute limits, a negative word or sentence count, a zero or negative speaking rate, or a negative pause—return invalid_input and are not billed. Pricing is a fixed $0.002 per successful call with unit item.
Where a pause-adjusted speech duration API earns its keep
Podcast and video editors use the pause-adjusted total as a first-cut runtime before recording, then raise pause_seconds toward one second for documentary pacing.
Integration use cases
Podcast and LMS rehearsal tools
Editors and course platforms call the pure duration API to preview runtime from script stats, then raise pause_seconds for slower documentary pacing.
Technical questions
What happens if words_per_minute is zero or negative?
The task fails with invalid_input. A non-positive speaking rate cannot convert a word count into spoken seconds and is not billed.
Can sentence_count be zero?
Yes. Zero sentences add zero pause, so the result is the base spoken time from word count and rate only. Zero words with a positive sentence count is silence-only pause time.
What does the pause-adjusted speech duration calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.