# Antwortformate und Inhaltsaushandlung

Was eine Aktion zurückgibt und wie der Header Accept zwischen einem PDF, einem ZIP, einem JSON-Umschlag und multipart/mixed wählt.

Die meisten Aktionen geben ein einzelnes Dokument vom Typ `application/pdf`
zurück. Die vier Aktionen zum Aufteilen geben mehrere Dokumente auf einmal
zurück, und Sie wählen mit dem Anfrage-Header `Accept`, wie diese verpackt
werden. Diese Seite ist die Referenz für diese Inhaltsaushandlung: die
Verpackungsoptionen, das Schema des JSON-Umschlags und was geschieht, wenn ein
Header `Accept` auf nichts passt.

## Antworten mit einem einzelnen Dokument

Jede Aktion außer denen zum Aufteilen antwortet mit `200 OK` und dem
verarbeiteten PDF als reinem Antworttext:

```http
HTTP/1.1 200 OK
Content-Type: application/pdf
Content-Length: 48213
```

Es gibt nichts auszuhandeln. Verarbeiten Sie den Antworttext als Stream direkt
in eine Datei, wie es die Beispiele auf jeder Seite einer Aktion tun.

## Antworten mit mehreren Dokumenten

Die Familie der Aktionen zum Aufteilen gibt aus einem Aufruf viele Dokumente
zurück: [Nach Seitenanzahl aufteilen](/docs/api/split-pdf-by-page-count),
[An einer Seite aufteilen](/docs/api/split-pdf-at-page),
[Nach Dateigröße aufteilen](/docs/api/split-pdf-by-file-size) und
[In Seitengruppen aufteilen](/docs/api/split-pdf-into-page-groups). Die
Ausgabedokumente heißen der Reihe nach `00001.pdf`, `00002.pdf` und so weiter.
Die Verpackung wählen Sie mit dem Anfrage-Header `Accept`:

| Header `Accept`      | Antwort                                                         |
| -------------------- | -------------------------------------------------------------- |
| *(nicht gesendet)*   | `application/zip`, die Voreinstellung                          |
| `application/zip`    | Ein ZIP-Archiv der Ausgabe-PDFs                                |
| `application/json`   | Ein JSON-Umschlag mit base64-kodierten Dokumenten              |
| `multipart/mixed`    | Ein PDF pro Teil                                               |
| alles andere         | `406 Not Acceptable`                                            |

### application/zip: die Voreinstellung

Ohne den Header `Accept` (oder mit `Accept: application/zip`) ist die Antwort
ein ZIP-Archiv, dessen Einträge `00001.pdf`, `00002.pdf` und so weiter heißen:

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

Entpacken Sie `parts.zip`, um die einzelnen Dokumente zu erhalten.

### application/json: der base64-Umschlag

Fordern Sie `Accept: application/json` an, um alle Dokumente inline in einer
einzigen JSON-Antwort zu erhalten. Das ist praktisch, wenn Sie die Teile im
Arbeitsspeicher halten oder weiterreichen möchten, ohne das Dateisystem zu
berühren:

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

Der Antworttext ist ein Array `documents`, dessen Einträge jeweils ihren Namen
und ihre base64-kodierten Bytes tragen:

```json
{
  "documents": [
    {
      "name": "00001.pdf",
      "content": "JVBERi0xLjcKJeLjz9MK... (base64)",
      "content_type": "application/pdf"
    },
    {
      "name": "00002.pdf",
      "content": "JVBERi0xLjcKJeLjz9MK... (base64)",
      "content_type": "application/pdf"
    }
  ]
}
```

<ParamField name="documents" type="array" required>
  Die PDF-Ausgabedokumente, der Reihe nach.
</ParamField>

<ParamField name="documents[].name" type="string" required>
  Der Name des Dokuments: `00001.pdf`, `00002.pdf` und so weiter.
</ParamField>

<ParamField name="documents[].content" type="string (base64)" required>
  Das PDF-Dokument, base64-kodiert. Dekodieren Sie es, um die reinen PDF-Bytes
  zurückzuerhalten.
</ParamField>

<ParamField name="documents[].content_type" type="string" required>
  Der Medientyp des Dokuments: `application/pdf`.
</ParamField>

### multipart/mixed: ein Teil pro Dokument

Fordern Sie `Accept: multipart/mixed` an, um die Dokumente als Stream in einem
Multipart-Antworttext zu verarbeiten, mit einem Teil pro Ausgabe-PDF, der
Reihe nach. Jeder Teil hat den `Content-Type` `application/pdf` und ein
`Content-Disposition`, das ihn `00001.pdf`, `00002.pdf` und so weiter benennt.

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

## Ein nicht passendes Accept ergibt 406

Wenn Sie einen Header `Accept` senden, der auf keines der drei Formate oben
passt (zum Beispiel `Accept: application/pdf` bei einer Aktion zum Aufteilen),
antwortet die API mit `406 Not Acceptable` und einem Antworttext vom Typ
`application/problem+json`. Lassen Sie `Accept` entweder weg, um die
ZIP-Voreinstellung zu übernehmen, oder fordern Sie einen der unterstützten
Medientypen an. Siehe [Fehler](/docs/api/errors) für die Form der Problemdetails.

<Tip>
  Vollständigen Code, der eine Aktion zum Aufteilen aufruft und jedes Format
  entpackt (das ZIP extrahieren, den JSON-Umschlag dekodieren oder die
  Multipart-Teile lesen), finden Sie im Leitfaden [Ein PDF
  aufteilen](/docs/api/splitting-a-pdf).
</Tip>