PDF Blocks
PreciosSoporte
Empezar gratis
Ir a la página

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 (split_by_page_count) un número fijo de páginas por parte page_count
Dividir en una página (split_at_page) un límite que produce dos partes page
Dividir por tamaño de archivo (split_by_size) un tamaño máximo en bytes por parte maximum_bytes
Dividir en grupos de páginas (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 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.

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

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:

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

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

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:

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)

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.
  • Una sola página demasiado grande. Con Dividir por tamaño de archivo, 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

Formatos de respuesta

El contrato completo de ZIP, JSON y multipart.

Dividir por número de páginas

Parta un PDF en partes de tamaño fijo.

Dividir en grupos de páginas

Defina exactamente qué páginas van en cada salida.

Trabajar con archivos grandes

Transmita archivos de división grandes sin acumularlos en memoria.