ForHosting KIT · Documents & PDF

Split a PDF

The Split PDF API takes a single PDF and cuts it into the exact set of smaller files you need, whether that means one file per page, one per chapter, or a handful of custom ranges. You send the document and the rules, we return each piece as its own clean PDF with its page tree, links, and embedded fonts intact. No desktop tool, no queue of manual saves, no fragile shell scripts.

● StablePer request + per page$0.002

Run — $0.002 How it works & API

Use it from WebAPIEmailApp soonTelegram soon

Run it online

Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.

The problem it actually solves

Most PDFs arrive as one long blob when the people downstream only need a slice of it: a single invoice out of a monthly statement run, chapter three of a manual, or the signature page pulled from a contract. Splitting by hand means opening a viewer, guessing page numbers, and exporting one file at a time, which does not survive contact with volume. The split pdf api turns that chore into a single call, so a document management platform, a legal ops team, or a print shop can separate thousands of files without a human ever touching a page range.

How the split works

You POST to /pdf/split with the source document and a split rule: fixed size (every N pages), explicit ranges like 1-4, 5, 6-9, or one file per page. Because the work is asynchronous, the endpoint immediately returns a task_id and gets out of your way. When the split finishes, each output PDF is delivered to your signed webhook or made available as a signed link valid for 24 hours. The page objects are copied rather than re-rendered, so text stays selectable, vectors stay sharp, and the split files weigh roughly what the original pages did.

Why PDF makes this harder than it looks

A PDF is not a stack of independent pages; it is a shared object graph where fonts, images, and annotations are referenced across the file. Naively copying a page can leave it pointing at resources that live in a part you just discarded, producing files that open blank or bloated. Since Adobe published the format in 1993 and it became the ISO 32000 standard, this internal structure has only grown richer with layers, forms, and tagging. Our splitter walks that graph and pulls each output's real dependencies with it, which is the difference between a valid standalone PDF and a broken fragment.

Built for automation, not clicking

This is designed to run unattended inside a pipeline. Point an incoming folder, an upload handler, or a nightly job at the endpoint and let webhooks fan the results into storage, an email, or the next task. A failed split is never charged: we retry three times with backoff, and if it still cannot complete you get a clear error instead of a silent gap and a mystery bill. Access requires prepaid balance, which is deliberate: it keeps the service fast, spam-free, and predictable for the teams that depend on it.

What you can do with it

Bursting statement runs

A billing system generates one 900-page PDF containing every customer's monthly statement. Split it into one file per statement so each can be emailed or dropped into the right account portal automatically.

Isolating signed pages

A contract platform needs only the executed signature and initials pages returned to compliance. Split the agreement by explicit page ranges to extract exactly those sheets without shipping the full 60-page document.

Chapter-level course material

An e-learning team receives textbooks as single massive PDFs. Split each into per-chapter files so students download only the reading assigned that week instead of a 400-page brick.

Feeding a print workflow

A print shop takes a combined proof and splits it into per-job files, each routed to a different press profile, so operators never manually re-export ranges under deadline.

FAQ

How do I split a PDF into separate files with an API?

Send a POST to /pdf/split with your document and a split rule (fixed page count, explicit ranges, or one file per page). The split pdf api returns a task_id right away and delivers each resulting file to your webhook or a signed link.

Is the Split PDF API free?

There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.

Can I split a PDF by specific page ranges?

Yes. You can pass explicit ranges such as 1-4, 5, and 6-9 to produce exactly those files, split every N pages, or output one file per page.

Will splitting reduce the quality of my PDF?

No. Pages are copied, not re-rendered, so text stays selectable and vector graphics stay sharp. Each output carries its own fonts and resources so it opens as a valid standalone file.

Can I split thousands of PDFs in bulk?

Yes. The endpoint is asynchronous and built for automation, so you can fire many requests from a pipeline and receive results by webhook as each one finishes, without blocking.

How are the split files delivered?

Results arrive by signed webhook (recommended) or a signed link valid for 24 hours. After the retention window the data is deleted, and it is never used to train anything.

What happens if a split fails?

We retry three times with backoff. If it still cannot complete, you receive a clear error and are not charged for that request.

Does the API keep bookmarks and links inside each file?

Internal page objects, embedded fonts, and links that live within a slice are preserved. References that pointed to discarded pages are resolved so each output remains a clean, valid 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/split

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, and soon from our app, email and Telegram.

Call it from your stack

curl -X POST https://api.kit.forhosting.com/pdf/split \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d &#39;{"pdf":"https://ejemplo.com/documento.pdf"}'

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

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/pdf/split",
    headers={"Authorization": f"Bearer {os.environ[&#39;KIT_KEY']}"},
    json={
    "pdf": "https://ejemplo.com/documento.pdf"
},
)
task_id = res.json()["task_id"]

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

body := bytes.NewBufferString(`{"pdf":"https://ejemplo.com/documento.pdf"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/pdf/split", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)

Example request

{
  "pdf": "https://ejemplo.com/documento.pdf"
}

Example response

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "pdf.split",
  "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.
`413`	`input_too_large`	The file exceeds the size limit.

Read the full KIT documentation →