# Diviser un PDF et traiter la sortie

Comment exécuter une action de division et lire ses multiples sorties, en couvrant les formats ZIP, JSON et multipart ainsi que les pièges de chacun.

Une action de division transforme un PDF en plusieurs. Contrairement à toutes
les autres actions, la réponse est un ensemble de documents plutôt qu’un seul
PDF, et vous choisissez leur conditionnement avec l’en-tête de requête
`Accept` : une archive ZIP (la valeur par défaut), une enveloppe JSON de
documents encodés en base64, ou un corps `multipart/mixed`. Ce guide choisit
une action de division, demande chaque format et extrait les parties dans le
code.

## Choisir une action de division

Quatre actions divisent un document de différentes manières. Elles partagent le
même contrat de sortie, si bien que le code d’extraction ci-dessous fonctionne
pour toutes.

| Action | Divise selon | Champ clé |
| --- | --- | --- |
| [Diviser un PDF par nombre de pages](/docs/api/split-pdf-by-page-count) (`split_by_page_count`) | un nombre fixe de pages par partie | `page_count` |
| [Diviser un PDF à une page](/docs/api/split-pdf-at-page) (`split_at_page`) | une limite unique donnant deux parties | `page` |
| [Diviser un PDF par taille de fichier](/docs/api/split-pdf-by-file-size) (`split_by_size`) | une taille maximale en octets par partie | `maximum_bytes` |
| [Diviser un PDF en groupes de pages](/docs/api/split-pdf-into-page-groups) (`split_by_groups`) | des groupes explicites que vous définissez | `groups` |

Les exemples utilisent `split_by_page_count` avec `page_count=10`. Changez la
route et le champ pour utiliser n’importe quelle autre action de division.

## Choisir un format de sortie

Définissez l’en-tête `Accept` pour demander un format. Les documents de sortie
sont toujours nommés `00001.pdf`, `00002.pdf`, et ainsi de suite, dans l’ordre.

| `Accept` | Corps de la réponse | Comment le lire |
| --- | --- | --- |
| `application/zip` *(par défaut)* | Une archive ZIP, une entrée par document | Décompressez l’archive |
| `application/json` | Une enveloppe JSON avec un tableau `documents[]` en base64 | Décodez chaque `content` |
| `multipart/mixed` | Une partie `application/pdf` par document | Lisez les parties dans l’ordre |

Omettez complètement `Accept` et vous obtenez le ZIP. Un en-tête `Accept` qui
ne correspond à aucun de ces trois formats reçoit une réponse
`406 Not Acceptable`. Consultez [Formats de réponse et négociation de
contenu](/docs/api/response-formats) pour le contrat complet.

## Obtenir un ZIP (le format par défaut)

Sans en-tête `Accept`, la réponse est une archive ZIP. Enregistrez-la, puis
parcourez ses entrées.

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

## Obtenir du JSON

Définissez `Accept: application/json` pour recevoir une enveloppe à la place.
Chaque document porte son `name`, son `content` encodé en base64 et son
`content_type` :

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

Le JSON est pratique lorsque l’appelant veut les noms des documents en plus des
octets, ou lorsqu’un transport est plus facile à gérer sous forme de texte que
d’archive binaire. Décodez chaque `content` depuis le base64 pour retrouver le
PDF.

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

## Obtenir du multipart/mixed

Définissez `Accept: multipart/mixed` pour recevoir en flux une partie
`application/pdf` par document, chacune avec un `Content-Disposition` qui la
nomme `00001.pdf`, `00002.pdf`, et ainsi de suite. Préférez ce format lorsque
vous voulez traiter chaque partie à mesure qu’elle arrive plutôt que de garder
toute une archive en mémoire. La plupart des langages disposent d’un analyseur
multipart. En Python, `requests-toolbelt` décode directement la réponse :

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

## Pièges

- **Un `406` signifie que votre `Accept` ne correspondait pas.** Envoyez
  exactement `application/zip`, `application/json` ou `multipart/mixed` (ou
  aucun `Accept` du tout). Un `application/pdf` ou `*/*` parasite venu des
  valeurs par défaut d’un client HTTP en est une cause fréquente : définissez
  l’en-tête explicitement.
- **Les grandes divisions produisent de grandes réponses.** Un gros document
  divisé en de nombreuses parties peut donner une archive volumineuse. Écrivez
  la réponse en flux sur le disque au lieu de la garder en mémoire, ou utilisez
  `multipart/mixed` pour traiter chaque partie à mesure qu’elle arrive.
  Consultez [Travailler avec de gros
  fichiers](/docs/api/working-with-large-files).
- **Une page unique hors gabarit.** Avec [Diviser un PDF par taille de
  fichier](/docs/api/split-pdf-by-file-size), une page qui dépasse à elle seule
  `maximum_bytes` est renvoyée comme une partie à part entière qui excède la
  limite : elle ne peut pas être divisée davantage. Attendez-vous à ce qu’une
  partie soit de temps en temps plus grosse que le plafond.

## Voir aussi

<CardGroup cols={2}>

<Card title="Formats de réponse" href="/docs/api/response-formats">
  Le contrat complet ZIP, JSON et multipart.
</Card>

<Card title="Diviser par nombre de pages" href="/docs/api/split-pdf-by-page-count">
  Découpez un PDF en blocs de taille fixe.
</Card>

<Card title="Diviser en groupes de pages" href="/docs/api/split-pdf-into-page-groups">
  Définissez exactement quelles pages vont dans chaque sortie.
</Card>

<Card title="Travailler avec de gros fichiers" href="/docs/api/working-with-large-files">
  Traitez en flux les grosses archives de division sans mise en mémoire tampon.
</Card>

</CardGroup>