PDF Blocks
PreiseSupport
Kostenlos starten
Seite öffnen

Ein PDF aufteilen und die Ausgabe verarbeiten

Wie Sie eine Aktion zum Aufteilen ausführen und ihre vielen Ausgaben lesen, mit den Formaten ZIP, JSON und multipart sowie den Fallstricken jedes einzelnen Formats.

Eine Aktion zum Aufteilen macht aus einem PDF mehrere. Anders als bei jeder anderen Aktion ist die Antwort eine Menge von Dokumenten statt eines einzelnen PDFs, und wie sie verpackt werden, wählen Sie mit dem Anfrage-Header Accept: ein ZIP-Archiv (die Voreinstellung), ein JSON-Umschlag mit base64-kodierten Dokumenten oder ein Antworttext vom Typ multipart/mixed. Dieser Leitfaden wählt eine Aktion zum Aufteilen, fordert jedes Format an und packt die Teile im Code aus.

Eine Aktion zum Aufteilen wählen

Vier Aktionen teilen ein Dokument auf unterschiedliche Weise auf. Sie folgen demselben Ausgabevertrag, sodass der Code zum Auspacken weiter unten für alle funktioniert.

Aktion Teilt auf nach Schlüsselfeld
Nach Seitenanzahl aufteilen (split_by_page_count) einer festen Seitenanzahl pro Teil page_count
An einer Seite aufteilen (split_at_page) einer Trennstelle in zwei Teile page
Nach Dateigröße aufteilen (split_by_size) einer maximalen Größe in Bytes pro Teil maximum_bytes
In Seitengruppen aufteilen (split_by_groups) expliziten Gruppen, die Sie festlegen groups

Die Beispiele verwenden split_by_page_count mit page_count=10. Tauschen Sie Route und Feld aus, um jede andere Aktion zum Aufteilen zu verwenden.

Ein Ausgabeformat wählen

Setzen Sie den Header Accept, um ein Format anzufordern. Die Ausgabedokumente heißen immer 00001.pdf, 00002.pdf und so weiter, der Reihe nach.

Accept Antworttext So lesen Sie ihn
application/zip (Voreinstellung) Ein ZIP-Archiv, ein Eintrag pro Dokument Das Archiv entpacken
application/json Ein JSON-Umschlag mit einem base64-kodierten Array documents[] Jedes content dekodieren
multipart/mixed Ein Teil application/pdf pro Dokument Die Teile der Reihe nach lesen

Lassen Sie Accept ganz weg, erhalten Sie das ZIP. Ein Header Accept, der zu keinem dieser drei passt, wird mit 406 Not Acceptable beantwortet. Den vollständigen Vertrag finden Sie unter Antwortformate.

Ein ZIP abrufen (die Voreinstellung)

Ohne Header Accept ist die Antwort ein ZIP-Archiv. Speichern Sie es und gehen Sie dann seine Einträge durch.

cURLbash
curl https://api.pdfblocks.com/v1/split_by_page_count \
  -H 'X-API-Key: your_api_key' \
  -F file=@input.pdf \
  -F page_count=10 \
  -o parts.zip

unzip parts.zip -d parts/
# parts/00001.pdf  parts/00002.pdf  parts/00003.pdf …
Pythonpython
# pip install requests
import io
import zipfile
import requests

with open('input.pdf', 'rb') as file:
    response = requests.post(
        'https://api.pdfblocks.com/v1/split_by_page_count',
        headers={'X-API-Key': 'your_api_key'},  # no Accept → ZIP
        files={'file': file},
        data={'page_count': 10},
    )
response.raise_for_status()

with zipfile.ZipFile(io.BytesIO(response.content)) as archive:
    print(archive.namelist())  # ['00001.pdf', '00002.pdf', …]
    archive.extractall('parts')
Gogo
package main

import (
	"archive/zip"
	"bytes"
	"io"
	"mime/multipart"
	"net/http"
	"os"
	"path/filepath"
)

func main() {
	var buf bytes.Buffer
	form := multipart.NewWriter(&buf)
	file, _ := os.Open("input.pdf")
	defer file.Close()
	part, _ := form.CreateFormFile("file", "input.pdf")
	io.Copy(part, file)
	form.WriteField("page_count", "10")
	form.Close()

	req, _ := http.NewRequest("POST",
		"https://api.pdfblocks.com/v1/split_by_page_count", &buf)
	req.Header.Set("Content-Type", form.FormDataContentType())
	req.Header.Set("X-API-Key", "your_api_key")
	// No Accept header → ZIP.

	res, _ := http.DefaultClient.Do(req)
	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	archive, _ := zip.NewReader(bytes.NewReader(body), int64(len(body)))
	os.MkdirAll("parts", 0755)
	for _, entry := range archive.File {
		in, _ := entry.Open()
		out, _ := os.Create(filepath.Join("parts", entry.Name))
		io.Copy(out, in)
		out.Close()
		in.Close()
	}
}

JSON abrufen

