PDF Blocks
TarifsSupport
Commencer gratuitement
Ouvrir la page

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 (split_by_page_count) un nombre fixe de pages par partie page_count
Diviser un PDF à une page (split_at_page) une limite unique donnant deux parties page
Diviser un PDF par taille de fichier (split_by_size) une taille maximale en octets par partie maximum_bytes
Diviser un PDF en groupes de pages (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 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.

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()
	}
}

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 :

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

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'));
}

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 :

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)

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.
  • Une page unique hors gabarit. Avec Diviser un PDF par taille de fichier, 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

Formats de réponse

Le contrat complet ZIP, JSON et multipart.

Diviser par nombre de pages

Découpez un PDF en blocs de taille fixe.

Diviser en groupes de pages

Définissez exactement quelles pages vont dans chaque sortie.

Travailler avec de gros fichiers

Traitez en flux les grosses archives de division sans mise en mémoire tampon.