Words per slide budget
A 1,200-word script on 12 slides puts 100 words on each one, 60 over the usual 40-word ceiling. Enter the words and the slide count to see the density and how many slides would keep it concise, here 30. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Total words
- 1,200
- Slide count
- 12
- Max words per slide
- 40
- Words per slide
- 100
- Words per slide rounded
- 100
- Excess words per slide
- 60
Presenters, teachers, and pitch coaches who write a full spoken script before designing slides need a hard number for how many words each slide can carry without turning the deck into a wall of text. This words per slide budget tool divides total script words by slide count, returns the average words-per-slide budget, and optionally compares that average to a readability ceiling (forty words by default) so you know whether the deck is sparse, concise, moderate, dense, or overloaded. Enter twelve hundred script words and twelve slides and the planner reports about one hundred words per slide, flags the excess over a forty-word ceiling, and suggests roughly thirty slides if you want every card to stay concise. Zero or negative slide counts are rejected as invalid input so planners never divide by zero. Negative script word counts are likewise rejected; a zero-word script yields an empty budget for stubs.
How script words become a per-slide budget
Slide design guidance answers a simple planning question: if the spoken or written script will reach a fixed word total and the deck will have a chosen number of slides, how many words should each slide absorb if the text is spread evenly? A twelve-hundred-word keynote across twelve slides budgets one hundred words per slide; an eight-hundred-word classroom lecture across twenty slides budgets forty words per slide; a three-thousand-word training script across thirty slides budgets one hundred words per slide.
That average is the even-distribution budget you can pin next to each card before you write bullets. Density labels map the average into empty, sparse, concise, moderate, dense, or overloaded bands that match common presentation coaching (sparse near twenty words, concise near forty, moderate near sixty, dense near ninety, overloaded beyond that). Zero script words always map to an empty budget so stub decks do not claim a phantom word load.
When a words-per-slide budget helps
Pitch coaches and corporate training teams embed the free browser path so speakers turn a fifteen-minute script word count into a per-slide budget before they open the design tool. Teachers planning lecture decks recompute when a lesson grows from eight hundred to twelve hundred words and the slide count stays fixed, then either trim spoken prose or add slides to restore a concise density band. Event producers can preview that three thousand words on twelve slides is overloaded and reserve a longer deck or a handout for overflow prose.
Failed validation does not consume balance, which keeps exploratory scripts cheap when developers intentionally send a zero slide count. Prefer this capability when you already know the script length and slide count and only need the linear budget and density judgment; if you need automatic slide splitting of a document, OCR of an existing deck, or AI-written speaker notes, layer those tools outside this pure division.
What you can do with it
Pitch and keynote deck planning
Founders and coaches convert a full spoken script word count and a target slide count into a words-per-slide budget and density band before designing cards.
FAQ
How is density labeled?
empty (0), sparse (≤20), concise (≤40), moderate (≤60), dense (≤90), or overloaded (>90) average words per slide—bands aligned with common presentation coaching.
How many words should a slide have?
The default readability ceiling is 40 words per slide, a widely taught target for concise slides. You can set your own ceiling, and the result tells you whether your average stays at or under it.
How many slides do I need for my script?
Divide the script's words by the ceiling and round up. A 1,200-word script with a 40-word ceiling needs 30 slides, the number suggested whenever your current deck runs over the limit.
How far over the limit is my deck?
The result shows the excess per slide and for the whole deck. With 1,200 words on 12 slides you average 100 words, which is 60 too many on each slide and 720 extra words in total.
What happens if I enter zero slides?
Zero or negative slide counts are refused, because the words cannot be divided by zero. A negative word count is refused too, while a script of zero words simply gives an empty budget.
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/slides-words-budget \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"total_words":1200,"slide_count":12}'const res = await fetch("https://api.kit.forhosting.com/edu/slides-words-budget", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"total_words": 1200,
"slide_count": 12
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/edu/slides-words-budget",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"total_words": 1200,
"slide_count": 12
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/edu/slides-words-budget", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"total_words":1200,"slide_count":12}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"total_words":1200,"slide_count":12}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/edu/slides-words-budget", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"total_words": 1200,
"slide_count": 12
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "edu.slides_words_budget",
"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 script words become a per-slide budget
The core identity is words_per_slide equals total_words divided by slide_count. A separate readability ceiling (max_words_per_slide, default forty) judges whether that average still feels concise: within_budget is true when the average stays at or under the ceiling, excess_words_per_slide is how far each card sits above the ceiling, and total_excess_words scales that surplus across the whole deck. When the average is too high, recommended_slide_count equals the ceiling-based ceil of total_words over max_words_per_slide so you can grow the deck instead of cramming prose.
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 “slides”. POST a JSON body with two required finite numbers and one optional ceiling. total_words (aliases words, word_count, script_words, n) is the non-negative total script words to distribute. slide_count (aliases slides, num_slides, deck_size, count) is the positive number of slides in the deck and must be strictly greater than zero. max_words_per_slide (aliases max_wps, ceiling, target_wps, budget_max) is an optional positive readability ceiling in words per slide; when omitted the service uses forty, a widely taught concise-slide target. 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 total_words, slide_count, and max_words_per_slide; sets words_per_slide to the exact ratio after fixed twelve-decimal rounding; words_per_slide_rounded to the nearest integer for calendar labels; within_budget to whether the average stays at or under the ceiling; excess_words_per_slide and total_excess_words to non-negative surplus figures; recommended_slide_count to how many slides would keep the average under the ceiling (zero when the script is empty); density to the band label; formula to the documented identity; method equal to script_words_over_slide_count; and message to a short English summary for UI badges. Validation failures—missing fields, non-finite numbers, values outside absolute limits, a negative word count, a zero or negative slide count, or a zero or negative ceiling—return invalid_input and are not billed. Pricing is a fixed $0.002 per successful call with unit item.
Where a words-per-slide budget API earns its keep
LMS plugins and presentation generators call the same pure module when a student sets a two-thousand-word talk and a twenty-slide outline, then recompute recommended_slide_count when the coach tightens the ceiling from forty words to thirty.
Integration use cases
Lecture and training outline checks
Teachers recompute per-slide load when a lesson script grows, then raise slide_count or trim prose so the deck stays concise under a chosen ceiling.
LMS and presentation generators
Course platforms call the pure budget API when students set script length and deck size, then surface recommended_slide_count when the average exceeds the readability ceiling.
Technical questions
How is the words per slide budget calculated?
Send total_words (non-negative) and slide_count (positive). The API returns words_per_slide = total_words / slide_count, plus a rounded integer, density band, and optional comparison to max_words_per_slide (default 40).
What does max_words_per_slide control?
It is the readability ceiling used for within_budget, excess_words_per_slide, total_excess_words, and recommended_slide_count. Omit it to use the default of 40 words per slide.
What happens if slide_count is zero or negative?
The task fails with invalid_input. A non-positive slide count cannot divide a script into a per-slide budget and is not billed.
What does the words per slide budget calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.