# 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](/docs/api/split-pdf-by-page-count) (`split_by_page_count`) | einer festen Seitenanzahl pro Teil | `page_count` |
| [An einer Seite aufteilen](/docs/api/split-pdf-at-page) (`split_at_page`) | einer Trennstelle in zwei Teile | `page` |
| [Nach Dateigröße aufteilen](/docs/api/split-pdf-by-file-size) (`split_by_size`) | einer maximalen Größe in Bytes pro Teil | `maximum_bytes` |
| [In Seitengruppen aufteilen](/docs/api/split-pdf-into-page-groups) (`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](/docs/api/response-formats).

## 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.

<CodeGroup>

```bash title="cURL"
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 …
```

```python title="Python"
# 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')
```

```go title="Go"
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()
	}
}
```

</CodeGroup>

## 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`:

```json
{
  "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.

<CodeGroup>

```bash title="cURL"
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
```

```python title="Python"
# 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']))
```

```javascript title="Node.js"
// 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'));
}
```

</CodeGroup>

## 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:

<CodeGroup>

```bash title="cURL"
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
```

```python title="Python"
# 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)
```

</CodeGroup>

## 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](/docs/api/working-with-large-files).
- **Eine einzelne übergroße Seite.** Bei [Nach Dateigröße
  aufteilen](/docs/api/split-pdf-by-file-size) 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

<CardGroup cols={2}>

<Card title="Antwortformate" href="/docs/api/response-formats">
  Der vollständige Vertrag für ZIP, JSON und multipart.
</Card>

<Card title="Nach Seitenanzahl aufteilen" href="/docs/api/split-pdf-by-page-count">
  Ein PDF in Blöcke fester Größe zerlegen.
</Card>

<Card title="In Seitengruppen aufteilen" href="/docs/api/split-pdf-into-page-groups">
  Genau festlegen, welche Seiten in welche Ausgabe kommen.
</Card>

<Card title="Mit großen Dateien arbeiten" href="/docs/api/working-with-large-files">
  Große Archive aus dem Aufteilen als Stream verarbeiten, ohne sie zu puffern.
</Card>

</CardGroup>