Setzen Sie Accept: application/json, um stattdessen einen Umschlag zu erhalten. Jedes Dokument trägt seinen name, seinen base64-kodierten content und seinen content_type:

{
  "documents": [
    { "name": "00001.pdf", "content": "JVBERi0xLjcK…", "content_type": "application/pdf" },
    { "name": "00002.pdf", "content": "JVBERi0xLjcK…", "content_type": "application/pdf" }
  ]
}

JSON ist praktisch, wenn der Aufrufer die Dokumentnamen zusätzlich zu den Bytes braucht oder wenn ein Transportweg Text leichter handhabt als ein binäres Archiv. Dekodieren Sie jedes content aus base64, um das PDF zurückzugewinnen.

cURLbash
curl https://api.pdfblocks.com/v1/split_by_page_count \
  -H 'X-API-Key: your_api_key' \
  -H 'Accept: application/json' \
  -F file=@input.pdf \
  -F page_count=10 \
  -o parts.json
Pythonpython
# pip install requests
import base64
import requests

with open('input.pdf', 'rb') as file:
    response = requests.post(
        'https://api.pdfblocks.com/v1/split_by_page_count',
        headers={'X-API-Key': 'your_api_key', 'Accept': 'application/json'},
        files={'file': file},
        data={'page_count': 10},
    )
response.raise_for_status()

for document in response.json()['documents']:
    with open(document['name'], 'wb') as out:
        out.write(base64.b64decode(document['content']))
Node.jsjavascript
// Node.js 18+
import { readFile, writeFile } from 'node:fs/promises';

const body = new FormData();
body.set('file', new Blob([await readFile('input.pdf')]), 'input.pdf');
body.set('page_count', '10');

const response = await fetch('https://api.pdfblocks.com/v1/split_by_page_count', {
  method: 'POST',
  headers: { 'X-API-Key': 'your_api_key', Accept: 'application/json' },
  body,
});
if (!response.ok) throw new Error(`Request failed: ${response.status}`);

const { documents } = await response.json();
for (const document of documents) {
  await writeFile(document.name, Buffer.from(document.content, 'base64'));
}

multipart/mixed abrufen

Setzen Sie Accept: multipart/mixed, um pro Dokument einen Teil application/pdf als Stream zu erhalten, jeweils mit einem Content-Disposition, das ihn 00001.pdf, 00002.pdf und so weiter nennt. Bevorzugen Sie das, wenn Sie jeden Teil beim Eintreffen verarbeiten wollen, statt ein ganzes Archiv im Speicher zu halten. Die meisten Sprachen haben einen Multipart-Parser. Für Python dekodiert requests-toolbelt die Antwort direkt:

cURLbash
curl https://api.pdfblocks.com/v1/split_by_page_count \
  -H 'X-API-Key: your_api_key' \
  -H 'Accept: multipart/mixed' \
  -F file=@input.pdf \
  -F page_count=10 \
  -o parts.multipart
Pythonpython
# pip install requests requests-toolbelt
import requests
from requests_toolbelt.multipart.decoder import MultipartDecoder

with open('input.pdf', 'rb') as file:
    response = requests.post(
        'https://api.pdfblocks.com/v1/split_by_page_count',
        headers={'X-API-Key': 'your_api_key', 'Accept': 'multipart/mixed'},
        files={'file': file},
        data={'page_count': 10},
    )
response.raise_for_status()

for index, part in enumerate(MultipartDecoder.from_response(response).parts, start=1):
    with open(f'{index:05d}.pdf', 'wb') as out:
        out.write(part.content)

Fallstricke

  • Ein 406 heißt, dass Ihr Accept nicht gepasst hat. Senden Sie genau application/zip, application/json oder multipart/mixed (oder gar kein Accept). Ein versehentliches application/pdf oder */* aus den Voreinstellungen eines HTTP-Clients ist eine häufige Ursache: Setzen Sie den Header ausdrücklich.
  • Große Aufteilungen erzeugen große Antworten. Ein großes Dokument, das in viele Teile aufgeteilt wird, kann ein umfangreiches Archiv ergeben. Schreiben Sie die Antwort als Stream auf die Festplatte, statt sie im Speicher zu halten, oder verarbeiten Sie mit multipart/mixed jeden Teil beim Eintreffen. Siehe Mit großen Dateien arbeiten.
  • Eine einzelne übergroße Seite. Bei Nach Dateigröße aufteilen wird eine Seite, die für sich allein größer ist als maximum_bytes, als eigener Teil zurückgegeben, der das Limit überschreitet: sie lässt sich nicht weiter aufteilen. Rechnen Sie damit, dass ein Teil gelegentlich größer ist als die Obergrenze.

Siehe auch

Antwortformate

Der vollständige Vertrag für ZIP, JSON und multipart.

Nach Seitenanzahl aufteilen

Ein PDF in Blöcke fester Größe zerlegen.

In Seitengruppen aufteilen

Genau festlegen, welche Seiten in welche Ausgabe kommen.

Mit großen Dateien arbeiten

Große Archive aus dem Aufteilen als Stream verarbeiten, ohne sie zu puffern.