# Formati di risposta e negoziazione del contenuto

Che cosa restituisce un’azione e come l’intestazione Accept sceglie tra un PDF, uno ZIP, una busta JSON e multipart/mixed.

La maggior parte delle azioni restituisce un solo documento `application/pdf`. Le
quattro azioni di divisione restituiscono più documenti in una volta sola e
l’impacchettamento si sceglie con l’intestazione di richiesta `Accept`. Questa
pagina è il riferimento per quella negoziazione del contenuto: le opzioni di
impacchettamento, lo schema della busta JSON e che cosa succede quando
un’intestazione `Accept` non corrisponde a nulla.

## Risposte a documento singolo

Ogni azione che non sia una divisione risponde con `200 OK` e il PDF elaborato
come corpo grezzo:

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

Non c’è nulla da negoziare. Scrivere il corpo in streaming in un file, come fanno
gli esempi di ogni pagina di azione.

## Risposte a più documenti

La famiglia delle divisioni restituisce molti documenti da una sola chiamata:
[Dividere per numero di pagine](/docs/api/split-pdf-by-page-count),
[Dividere a una pagina](/docs/api/split-pdf-at-page),
[Dividere per dimensione del file](/docs/api/split-pdf-by-file-size) e
[Dividere in gruppi di pagine](/docs/api/split-pdf-into-page-groups). I documenti
di output si chiamano `00001.pdf`, `00002.pdf` e così via, in ordine.
L’impacchettamento si seleziona con l’intestazione di richiesta `Accept`:

| Intestazione `Accept` | Risposta                                                |
| --------------------- | ------------------------------------------------------- |
| *(nessuna inviata)*   | `application/zip`, il valore predefinito                |
| `application/zip`     | Un archivio ZIP dei PDF di output                       |
| `application/json`    | Una busta JSON di documenti codificati in base64        |
| `multipart/mixed`     | Un PDF per parte                                        |
| qualsiasi altro       | `406 Not Acceptable`                                    |

### application/zip: il valore predefinito

Senza intestazione `Accept` (oppure con `Accept: application/zip`), la risposta è
un archivio ZIP le cui voci si chiamano `00001.pdf`, `00002.pdf` e così via:

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

Estrarre `parts.zip` per ottenere i singoli documenti.

### application/json: la busta base64

Richiedere `Accept: application/json` per ottenere tutti i documenti in linea in
un’unica risposta JSON, comodo quando si vogliono tenere le parti in memoria
oppure inoltrarle senza toccare il filesystem:

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

Il corpo è un array `documents` in cui ogni voce contiene il proprio nome e i
byte codificati in base64:

```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>
  I documenti PDF di output, in ordine.
</ParamField>

<ParamField name="documents[].name" type="string" required>
  Il nome del documento: `00001.pdf`, `00002.pdf` e così via.
</ParamField>

<ParamField name="documents[].content" type="string (base64)" required>
  Il documento PDF, codificato in base64. Decodificarlo per recuperare i byte
  grezzi del PDF.
</ParamField>

<ParamField name="documents[].content_type" type="string" required>
  Il tipo di media del documento: `application/pdf`.
</ParamField>

### multipart/mixed: una parte per documento

Richiedere `Accept: multipart/mixed` per ricevere in streaming i documenti come
corpo multipart con una parte per ogni PDF di output, in ordine. Ogni parte ha un
`Content-Type` pari a `application/pdf` e un `Content-Disposition` che la nomina
`00001.pdf`, `00002.pdf` e così via.

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

## Un Accept senza corrispondenza restituisce 406

Se si invia un’intestazione `Accept` che non corrisponde a nessuno dei tre
formati qui sopra (ad esempio `Accept: application/pdf` su un’azione di
divisione), l’API risponde con un `406 Not Acceptable` e un corpo
`application/problem+json`. Occorre omettere `Accept` per prendere lo ZIP
predefinito oppure richiedere uno dei tipi di media supportati. Vedere
[Errori](/docs/api/errors) per la forma dei problem details.

<Tip>
  Per codice completo che chiama un’azione di divisione e spacchetta ciascun
  formato (estraendo lo ZIP, decodificando la busta JSON oppure leggendo le parti
  multipart), vedere la guida [Dividere un PDF](/docs/api/splitting-a-pdf).
</Tip>