# Dividir un PDF y tratar la salida
Cómo ejecutar una acción de división y leer sus múltiples salidas, con los formatos ZIP, JSON y multipart y los escollos de cada uno.
Una acción de división convierte un PDF en varios. A diferencia de todas las
demás acciones, la respuesta es un conjunto de documentos y no un solo PDF, y
usted elige cómo se empaquetan con la cabecera de solicitud `Accept`: un
archivo ZIP (la opción predeterminada), un sobre JSON con los documentos
codificados en base64 o un cuerpo `multipart/mixed`. Esta guía elige una
acción de división, solicita cada formato y desempaqueta las partes en
código.
## Elegir una acción de división
Cuatro acciones dividen un documento de maneras distintas. Comparten el mismo
contrato de salida, así que el código de desempaquetado que sigue funciona
para todas.
| Acción | Divide por | Campo clave |
| ------------------------------------------------------------------------------------------ | -------------------------------------- | --------------- |
| [Dividir por número de páginas](/docs/api/split-pdf-by-page-count) (`split_by_page_count`) | un número fijo de páginas por parte | `page_count` |
| [Dividir en una página](/docs/api/split-pdf-at-page) (`split_at_page`) | un límite que produce dos partes | `page` |
| [Dividir por tamaño de archivo](/docs/api/split-pdf-by-file-size) (`split_by_size`) | un tamaño máximo en bytes por parte | `maximum_bytes` |
| [Dividir en grupos de páginas](/docs/api/split-pdf-into-page-groups) (`split_by_groups`) | los grupos explícitos que usted define | `groups` |
Los ejemplos usan `split_by_page_count` con `page_count=10`. Cambie la ruta y
el campo para usar cualquier otra acción de división.
## Elegir un formato de salida
Establezca la cabecera `Accept` para solicitar un formato. Los documentos de
salida siempre se llaman `00001.pdf`, `00002.pdf` y así sucesivamente, en
orden.
| `Accept` | Cuerpo de la respuesta | Cómo leerlo |
| ------------------------------------ | ---------------------------------------------------- | -------------------------- |
| `application/zip` *(predeterminado)* | Un archivo ZIP, una entrada por documento | Descomprima el archivo |
| `application/json` | Un sobre JSON con una matriz `documents[]` en base64 | Decodifique cada `content` |
| `multipart/mixed` | Una parte `application/pdf` por documento | Lea las partes en orden |
Si omite `Accept` por completo, obtiene el ZIP. Una cabecera `Accept` que no
coincida con ninguno de estos tres se responde con `406 Not Acceptable`.
Consulte [Formatos de respuesta](/docs/api/response-formats) para ver el
contrato completo.
## Obtener un ZIP (la opción predeterminada)
Sin cabecera `Accept`, la respuesta es un archivo ZIP. Guárdelo y después
recorra sus entradas.
```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()
}
}
```
## Obtener JSON
Establezca `Accept: application/json` para recibir en su lugar un sobre. Cada
documento lleva su `name`, su `content` codificado en base64 y su
`content_type`:
```json
{
"documents": [
{ "name": "00001.pdf", "content": "JVBERi0xLjcK…", "content_type": "application/pdf" },
{ "name": "00002.pdf", "content": "JVBERi0xLjcK…", "content_type": "application/pdf" }
]
}
```
JSON resulta práctico cuando quien llama quiere los nombres de los documentos
junto con los bytes, o cuando un transporte es más fácil de manejar como
texto que como archivo binario. Decodifique cada `content` desde base64 para
recuperar el PDF.
```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'));
}
```
## Obtener multipart/mixed
Establezca `Accept: multipart/mixed` para recibir en streaming una parte
`application/pdf` por documento, cada una con un `Content-Disposition` que la
nombra `00001.pdf`, `00002.pdf` y así sucesivamente. Prefiéralo cuando
quiera tratar cada parte a medida que llega en lugar de mantener un archivo
completo en memoria. La mayoría de los lenguajes tiene un analizador
multipart: en Python, `requests-toolbelt` decodifica la respuesta
directamente:
```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)
```
## Errores frecuentes
- **Un `406` significa que su `Accept` no coincidió.** Envíe exactamente
`application/zip`, `application/json` o `multipart/mixed` (o ningún
`Accept`). Un `application/pdf` o `*/*` colado desde los valores
predeterminados de un cliente HTTP es una causa habitual: establezca la
cabecera de forma explícita.
- **Las divisiones grandes producen respuestas grandes.** Un documento grande
dividido en muchas partes puede ser un archivo de tamaño considerable.
Escriba la respuesta en disco en streaming en lugar de mantenerla en
memoria, o use `multipart/mixed` para procesar cada parte a medida que
llega. Consulte [Trabajar con archivos
grandes](/docs/api/working-with-large-files).
- **Una sola página demasiado grande.** Con [Dividir por tamaño de
archivo](/docs/api/split-pdf-by-file-size), una página que por sí sola
supera `maximum_bytes` se devuelve como una parte propia que excede el
límite: no se puede dividir más. Cuente con que alguna parte sea más grande
que el tope.
## Relacionado
El contrato completo de ZIP, JSON y multipart.
Parta un PDF en partes de tamaño fijo.
Defina exactamente qué páginas van en cada salida.
Transmita archivos de división grandes sin acumularlos en memoria.