ForHosting KIT · Documents & PDF

Booklet imposition sheets calculator

A saddle-stitched booklet is built from folded sheets, and each physical sheet contributes four finished pages: two on the front and two on the back.

● BetaFree · in your browser

Run — free How it works & API

Use it from WebAPIEmailTelegramApp soon

This calculator converts any positive page count into the number of sheets the booklet requires. When the count is not divisible by four, it rounds up to the next complete sheet and reports the blank pages that must be added. Use the result to plan imposition, estimate paper, and catch pagination problems before a file reaches production.

Count every page in the finished booklet

Start with the total number of pages a reader will turn through, not the number of PDF spreads and not the number of printed sides. Include the front cover, inside front cover, inside back cover, and back cover when they are part of the same saddle-stitched piece. Also include intentionally empty pages, title pages, copyright pages, advertisements, dividers, and any other numbered or unnumbered page. A page is one finished face after trimming and folding. This distinction matters because one press sheet has two sides, each side carries two imposed booklet pages, and the folded sheet therefore supplies four finished pages. Enter that complete count as total_pages. The calculator accepts whole numbers from one through one million. It also accepts pages as an API alias, although total_pages is the canonical field in documentation and generated clients. Keeping the count tied to the finished object prevents the common mistake of dividing a PDF’s spread count by four again or forgetting that covers consume four page positions too.

Understand rounding and blank pages

Saddle-stitch signatures must contain a multiple of four pages because no fraction of a folded sheet can be bound into the booklet. The calculation divides the requested total by four and rounds upward to the next whole sheet. It then multiplies that sheet count by four to find the imposed page capacity. The difference between capacity and the requested total is returned as blank_pages. For example, a 22-page document needs six sheets, which provide 24 imposed pages, so two blank positions must be introduced. A 24-page document also needs six sheets but has no blanks. The result does not decide where those blank pages belong. That editorial and prepress choice depends on the content, printer requirements, and imposition software; blanks are often placed near the inside covers or at a section boundary. The calculation simply exposes the unavoidable capacity difference, making it easy to revise content, add notes pages, or approve intentional blanks before the production PDF is imposed.

Use the result in a print workflow

Treat sheets as the folded-sheet quantity for one finished copy before spoilage, setup waste, overs, or press-sheet nesting. To estimate the production paper requirement, multiply the returned sheets by the desired number of copies, then apply the printer’s waste allowance separately. Commercial workflows may place several booklet sheets on a larger parent press sheet, so the calculator should not be mistaken for a parent-sheet yield estimator. It also does not rearrange PDF pages, generate printer spreads, compensate for creep, select paper grain, or verify a bindery’s maximum signature thickness. Those decisions depend on trim size, stock caliper, equipment, and the printer’s imposition system. The result is most useful as an early structural check: compare imposed_pages with the document plan, resolve blank_pages intentionally, and communicate the sheets figure when requesting a quotation. Via the API, the same deterministic arithmetic costs $0.002 per request and can be placed in estimating forms, preflight checks, or automated job-ticket creation without network-dependent calculations.

What you can do with it

Preflight a booklet PDF

Check whether the planned page count fills complete folded sheets and identify how many blank pages must be added before imposition.

Estimate paper per copy

Get the exact folded-sheet count for one finished booklet before applying quantity, spoilage, and parent-sheet yield assumptions.

Build print quotations

Convert a customer-provided page count into a consistent sheet quantity inside an estimating form or automated job ticket.

FAQ

Why must a saddle-stitched booklet have a multiple of four pages?

Each sheet is printed on both sides and folded, creating four finished page positions. A partial physical sheet cannot be stitched into the booklet.

Are covers included in total_pages?

Yes, include all four cover faces when the cover is part of the same folded and stitched construction. Ask the printer if a separate cover changes the production plan.

Where should required blank pages be placed?

The calculator reports only their number. Your designer, prepress operator, or printer should place them where they best fit the content and binding requirements.

Does the sheet count include printing waste?

No. It is the exact number of folded booklet sheets per finished copy. Add setup waste, spoilage, overs, and parent-sheet yield separately.

Can this tool impose or rearrange PDF pages?

No. It calculates sheet capacity and blanks only; it does not create printer spreads, reorder pages, compensate for creep, or modify a PDF.

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

POSThttps://api.kit.forhosting.com/pdf/booklet-sheets

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/pdf/booklet-sheets \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"total_pages":22}'

const res = await fetch("https://api.kit.forhosting.com/pdf/booklet-sheets", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "total_pages": 22
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/pdf/booklet-sheets",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "total_pages": 22
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/pdf/booklet-sheets", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"total_pages":22}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"total_pages":22}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/pdf/booklet-sheets", 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_pages": 22
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "pdf.booklet_sheets",
  "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

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

Limits

`max_mb`	25
`max_pages`	200

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.

Read the full KIT documentation →