Estimate page count from text
At 250 words per page, a 500-word essay fills exactly 2 pages and a 750-word chapter fills 3. Paste your text, change the words per page if your layout differs, and get the exact pages plus the whole pages to print. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Writers, students, agents, and production editors constantly ask the same planning question: how many printed pages will this draft fill once it is double-spaced, set in a standard manuscript font, or laid out for a short essay booklet? This page-count estimator answers that question with a transparent arithmetic model. Paste your plain text, optionally set how many words fit on one of your pages, and receive a deterministic word total, exact fractional pages, and a whole-page ceiling you can use for print quotes, workshop submissions, and chapter packing. The default density of two hundred fifty words per page mirrors the familiar double-spaced manuscript rule of thumb, while custom densities cover single-spaced reports, dense academic layouts, and large-print editions. Empty input and non-positive densities fail with clear validation errors instead of inventing infinite or zero-cost nonsense.
Where page estimates show up in real writing and print workflows
Novelists and short-story writers convert draft length into approximate manuscript pages before querying agents who still quote limits in pages rather than pure word counts. Students and teachers check essay and thesis page targets under a shared density so a ten-page assignment means the same thing in every section. Self-publishers and small presses estimate booklet signatures and paper orders from chapter word totals without opening a full desktop layout suite.
Content marketers planning printed leave-behinds or conference handouts map blog-length copy onto a fixed page budget. Curriculum designers pack reading packets so each night’s homework stays within a page range parents can plan around. Data engineers cleaning free-text columns sometimes store estimated pages as a derived metric for capacity dashboards when content later ships to print.
If you later need raw word and character totals, reading-time badges, PDF page stats from a binary file, or grade-level scores, treat those as separate search intents and landings rather than overloading this estimate-page-count-from-text page.
What you can do with it
Manuscript and novel page planning
Convert chapter drafts into approximate double-spaced manuscript pages at 250 words per page before agent queries or workshop submissions.
Essay and thesis page limits
Students and teachers share one density so a ten-page assignment is checked the same way in browser demos and bulk grading scripts.
Print quotes and booklet packing
Self-publishers and marketing teams map plain-text copy onto whole-page ceilings for paper orders and fixed-length leave-behinds.
FAQ
What is the default words-per-page value?
Override it for single-spaced, academic, or large-print layouts.
Does this measure real PDF layout, fonts, or images?
No. It is a transparent words-per-page model for planning. For binary PDF page stats use a dedicated PDF capability; for reading duration use a reading-time estimator.
What does it cost?
The browser tool is free and runs locally.
Why does the result show two page counts?
One is the exact fraction and the other is rounded up to whole pages. A 29-word paragraph is 0.116 pages, yet it still occupies 1 printed page, which is the number printers and binders work with.
How are words counted?
A word is any run of characters between spaces, tabs or line breaks, as in the status bar of most editors. Hyphenated compounds count as one word, and repeated spaces never add extra 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/str/estimate-page-count \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"Once upon a time there was a careful writer who planned every chapter before printing. The draft grew through mornings of revision until the story filled several manuscript pages."}'const res = await fetch("https://api.kit.forhosting.com/str/estimate-page-count", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "Once upon a time there was a careful writer who planned every chapter before printing. The draft grew through mornings of revision until the story filled several manuscript pages."
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/estimate-page-count",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "Once upon a time there was a careful writer who planned every chapter before printing. The draft grew through mornings of revision until the story filled several manuscript pages."
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/estimate-page-count", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"Once upon a time there was a careful writer who planned every chapter before printing. The draft grew through mornings of revision until the story filled several manuscript pages."}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"Once upon a time there was a careful writer who planned every chapter before printing. The draft grew through mornings of revision until the story filled several manuscript pages."}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/estimate-page-count", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "Once upon a time there was a careful writer who planned every chapter before printing. The draft grew through mornings of revision until the story filled several manuscript pages."
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.estimate_page_count",
"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 printed page count is estimated from text and words per page
The engine first counts words as non-empty tokens separated by Unicode whitespace, matching the status bar in most editors and online counters. Hyphenated compounds count as one word, and runs of spaces, tabs, or newlines collapse into a single separator. A five-hundred-word essay at two hundred fifty words per page is exactly two pages; a seven-hundred-fifty-word chapter at the same density is three pages; a three-thousand-word short story at three hundred words per page is ten pages. Because the path is pure parse arithmetic over strings, latency stays sub-millisecond for typical form sizes and the published cost model is analytic rather than model-token based. It then divides that word total by your words-per-page density: pages equals word_count divided by words_per_page. The response also returns pages_ceil, the smallest whole number of pages that still covers the draft, which is what printers and binders care about when you cannot ship a fraction of a sheet. When the division lands on an integer, pages and pages_ceil agree; when it does not, pages keeps the fractional remainder and pages_ceil rounds up so you never under-order paper. Extremely long payloads above the documented character cap fail with invalid_input so a single request cannot monopolize Worker memory.
What you send, defaults, and how to read the response
Send a required field named text containing the non-empty plain string of your manuscript, essay, report, or chapter. When you omit density, the engine uses two hundred fifty words per page—the common double-spaced, twelve-point manuscript convention used by agents and writing workshops. Zero or negative density is a hard error under the product contract because it would divide by zero or reverse the page model. Empty or whitespace-only text is rejected before any counters run and is not charged. Aliases such as input, value, data, s, message, string, content, and body are accepted when wiring older clients. Optionally send words_per_page as a finite positive number or numeric string; aliases include wpp, density, page_words, and words_page. On success the response returns word_count, words_per_page after stable rounding, pages as the exact quotient, pages_ceil as the whole-page plan figure, a human-readable formula string, method equal to words_per_page, and operation equal to estimate_page_count. Use pages when you need fractional progress bars or chapter packing math; use pages_ceil when you order paper, quote print jobs, or enforce a hard page limit that cannot be fractional. Pricing for successful API calls is the published base of $0.002 per item; validation failures including empty text and non-positive density do not consume prepaid balance.
Where page estimates show up in real writing and print workflows
Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.
Technical questions
How is page count estimated from my text?
Words are counted as non-empty whitespace-separated tokens, then divided by words_per_page. The response includes exact pages and pages_ceil for whole printed sheets.
What happens if words_per_page is zero or negative?
The request fails with invalid_input. Non-positive density is rejected under the product contract and is not charged.