lucasw89/bentopdf
1
0 Fork 0
mirror of https://github.com/alam00000/bentopdf.git synced 2026-11-12 01:33:36 +01:00
Code Issues Packages Projects Releases Wiki Activity

feat: translate all pages, UI messages and docs and fix SEO redirects and indexing

Browse Source
This commit is contained in:
alam00000 committed 2026-10-25 12:55:21 +05:30
1 parent 5e019de5ae
commit 4edb1718cc
3344 files changed
+415643 -4759
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

docs/es/contributing.md
+136
View File
@@ -0,0 +1,136 @@
# Contribuir
¡Gracias por tu interés en contribuir a BentoPDF! Esta guía te ayudará a empezar.
## Primeros pasos
### Requisitos previos
- Node.js 18+
- npm 9+
- Git
### Configuración
```bash
# Fork and clone the repository
git clone https://github.com/YOUR_USERNAME/bentopdf.git
cd bentopdf
# Install dependencies
npm install
# Start development server
npm run dev
```
## Estructura del proyecto
```
bentopdf/
├── src/
│ ├── js/
│ │ ├── config/ # Tool definitions
│ │ ├── logic/ # Tool page logic
│ │ ├── utils/ # Shared utilities
│ │ └── ui.ts # UI helpers
│ ├── pages/ # Tool HTML pages
│ └── css/ # Styles
├── public/
│ ├── locales/ # Translations
│ └── pymupdf-wasm/ # WASM modules
├── docs/ # Documentation (VitePress)
└── scripts/ # Build scripts
```
## Añadir una herramienta nueva
### Paso 1: Crear el archivo de lógica
Crea `src/js/logic/your-tool-page.ts`:
```typescript
import { showLoader, hideLoader, showAlert } from '../ui.js';
import { state } from '../state.js';
document.addEventListener('DOMContentLoaded', () => {
// Your tool logic here
});
```
### Paso 2: Crear la página HTML
Crea `src/pages/your-tool.html` siguiendo las plantillas de herramientas existentes.
### Paso 3: Registrar la herramienta
Añade a `src/js/config/tools.ts`:
```typescript
{
href: import.meta.env.BASE_URL + 'your-tool.html',
name: 'Your Tool',
icon: 'ph-icon-name',
subtitle: 'Description of your tool.',
}
```
### Paso 4: Añadir a la configuración de compilación
Añade la página a `vite.config.ts`:
```typescript
'your-tool': resolve(__dirname, 'src/pages/your-tool.html'),
```
### Paso 5: Añadir traducciones
Añade entradas a todos los archivos de idioma en `public/locales/`:
```json
{
"yourTool": {
"name": "Your Tool",
"subtitle": "Description"
}
}
```
## Estilo de código
- Usa TypeScript para todo el código nuevo
- Sigue los patrones existentes para mantener la coherencia
- Ejecuta `npm run format` antes de hacer commit
- Sin comentarios en el código de producción (los comentarios se eliminan durante la compilación)
## Proceso de pull request
1. Crea una rama de funcionalidad: `git checkout -b feature/your-feature`
2. Haz tus cambios
3. Pruébalo a fondo: `npm run build`
4. Envía un PR con una descripción clara
## Traducción
Consulta [TRANSLATION.md](https://github.com/alam00000/bentopdf/blob/main/TRANSLATION.md) para añadir nuevos idiomas.
## Acuerdo de licencia de colaborador
Antes de que se pueda fusionar tu PR, tendrás que firmar nuestro CLA:
- [CLA individual (ICLA)](https://github.com/alam00000/bentopdf/blob/main/ICLA.md)
- [CLA corporativo (CCLA)](https://github.com/alam00000/bentopdf/blob/main/CCLA.md)
## Obtener ayuda
- [GitHub Issues](https://github.com/alam00000/bentopdf/issues)
- [Comunidad de Discord](https://discord.gg/Bgq3Ay3f2w)
## Licencia
BentoPDF tiene doble licencia:
- **AGPL-3.0** para proyectos de código abierto en los que compartes públicamente todo tu código fuente
- **Licencia comercial** para aplicaciones propietarias o de código cerrado: [Obtén la licencia de por vida por $79](https://buy.polar.sh/polar_cl_ThDfffbl733x7oAodcIryCzhlO57ZtcWPq6HJ1qMChd)
Al contribuir, aceptas que tus contribuciones se licencien bajo estos términos.
docs/es/getting-started.md
+80
View File
@@ -0,0 +1,80 @@
# Primeros pasos
¡Bienvenido a BentoPDF! Esta guía te ayudará a ponerte en marcha rápidamente.
## ¿Qué es BentoPDF?
BentoPDF es un kit de herramientas PDF gratuito, de código abierto y centrado en la privacidad que funciona **por completo en tu navegador**. Tus archivos nunca salen de tu dispositivo: todo el procesamiento ocurre en local mediante tecnología WebAssembly (WASM).
## Inicio rápido
### Opción 1: Usar la versión alojada
Visita [bentopdf.com](https://www.bentopdf.com) para usar BentoPDF al instante, sin instalar nada.
### Opción 2: Autoalojar con Docker
> [!IMPORTANT]
> La conversión de archivos de Office requiere `SharedArrayBuffer`, que necesita las dos cosas siguientes:
>
> - `Cross-Origin-Opener-Policy: same-origin`
> - `Cross-Origin-Embedder-Policy: require-corp`
> - un contexto seguro
>
> `http://localhost` funciona para pruebas locales porque los navegadores consideran fiable la interfaz de loopback. `http://192.168.x.x` u otras IP de red local normalmente no, así que las conversiones de Word/Excel/PowerPoint requerirán HTTPS al acceder desde otros dispositivos de tu red.
```bash
# Pull and run the Docker image (self-hosted build)
docker run -d -p 3000:8080 ghcr.io/alam00000/bentopdf-simple:latest
# Or use Docker Compose
curl -O https://raw.githubusercontent.com/alam00000/bentopdf/main/docker-compose.yml
docker compose up -d
```
> [!TIP]
> BentoPDF se distribuye en dos versiones: la **versión autoalojada** (`bentopdf-simple`, la usada arriba) para despliegues internos, de equipo u organización, y la **versión comercial** (`bentopdf:latest`) que usa el propio bentopdf.com y los titulares de licencia comercial con despliegues públicos. Ambas incluyen las mismas herramientas PDF: la versión comercial añade el hero, las preguntas frecuentes, los testimonios y el pie de página de bentopdf.com. Si tienes dudas, usa la versión autoalojada.
Después abre `http://localhost:3000` en tu navegador.
> [!NOTE]
> Si estás preparando un despliegue de OCR aislado de la red (air-gapped), además del worker de Tesseract, el runtime principal y los archivos traineddata, debes alojar internamente las fuentes de la capa de texto del OCR. La configuración completa está documentada en [Autoalojamiento](/es/self-hosting/), incluidos `VITE_OCR_FONT_BASE_URL` y el directorio incluido `ocr-fonts/`.
### Opción 3: Compilar desde el código fuente
```bash
# Clone the repository
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
# Install dependencies
npm install
# Start development server
npm run dev
```
## Funciones de un vistazo
| Categoría | Herramientas |
| ----------------------- | --------------------------------------------------------------- |
| **Convertir a PDF** | Word, Excel, PowerPoint, imágenes, Markdown, EPUB, MOBI y más |
| **Convertir desde PDF** | JPG, PNG, texto, Excel, SVG y más |
| **Editar y anotar** | Firmar, resaltar, censurar, rellenar formularios, añadir sellos |
| **Organizar** | Unir, dividir, rotar, eliminar páginas, reordenar |
| **Optimizar** | Comprimir, reparar, aplanar, OCR |
| **Seguridad** | Cifrar, descifrar, quitar restricciones |
## Compatibilidad con navegadores
BentoPDF funciona mejor en navegadores modernos:
- ✅ Chrome/Edge 90+
- ✅ Firefox 90+
- ✅ Safari 15+
## Siguientes pasos
- [Explorar todas las herramientas](/es/tools/)
- [Autoalojar BentoPDF](/es/self-hosting/)
- [Contribuir al proyecto](/es/contributing)
docs/es/index.md
+42
View File
@@ -0,0 +1,42 @@
---
# https://vitepress.dev/reference/default-theme-home-page
layout: home
hero:
name: 'BentoPDF'
text: 'Herramientas PDF gratuitas y de código abierto'
tagline: Procesa PDF por completo en tu navegador. Sin cargas. Sin servidores. Privacidad total.
actions:
- theme: brand
text: Empezar
link: /es/getting-started
- theme: alt
text: Ver herramientas
link: /es/tools/
- theme: alt
text: Autoalojar
link: /es/self-hosting/
- theme: alt
text: Licencia comercial
link: /es/licensing
features:
- icon: 🔒
title: 100% privado
details: Tus archivos nunca salen de tu dispositivo. Todo el procesamiento ocurre en local en tu navegador mediante WebAssembly.
- icon: ⚡
title: Rápido y gratuito
details: Sin registros, sin límites, sin marcas de agua. Procesa PDF ilimitados gratis, para siempre.
- icon: 🛠️
title: Más de 50 herramientas
details: Convierte, edita, une, divide, comprime, firma, aplica OCR y más. Todo lo que necesitas en un solo lugar.
- icon: 🌐
title: Autoalojable
details: Despliégalo en tu propia infraestructura. Docker, Vercel, Netlify, AWS o entornos totalmente aislados de la red con workers de OCR, datos de idioma y fuentes de capa de texto autoalojados.
---
## OCR sin conexión
Si autoalojas BentoPDF en un entorno aislado de la red o sin conexión, el OCR necesita algo más que el worker de Tesseract y los archivos traineddata. La salida de PDF con texto buscable también necesita que las fuentes de la capa de texto del OCR se sirvan internamente.
Consulta [Autoalojamiento](/es/self-hosting/) para ver la configuración completa, incluidos `VITE_OCR_FONT_BASE_URL`, el directorio incluido `ocr-fonts/` y el flujo de trabajo aislado actualizado.
docs/es/licensing.md
+92
View File
@@ -0,0 +1,92 @@
# Commercial License
BentoPDF is dual-licensed under **AGPL-3.0** (for open-source projects) and a **Commercial License** (for proprietary/closed-source applications).
::: tip Full Details
For complete licensing information, delivery details, AGPL component notices, and invoicing, visit our [Licensing Page](https://www.bentopdf.com/licensing).
:::
## Get a Commercial License
**[Get Lifetime License for $79](https://buy.polar.sh/polar_cl_ThDfffbl733x7oAodcIryCzhlO57ZtcWPq6HJ1qMChd)**. A one-time purchase that includes all future updates forever.
## When Do You Need a Commercial License?
| Use Case | License Required |
| ------------------------------------------- | ---------------------- |
| Open-source project with public source code | AGPL-3.0 (Free) |
| Internal company tool (not distributed) | AGPL-3.0 (Free) |
| Proprietary/closed-source application | **Commercial License** |
| SaaS product without source code disclosure | **Commercial License** |
| Redistributing without AGPL compliance | **Commercial License** |
## Delivery & Licensing Model
- **No license key is required or provided.** BentoPDF intentionally does not use license keys to streamline deployment and reduce operational friction for users.
- Upon purchase, users receive a ZIP archive containing the complete BentoPDF source code and binaries.
- The source code provided is identical to the code published in our public open-source repository.
**GitHub Repository:** [github.com/alam00000/bentopdf](https://github.com/alam00000/bentopdf)
## Important Notice on Third-Party Components
::: info AGPL Components — Pre-configured via CDN
BentoPDF **does not bundle** AGPL-licensed processing libraries in its source code. These components are loaded at runtime from CDN URLs that are **pre-configured by default** — all features work out of the box with zero setup.
| Component | License | Status |
| --------------- | -------- | ---------------------- |
| **PyMuPDF** | AGPL-3.0 | Pre-configured via CDN |
| **Ghostscript** | AGPL-3.0 | Pre-configured via CDN |
| **CoherentPDF** | AGPL-3.0 | Pre-configured via CDN |
WASM module URLs are configured via environment variables at build time (`.env.production`). The defaults point to jsDelivr CDN. For custom deployments (air-gapped, self-hosted), you can override via environment variables, Docker build args, or per-user via **Advanced Settings** in the UI.
See [Self-Hosting > WASM Configuration](/es/self-hosting/#configuracion-de-wasm-componentes-agpl) for details.
This approach ensures:
- BentoPDF's core code remains under its dual-license (AGPL-3.0 / Commercial)
- WASM binaries are loaded at runtime, not included in the source
- Clear compliance boundaries for commercial users
:::
::: tip Commercial License & AGPL Features
The commercial license covers BentoPDF's own code. If you configure and use AGPL components (PyMuPDF, Ghostscript, CoherentPDF), you must still comply with their respective AGPL-3.0 license terms, which may require source code disclosure if you distribute modified versions.
:::
## Invoicing
- Payments are handled by [Polar](https://polar.sh), which automatically emails an invoice after purchase.
- Polar handles VAT invoices for businesses in applicable regions. Select **"I'm purchasing as a business"** at checkout and enter your billing address and Tax/VAT number.
**Questions?** Contact [contact@bentopdf.com](mailto:contact@bentopdf.com) with your purchase details.
## What's Included
| Feature | Included |
| ----------------------------- | -------------- |
| Full source code | ✅ |
| All 50+ PDF tools | ✅ |
| Self-hosting rights | ✅ |
| Lifetime updates | ✅ |
| Remove branding (Simple Mode) | ✅ |
| Commercial support | ✅ (via email) |
| Priority feature requests | ✅ |
## FAQ
### Do I need a license key to use BentoPDF?
No. BentoPDF does not use license keys. The commercial license grants you legal rights to use the software in proprietary applications.
### Can I use BentoPDF in my SaaS product?
Yes, with a commercial license. Without it, you must comply with AGPL-3.0, which requires you to make your full source code available to users.
### What about the AGPL components?
Components like CoherentPDF are licensed under AGPL v3 and remain under that license. The commercial license covers BentoPDF's own code but does not override third-party AGPL obligations.
### How do I get an invoice?
Polar emails your invoice automatically after purchase. For a VAT invoice, select "I'm purchasing as a business" at checkout. If you need anything else, email [contact@bentopdf.com](mailto:contact@bentopdf.com) with your purchase details.
docs/es/self-hosting/apache.md
+275
View File
@@ -0,0 +1,275 @@
# Desplegar con Apache
Aloja BentoPDF con Apache HTTP Server.
## Requisitos previos
- Apache 2.4+
- mod_rewrite habilitado
- Certificado SSL (recomendado)
## Paso 1: Compilar el proyecto
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
npm install
npm run build
```
Para personalizar la marca, define variables de entorno antes de compilar:
```bash
VITE_BRAND_NAME="AcmePDF" VITE_BRAND_LOGO="images/acme-logo.svg" npm run build
```
## Paso 2: Copiar los archivos
```bash
sudo mkdir -p /var/www/bentopdf
sudo cp -r dist/* /var/www/bentopdf/
sudo chown -R www-data:www-data /var/www/bentopdf
```
## Paso 3: Configuración de Apache
Crea `/etc/apache2/sites-available/bentopdf.conf`:
```apache
<VirtualHost *:80>
ServerName your-domain.com
Redirect permanent / https://your-domain.com/
</VirtualHost>
<VirtualHost *:443>
ServerName your-domain.com
DocumentRoot /var/www/bentopdf
SSLEngine on
SSLCertificateFile /etc/letsencrypt/live/your-domain.com/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/your-domain.com/privkey.pem
<Directory /var/www/bentopdf>
Options -Indexes +FollowSymLinks
AllowOverride All
Require all granted
</Directory>
# WASM MIME type
AddType application/wasm .wasm
# Prevent double-compression of pre-compressed files
SetEnvIfNoCase Request_URI "\.gz$" no-gzip
# Compression
<IfModule mod_deflate.c>
AddOutputFilterByType DEFLATE text/html text/plain text/css application/javascript application/json application/wasm
</IfModule>
# Cache headers
<IfModule mod_expires.c>
ExpiresActive On
ExpiresByType application/javascript "access plus 1 year"
ExpiresByType text/css "access plus 1 year"
ExpiresByType application/wasm "access plus 1 year"
ExpiresByType image/png "access plus 1 year"
ExpiresByType image/svg+xml "access plus 1 year"
</IfModule>
# Required headers for SharedArrayBuffer (LibreOffice WASM)
Header always set Cross-Origin-Embedder-Policy "require-corp"
Header always set Cross-Origin-Opener-Policy "same-origin"
Header always set Cross-Origin-Resource-Policy "cross-origin"
# Security headers
Header always set X-Frame-Options "SAMEORIGIN"
Header always set X-Content-Type-Options "nosniff"
# Pre-compressed LibreOffice WASM files
<FilesMatch "soffice\.wasm\.gz$">
ForceType application/wasm
Header set Content-Encoding "gzip"
</FilesMatch>
<FilesMatch "soffice\.data\.gz$">
ForceType application/octet-stream
Header set Content-Encoding "gzip"
</FilesMatch>
</VirtualHost>
```
## Paso 4: .htaccess para el enrutamiento
Crea `/var/www/bentopdf/.htaccess`:
```apache
RewriteEngine On
RewriteBase /
# Existing files/dirs - serve directly
RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^ - [L]
# ============================================
# LANGUAGE ROUTES
# ============================================
# Supported languages: de, es, zh, zh-TW, vi, it, id, tr, fr, pt
# English has no prefix - served from root
# English prefix redirects to root
RewriteRule ^en/?$ / [R=301,L]
RewriteRule ^en/(.+)$ /$1 [R=301,L]
# Language prefix root (e.g., /de/ -> /de/index.html)
RewriteCond %{DOCUMENT_ROOT}/$1/index.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/?$ /$1/index.html [L]
# Language prefix with path (e.g., /de/merge-pdf -> /de/merge-pdf.html)
RewriteCond %{DOCUMENT_ROOT}/$1/$2.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/([^/]+)/?$ /$1/$2.html [L]
# ============================================
# ADD .HTML EXTENSION (ROOT LEVEL)
# ============================================
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME}.html -f
RewriteRule ^([^/]+)$ $1.html [L]
ErrorDocument 404 /404.html
```
## Paso 5: Habilitar los módulos necesarios
```bash
sudo a2enmod rewrite
sudo a2enmod ssl
sudo a2enmod headers
sudo a2enmod expires
sudo a2enmod deflate
```
## Paso 6: Habilitar el sitio
```bash
sudo a2ensite bentopdf.conf
sudo apache2ctl configtest
sudo systemctl reload apache2
```
## Despliegue en un subdirectorio
Para alojarlo en `/pdf/`:
1. Compila con la URL base:
```bash
BASE_URL=/pdf/ npm run build
```
2. Actualiza `.htaccess`:
```apache
RewriteEngine On
RewriteBase /pdf/
# Existing files/dirs - serve directly
RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^ - [L]
# Language routes
RewriteRule ^en/?$ /pdf/ [R=301,L]
RewriteRule ^en/(.+)$ /pdf/$1 [R=301,L]
RewriteCond %{DOCUMENT_ROOT}/pdf/$1/index.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/?$ /pdf/$1/index.html [L]
RewriteCond %{DOCUMENT_ROOT}/pdf/$1/$2.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/([^/]+)/?$ /pdf/$1/$2.html [L]
# Root level .html extension
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME}.html -f
RewriteRule ^([^/]+)$ $1.html [L]
ErrorDocument 404 /pdf/404.html
```
## Solución de problemas
### Errores 404 de WASM
Asegúrate de que el tipo MIME esté configurado:
```apache
AddType application/wasm .wasm
```
### Firmar PDF o el rellenador de formularios muestra un visor en blanco (error MIME de `.mjs`)
Si la consola del navegador muestra:
```
Failed to load module script: The server responded with a non-JavaScript
MIME type of "application/octet-stream". Strict MIME type checking is
enforced for module scripts per HTML spec.
```
...y la solicitud que falla termina en `.mjs`, a tu configuración de Apache le falta la asignación `.mjs → application/javascript`. El visor de PDF incluido usa módulos ES con extensión `.mjs`, y el `mime.types` de serie de Apache no los incluye por defecto.
Añade esto a tu VirtualHost o a `.htaccess`:
```apache
AddType application/javascript .mjs
```
Después recarga Apache:
```bash
sudo apache2ctl configtest && sudo systemctl reload apache2
```
Para confirmarlo: en las DevTools del navegador, pestaña Network, busca la solicitud `.mjs` que falla y revisa la cabecera de respuesta `Content-Type`. Ahora debería ser `application/javascript`, no `application/octet-stream`.
### La reescritura no funciona
Comprueba que mod_rewrite esté habilitado:
```bash
sudo a2enmod rewrite
```
### Word/ODT/Excel a PDF no funciona
LibreOffice WASM requiere `SharedArrayBuffer`, que necesita estas cabeceras:
```apache
Header always set Cross-Origin-Embedder-Policy "require-corp"
Header always set Cross-Origin-Opener-Policy "same-origin"
```
También necesita un contexto seguro. `http://localhost` funciona para pruebas locales, pero `http://192.168.x.x` u otras IP de red local normalmente requieren HTTPS. Si las cabeceras están presentes pero `window.crossOriginIsolated` sigue siendo `false`, comprueba si la página se abre por HTTP simple desde un origen que no es de loopback.
Los archivos precomprimidos `.wasm.gz` y `.data.gz` también necesitan el `Content-Encoding` correcto:
```apache
<FilesMatch "soffice\.wasm\.gz$">
ForceType application/wasm
Header set Content-Encoding "gzip"
</FilesMatch>
<FilesMatch "soffice\.data\.gz$">
ForceType application/octet-stream
Header set Content-Encoding "gzip"
</FilesMatch>
```
Asegúrate de que `mod_headers` esté habilitado: `sudo a2enmod headers`
### Permiso denegado
```bash
sudo chown -R www-data:www-data /var/www/bentopdf
sudo chmod -R 755 /var/www/bentopdf
```
docs/es/self-hosting/aws.md
+200
View File
@@ -0,0 +1,200 @@
# Desplegar en AWS S3 + CloudFront
Aloja BentoPDF en AWS para obtener el máximo control y escalabilidad.
## Arquitectura
```
User → CloudFront (CDN) → S3 (Static Files)
```
## Paso 1: Crear el bucket de S3
```bash
# Create bucket
aws s3 mb s3://your-bentopdf-bucket --region us-east-1
# Enable static website hosting
aws s3 website s3://your-bentopdf-bucket \
--index-document index.html \
--error-document index.html
```
## Paso 2: Compilar y subir
```bash
# Build the project (optionally with custom branding)
# VITE_BRAND_NAME="AcmePDF" VITE_BRAND_LOGO="images/acme-logo.svg" npm run build
npm run build
# Sync to S3
aws s3 sync dist/ s3://your-bentopdf-bucket \
--delete \
--cache-control "max-age=31536000"
# Set correct MIME types for WASM
aws s3 cp s3://your-bentopdf-bucket/ s3://your-bentopdf-bucket/ \
--recursive \
--exclude "*" \
--include "*.wasm" \
--content-type "application/wasm" \
--metadata-directive REPLACE
# Set correct MIME type for ES module files (.mjs)
# S3 defaults .mjs to application/octet-stream, which browsers refuse to
# execute as ES modules. The bundled PDF viewer (Sign PDF, Form Filler)
# ships ES modules with .mjs extensions and will fail without this step.
aws s3 cp s3://your-bentopdf-bucket/ s3://your-bentopdf-bucket/ \
--recursive \
--exclude "*" \
--include "*.mjs" \
--content-type "application/javascript" \
--metadata-directive REPLACE
```
## Paso 3: Crear la distribución de CloudFront
```bash
aws cloudfront create-distribution \
--origin-domain-name your-bentopdf-bucket.s3.amazonaws.com \
--default-root-object index.html
```
O usa la consola de AWS:
1. Ve a CloudFront → Create distribution
2. Origin domain: selecciona tu bucket de S3
3. Activa "Origin Access Control"
4. Default root object: `index.html`
5. Crea la distribución
## Paso 3b: Política de cabeceras de respuesta (necesaria para LibreOffice WASM)
Las conversiones basadas en LibreOffice (Word, Excel, PowerPoint a PDF) requieren `SharedArrayBuffer`, que necesita cabeceras de respuesta específicas. Crea una Response Headers Policy de CloudFront:
1. Ve a CloudFront → Policies → Response headers
2. Crea una política personalizada con estas cabeceras:
| Cabecera | Valor |
| ------------------------------ | -------------- |
| `Cross-Origin-Embedder-Policy` | `require-corp` |
| `Cross-Origin-Opener-Policy` | `same-origin` |
| `Cross-Origin-Resource-Policy` | `cross-origin` |
3. Asocia la política al comportamiento de caché predeterminado de tu distribución
O mediante la CLI:
```bash
aws cloudfront create-response-headers-policy \
--response-headers-policy-config '{
"Name": "BentoPDF-COEP-COOP",
"CustomHeadersConfig": {
"Quantity": 3,
"Items": [
{"Header": "Cross-Origin-Embedder-Policy", "Value": "require-corp", "Override": true},
{"Header": "Cross-Origin-Opener-Policy", "Value": "same-origin", "Override": true},
{"Header": "Cross-Origin-Resource-Policy", "Value": "cross-origin", "Override": true}
]
}
}'
```
## Paso 3c: Metadatos de S3 para los archivos WASM precomprimidos
Los archivos WASM de LibreOffice están precomprimidos (`.wasm.gz`, `.data.gz`). Define el Content-Type y el Content-Encoding correctos para que los navegadores los descompriman:
```bash
# Set correct headers for soffice.wasm.gz
aws s3 cp s3://your-bentopdf-bucket/libreoffice-wasm/soffice.wasm.gz \
s3://your-bentopdf-bucket/libreoffice-wasm/soffice.wasm.gz \
--content-type "application/wasm" \
--content-encoding "gzip" \
--metadata-directive REPLACE
# Set correct headers for soffice.data.gz
aws s3 cp s3://your-bentopdf-bucket/libreoffice-wasm/soffice.data.gz \
s3://your-bentopdf-bucket/libreoffice-wasm/soffice.data.gz \
--content-type "application/octet-stream" \
--content-encoding "gzip" \
--metadata-directive REPLACE
```
::: warning Importante
Sin la política de cabeceras de respuesta, `SharedArrayBuffer` no está disponible y las conversiones de LibreOffice WASM se quedarán colgadas en torno al 55 %. Sin el Content-Encoding correcto en los archivos `.gz`, el navegador recibe bytes gzip sin procesar y la compilación de WASM falla.
:::
## Paso 4: Política del bucket de S3
Permite que CloudFront acceda al bucket:
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowCloudFrontAccess",
"Effect": "Allow",
"Principal": {
"Service": "cloudfront.amazonaws.com"
},
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::your-bentopdf-bucket/*",
"Condition": {
"StringEquals": {
"AWS:SourceArn": "arn:aws:cloudfront::ACCOUNT_ID:distribution/DISTRIBUTION_ID"
}
}
}
]
}
```
## Paso 5: Páginas de error personalizadas
Configura el 404 para que devuelva `index.html` y funcione el enrutamiento SPA:
1. CloudFront → Error pages
2. Crea una respuesta de error personalizada:
- HTTP error code: 404
- Response page path: `/index.html`
- HTTP response code: 200
## Estimación de costes
| Recurso | Coste estimado |
| ---------------------------------- | -------------- |
| Almacenamiento S3 (~500MB) | ~$0.01/mes |
| CloudFront (1TB de transferencia) | ~$85/mes |
| CloudFront (10GB de transferencia) | ~$0.85/mes |
::: tip
Usa S3 Intelligent Tiering para optimizar costes en archivos a los que se accede con poca frecuencia.
:::
## Automatización con Terraform
```hcl
# main.tf
resource "aws_s3_bucket" "bentopdf" {
bucket = "your-bentopdf-bucket"
}
resource "aws_cloudfront_distribution" "bentopdf" {
origin {
domain_name = aws_s3_bucket.bentopdf.bucket_regional_domain_name
origin_id = "S3Origin"
}
enabled = true
default_root_object = "index.html"
default_cache_behavior {
allowed_methods = ["GET", "HEAD"]
cached_methods = ["GET", "HEAD"]
target_origin_id = "S3Origin"
viewer_protocol_policy = "redirect-to-https"
}
}
```
docs/es/self-hosting/cloudflare.md
+154
View File
@@ -0,0 +1,154 @@
# Desplegar en Cloudflare Pages
[Cloudflare Pages](https://pages.cloudflare.com) ofrece alojamiento estático global y rápido con ancho de banda ilimitado.
## Despliegue rápido
1. Ve a [Cloudflare Pages](https://dash.cloudflare.com/?to=/:account/pages)
2. Haz clic en "Create a project"
3. Conecta tu repositorio de GitHub
## Configuración de compilación
| Ajuste | Valor |
| ---------------------- | --------------- |
| Framework preset | None |
| Build command | `npm run build` |
| Build output directory | `dist` |
| Root directory | `/` |
## Variables de entorno
Añádelas en Settings → Environment variables:
| Variable | Value |
| ----------------------- | ------------------------------------------------------------ |
| `NODE_VERSION` | `18` |
| `SIMPLE_MODE` | `false` (opcional) |
| `VITE_BRAND_NAME` | Nombre de marca personalizado (opcional) |
| `VITE_BRAND_LOGO` | Ruta del logo relativa a `public/` (opcional) |
| `VITE_FOOTER_TEXT` | Texto personalizado de pie/copyright (opcional) |
| `VITE_DEFAULT_LANGUAGE` | Idioma predeterminado de la interfaz, p. ej. `fr` (opcional) |
## Archivo de configuración
Crea `_headers` en tu carpeta `public`:
```
# Required security headers for SharedArrayBuffer (used by LibreOffice WASM)
/*
Cross-Origin-Embedder-Policy: require-corp
Cross-Origin-Opener-Policy: same-origin
Cross-Origin-Resource-Policy: cross-origin
# Pre-compressed LibreOffice WASM binary
/libreoffice-wasm/soffice.wasm.gz
Content-Type: application/wasm
Content-Encoding: gzip
Cache-Control: public, max-age=31536000, immutable
# Pre-compressed LibreOffice WASM data
/libreoffice-wasm/soffice.data.gz
Content-Type: application/octet-stream
Content-Encoding: gzip
Cache-Control: public, max-age=31536000, immutable
# Cache WASM files aggressively
/*.wasm
Cache-Control: public, max-age=31536000, immutable
Content-Type: application/wasm
# Service worker
/sw.js
Cache-Control: no-cache
```
::: warning Importante
Las cabeceras `Cross-Origin-Embedder-Policy` y `Cross-Origin-Opener-Policy` son necesarias para las conversiones de Word/ODT/Excel/PowerPoint a PDF. Sin ellas, `SharedArrayBuffer` no está disponible y el motor LibreOffice WASM no se podrá inicializar.
:::
Crea `_redirects` para el enrutamiento SPA:
```
/* /index.html 200
```
## Dominio personalizado
1. Ve a tu proyecto de Pages
2. Haz clic en "Custom domains"
3. Añade tu dominio
4. Cloudflare configurará el DNS automáticamente si el dominio está en Cloudflare
## Ventajas
- **Ancho de banda ilimitado y gratuito**
- **CDN global** con más de 300 ubicaciones edge
- **HTTPS automático**
- **Despliegues de vista previa** para pull requests
- **Compilaciones rápidas**
## Solución de problemas
### Subida de archivos grandes
Cloudflare Pages admite archivos de hasta 25 MB. Los módulos WASM deberían caber, pero si llegas a los límites, considera:
```bash
# Split large files during build
npm run build
```
### Límites de tamaño del Worker
Si usas Cloudflare Workers para un enrutamiento avanzado, ten en cuenta el límite de 1 MB de los planes gratuitos.
## Worker de proxy CORS (para firmas digitales)
La herramienta de firma digital necesita un proxy CORS para obtener las cadenas de certificados. Despliega el worker incluido:
```bash
cd cloudflare
npx wrangler login
npx wrangler deploy
```
### Funciones de seguridad
| Función | Descripción |
| --------------------------- | ------------------------------------ |
| **Restricciones de URL** | Solo se permiten URL de certificados |
| **Límite de tamaño** | Máx. 10MB por solicitud |
| **Limitación de velocidad** | 60 solicitudes/IP/min (requiere KV) |
| **Bloqueo de IP privadas** | Bloquea localhost e IP internas |
### Activar la limitación de velocidad
```bash
# Create KV namespace
npx wrangler kv namespace create "RATE_LIMIT_KV"
# Add to wrangler.toml with returned ID:
# [[kv_namespaces]]
# binding = "RATE_LIMIT_KV"
# id = "YOUR_ID"
npx wrangler deploy
```
### Compilar con la URL del proxy
```bash
VITE_CORS_PROXY_URL=https://your-worker.workers.dev npm run build
```
O con Docker:
```bash
export VITE_CORS_PROXY_URL="https://your-worker.workers.dev"
DOCKER_BUILDKIT=1 docker build \
--secret id=VITE_CORS_PROXY_URL,env=VITE_CORS_PROXY_URL \
-t your-bentopdf .
```
> **Nota:** Consulta el [README](https://github.com/alam00000/bentopdf#digital-signature-cors-proxy-required) para configurar la firma HMAC.
docs/es/self-hosting/cors-proxy.md
+180
View File
@@ -0,0 +1,180 @@
# Proxy CORS para obtener certificados
La herramienta de firma digital usa un proxy CORS para obtener los certificados de los emisores desde Autoridades de Certificación (CA) externas. Es necesario porque muchos servidores de CA no incluyen cabeceras CORS en sus respuestas, lo que impide la descarga directa desde el navegador.
Además, muchos servidores de CA sirven los certificados por HTTP simple. Cuando tu instancia de BentoPDF se aloja por HTTPS, los navegadores bloquean estas solicitudes HTTP (política de contenido mixto). El proxy CORS resuelve ambos problemas al enrutar las solicitudes a través de un endpoint HTTPS con las cabeceras adecuadas.
## Cómo funciona
Al firmar un PDF con un certificado:
1. La biblioteca `zgapdfsigner` intenta construir una cadena de certificados completa
2. Obtiene los certificados de los emisores desde las URL incluidas en la extensión AIA (Authority Information Access) de tu certificado
3. Estas solicitudes pasan por un proxy CORS que añade las cabeceras `Access-Control-Allow-Origin` necesarias
4. El proxy devuelve los datos del certificado al navegador
## Autoalojar el proxy CORS
Si autoalojas BentoPDF, tendrás que desplegar tu propio proxy CORS para que las firmas digitales funcionen con certificados que requieren obtener la cadena.
### Opción 1: Cloudflare Workers (recomendada)
1. **Instala la CLI de Wrangler**:
```bash
npm install -g wrangler
```
2. **Inicia sesión en Cloudflare**:
```bash
wrangler login
```
3. **Clona BentoPDF y actualiza los orígenes permitidos**:
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf/cloudflare
```
Abre `cors-proxy-worker.js` y cambia el array `ALLOWED_ORIGINS` por tu dominio:
```js
const ALLOWED_ORIGINS = [
'https://your-domain.com',
'https://www.your-domain.com',
];
```
::: warning Importante
Sin este cambio, el proxy rechazará todas las solicitudes de tu sitio con un error **403 Forbidden**. Por defecto solo permite solicitudes de `bentopdf.com`.
:::
4. **Despliega el proxy**:
```bash
wrangler deploy
```
Anota la URL de tu worker (p. ej., `https://bentopdf-cors-proxy.your-subdomain.workers.dev`).
5. **Vuelve a compilar BentoPDF con la URL del proxy**:
Si usas Docker:
```bash
export VITE_CORS_PROXY_URL="https://your-worker.workers.dev"
DOCKER_BUILDKIT=1 docker build \
--secret id=VITE_CORS_PROXY_URL,env=VITE_CORS_PROXY_URL \
-t your-bentopdf .
```
Si compilas desde el código fuente:
```bash
VITE_CORS_PROXY_URL=https://your-worker.workers.dev npm run build
```
### Opción 2: Proxy de backend personalizado
También puedes crear tu propio endpoint de proxy. Los requisitos son:
1. Aceptar solicitudes GET con un parámetro de consulta `url`
2. Obtener la URL desde tu servidor (sin restricciones CORS en el lado del servidor)
3. Devolver la respuesta con estas cabeceras:
- `Access-Control-Allow-Origin: https://your-domain.com`
- `Access-Control-Allow-Methods: GET, OPTIONS`
- `X-Content-Type-Options: nosniff`
Ejemplo de implementación con Express.js:
```javascript
app.get('/api/cert-proxy', async (req, res) => {
const targetUrl = req.query.url;
// Validate it's a certificate URL
if (!isValidCertUrl(targetUrl)) {
return res.status(400).json({ error: 'Invalid URL' });
}
try {
const response = await fetch(targetUrl);
const data = await response.arrayBuffer();
res.set('Access-Control-Allow-Origin', 'https://your-domain.com');
res.set('Content-Type', 'application/octet-stream');
res.set('X-Content-Type-Options', 'nosniff');
res.send(Buffer.from(data));
} catch (error) {
res.status(500).json({ error: 'Proxy error' });
}
});
```
## Consideraciones de seguridad
El Cloudflare Worker incluido tiene varias medidas de seguridad:
| Función | Descripción |
| ------------------------------ | ------------------------------------------------------------------------------------------------------ |
| **Validación de origen** | Solo permite solicitudes de los dominios incluidos en `ALLOWED_ORIGINS` |
| **Restricciones de URL** | Solo permite URL de certificados (`.crt`, `.cer`, `.pem`, `/certs/`, `/ocsp`, `/crl`) |
| **Bloqueo de IP privadas** | Bloquea rangos privados IPv4/IPv6, link-local, loopback, IP decimales y metadatos de la nube |
| **Seguridad del Content-Type** | Solo devuelve tipos MIME de certificado seguros y bloquea la inyección de content-type desde el origen |
| **Límite de tamaño** | Transmite la respuesta con un límite de 10MB y aborta la descarga si se supera |
| **Limitación de velocidad** | 60 solicitudes por minuto por IP o IPv6 /64 (requiere KV, permite el paso si KV falla) |
| **Firmas HMAC** | Firma opcional en el cliente (disuade el abuso casual) |
### Reenlace de DNS (DNS rebinding) al autoalojar fuera de Cloudflare
El worker rechaza cualquier URL que se resuelva a una IP privada o interna. No puede usar una lista fija de hosts permitidos, ya que las URL de la cadena de certificados apuntan a la CA que emitió el certificado (FNMT, CA corporativas, etc.), por lo que los destinos no se conocen de antemano. Eso deja una pequeña ventana de rebinding: quien controle el DNS de su propio dominio podría devolver una IP pública a la comprobación de seguridad y una privada a la solicitud real un instante después.
En Cloudflare esto no es explotable: los Workers no pueden alcanzar IP privadas ni el endpoint de metadatos `169.254.169.254`, así que el rebinding no llega a nada. Simplemente no le des al worker una vía de entrada: no le asocies un Tunnel, un Service ni un binding de red privada (solo necesita `RATE_LIMIT_KV`).
Si lo ejecutas fuera de Cloudflare (workerd, Node y similares) dentro de una VPC, el runtime _sí_ puede alcanzar IP internas. Coloca un firewall de salida delante y bloquea los rangos privados: `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`, `127.0.0.0/8`, `169.254.0.0/16` y sus equivalentes IPv6. El código de la aplicación no puede imponerlo una vez que estás fuera de Cloudflare.
## Desactivar el proxy
Si no quieres usar un proxy CORS, define la variable de entorno como una cadena vacía:
```
VITE_CORS_PROXY_URL=
```
**Nota**: Sin el proxy, firmar con certificados que requieren obtener la cadena externamente (como FNMT o algunas CA corporativas) fallará con el error "Failed to fetch".
## Solución de problemas
### "Signing error: TypeError: Failed to fetch"
Normalmente significa una de estas cosas:
1. **No hay proxy CORS configurado**: define `VITE_CORS_PROXY_URL` y vuelve a compilar
2. **Contenido mixto bloqueado**: tu sitio usa HTTPS pero la URL del emisor del certificado es HTTP. El proxy CORS lo resuelve.
3. **El proxy CORS rechaza tu origen**: comprueba que tu dominio esté en el array `ALLOWED_ORIGINS` de `cors-proxy-worker.js`
### "403 Forbidden" del proxy
Tu dominio no está en la lista `ALLOWED_ORIGINS`. Edita `cors-proxy-worker.js`:
```js
const ALLOWED_ORIGINS = ['https://your-domain.com'];
```
Después vuelve a desplegar: `npx wrangler deploy`
### Probar el proxy
```bash
curl -H "Origin: https://your-domain.com" \
"https://your-proxy.workers.dev?url=http://www.cert.fnmt.es/certs/ACUSU.crt"
```
### Certificados que funcionan sin proxy
Algunos certificados incluyen la cadena completa en el archivo P12/PFX y no requieren obtención externa:
- Certificados autofirmados
- Algunas CA comerciales que incluyen los certificados intermedios
- Certificados que has ensamblado manualmente con la cadena completa
docs/es/self-hosting/docker.md
+622
View File
@@ -0,0 +1,622 @@
# Desplegar con Docker / Podman
La forma más sencilla de autoalojar BentoPDF en un entorno de producción.
> [!IMPORTANT]
> **Cabeceras necesarias para la conversión de archivos de Office**
>
> Las herramientas basadas en LibreOffice (conversión de Word, Excel y PowerPoint) requieren estas cabeceras HTTP para admitir `SharedArrayBuffer`:
>
> - `Cross-Origin-Opener-Policy: same-origin`
> - `Cross-Origin-Embedder-Policy: require-corp`
>
> La página también debe servirse desde un contexto seguro. `http://localhost` funciona para pruebas locales, pero `http://192.168.x.x` u otras IP de red local normalmente no cumplen el requisito, así que la conversión de Office por HTTP simple fallará aunque las cabeceras estén presentes.
>
> Las imágenes de contenedor oficiales incluyen estas cabeceras. Si usas un proxy inverso (Traefik, Caddy, etc.), asegúrate de que estas cabeceras se conserven o se añadan, y usa HTTPS para el acceso que no sea loopback.
> [!TIP]
> **Usuarios de Podman:** todos los comandos `docker` funcionan con Podman sustituyendo `docker` por `podman` y `docker-compose` por `podman-compose`.
## Inicio rápido
> [!TIP]
> BentoPDF se distribuye en dos versiones:
>
> - **Versión autoalojada**: `ghcr.io/alam00000/bentopdf-simple:latest`. Todas las herramientas PDF, **sin** el aparato de marketing (sin hero, preguntas frecuentes, testimonios ni pie de página). Úsala para despliegues internos, de equipo u organización. **No** es una versión "lite" con menos funciones.
> - **Versión comercial**: `ghcr.io/alam00000/bentopdf:latest`. El sitio de marketing completo, usado por el propio bentopdf.com y por los titulares de licencia comercial con despliegues públicos.
>
> Si tienes dudas: descarga la versión autoalojada.
```bash
# Docker
docker run -d \
--name bentopdf \
-p 3000:8080 \
--restart unless-stopped \
ghcr.io/alam00000/bentopdf-simple:latest
# Podman
podman run -d \
--name bentopdf \
-p 3000:8080 \
ghcr.io/alam00000/bentopdf-simple:latest
```
## Docker Compose / Podman Compose
Crea `docker-compose.yml`:
```yaml
services:
bentopdf:
image: ghcr.io/alam00000/bentopdf-simple:latest
container_name: bentopdf
ports:
- '3000:8080'
restart: unless-stopped
healthcheck:
test: ['CMD', 'wget', '--spider', '-q', 'http://localhost:8080']
interval: 30s
timeout: 10s
retries: 3
```
Ejecuta:
```bash
# Docker Compose
docker compose up -d
# Podman Compose
podman-compose up -d
```
## Crear tu propia imagen
```dockerfile
# Dockerfile
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build
FROM nginxinc/nginx-unprivileged:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/nginx.conf
EXPOSE 8080
CMD ["nginx", "-g", "daemon off;"]
```
Compila y ejecuta:
```bash
docker build -t bentopdf:custom .
docker run -d -p 3000:8080 bentopdf:custom
```
## Variables de entorno
| Variable | Descripción | Predeterminado |
| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------- |
| `SIMPLE_MODE` | Compila la variante autoalojada (oculta el aparato de marketing de bentopdf.com: hero, preguntas frecuentes, testimonios y pie de página). Se mantienen todas las herramientas PDF. | `false` |
| `BASE_URL` | Desplegar en un subdirectorio | `/` |
| `VITE_WASM_PYMUPDF_URL` | URL del módulo WASM de PyMuPDF | `https://cdn.jsdelivr.net/npm/@bentopdf/pymupdf-wasm@0.11.16/` |
| `VITE_WASM_GS_URL` | URL del módulo WASM de Ghostscript | `https://cdn.jsdelivr.net/npm/@bentopdf/gs-wasm@0.1.1/assets/` |
| `VITE_WASM_CPDF_URL` | URL del módulo WASM de CoherentPDF | `https://cdn.jsdelivr.net/npm/coherentpdf@2.5.5/dist/` |
| `VITE_TESSERACT_WORKER_URL` | URL del script del worker de OCR | _(vacío; usa la CDN predeterminada de Tesseract.js)_ |
| `VITE_TESSERACT_CORE_URL` | Directorio del runtime principal de OCR | _(empty; use Tesseract.js default CDN)_ |
| `VITE_TESSERACT_LANG_URL` | Directorio de traineddata de OCR | _(empty; use Tesseract.js default CDN)_ |
| `VITE_TESSERACT_AVAILABLE_LANGUAGES` | Idiomas de OCR separados por comas que se muestran en la interfaz | _(vacío; muestra el catálogo completo)_ |
| `VITE_OCR_FONT_BASE_URL` | Directorio de fuentes de la capa de texto del OCR | _(vacío; usa las URL remotas de las fuentes Noto)_ |
| `VITE_DEFAULT_LANGUAGE` | Idioma predeterminado de la interfaz | `en` |
| `VITE_BRAND_NAME` | Nombre de marca personalizado | `BentoPDF` |
| `VITE_BRAND_LOGO` | Ruta del logo relativa a `public/` | `images/favicon-no-bg.svg` |
| `VITE_FOOTER_TEXT` | Texto personalizado de pie/copyright | `© 2026 BentoPDF. All rights reserved.` |
| `DISABLE_TOOLS` | IDs de herramientas separados por comas para ocultar | _(vacío; todas las herramientas activadas)_ |
| `DISABLE_GITHUB_STARS` | Omite la obtención del contador de estrellas de GitHub al cargar la página y elimina `api.github.com` de la CSP. Las compilaciones en Simple Mode siempre la omiten. | `false` |
| `SITE_URL` | URL pública escrita en los enlaces canonical, hreflang y de sitemap. Déjala por defecto salvo que quieras que los buscadores traten tu despliegue como un sitio propio. | `https://www.bentopdf.com` |
| `ALLOW_INDEXING` | Con un `SITE_URL` personalizado, todas las páginas se marcan como `noindex` para que tu copia no compita con bentopdf.com en los resultados de búsqueda. Ponlo en `true` para que los buscadores la indexen. | `false` |
Las URL de los módulos WASM vienen preconfiguradas con valores predeterminados de CDN, así que todas las funciones avanzadas funcionan desde el primer momento. Sobrescríbelas para despliegues aislados de la red o autoalojados.
### Buscadores
Por defecto, todas las páginas indican a los buscadores que el original es bentopdf.com, de modo que tu despliegue no aparece como duplicado. No necesitas cambiar nada para una instancia privada o interna.
- **Mantener tu instancia fuera de los resultados de búsqueda por completo:** ejecuta el contenedor con `-e ROBOTS_NOINDEX=true`. Solo requiere un reinicio, no una nueva compilación.
- **Hacer que tu instancia sea un sitio propio en los resultados de búsqueda:** compila con `--build-arg SITE_URL=https://your-domain.example --build-arg ALLOW_INDEXING=true`. Sin `ALLOW_INDEXING=true`, un `SITE_URL` personalizado marca todas las páginas como `noindex`.
### Content-Security-Policy
La imagen de nginx incluye una cabecera `Content-Security-Policy` en modo de aplicación. Las directivas `script-src`, `connect-src` y `font-src` de la CSP se **generan en tiempo de compilación** a partir de las variables de URL `VITE_*` anteriores: los hosts que pases mediante `--build-arg` se añaden automáticamente a la política.
Como resultado:
- Si sobrescribes `VITE_CORS_PROXY_URL` o `VITE_WASM_*_URL` al compilar, la CSP permite esos orígenes automáticamente, sin configuración adicional.
- Para las URL en `cdn.jsdelivr.net`, `script-src` solo permite la carpeta exacta del paquete con su versión, por ejemplo `https://cdn.jsdelivr.net/npm/@bentopdf/pymupdf-wasm@0.11.16/`, no toda la CDN. jsDelivr sirve cualquier paquete público de npm o repositorio de GitHub, así que permitir todo el host dejaría que cualquiera de ellos se ejecutara en tu instancia. Las URL de cualquier otro host se permiten por origen.
- Si configuras URL de WASM personalizadas en _tiempo de ejecución_ desde la página de Ajustes avanzados de la aplicación, esos orígenes **no** están en la CSP y el navegador bloqueará las solicitudes a ellos. Esto también se aplica a una versión distinta del mismo paquete en `cdn.jsdelivr.net`, porque solo se permite la versión definida al compilar. La configuración en tiempo de ejecución está pensada para experimentar; para URL personalizadas permanentes, define el build arg `VITE_*` correspondiente.
- Los despliegues aislados de la red que sobrescriben los tres valores `VITE_WASM_*_URL` también eliminan de la CSP esas carpetas de paquete de `cdn.jsdelivr.net` (cada valor predeterminado se sustituye, no se añade). Los valores predeterminados de Tesseract OCR en `cdn.jsdelivr.net` permanecen en la política hasta que también definas los tres valores `VITE_TESSERACT_*`. Del mismo modo, definir `VITE_CORS_PROXY_URL` sustituye el valor público predeterminado `bentopdf-cors-proxy.bentopdf.workers.dev`.
La CSP incluye `'unsafe-eval'` en `script-src` porque el runtime WASM de LibreOffice (usado por las herramientas de conversión de Word/Excel/PowerPoint) y la biblioteca de imágenes wasm-vips (usada por PDF a TIFF) compilan código de despacho interno mediante `new Function()`. Quitarlo rompería esas herramientas. Si compilas en `SIMPLE_MODE` (sin LibreOffice) y no necesitas PDF a TIFF, puedes editar manualmente el `security-headers.conf` generado para eliminar `'unsafe-eval'` y obtener una política más estricta.
Para el OCR, deja vacías las variables `VITE_TESSERACT_*` para usar los recursos en línea predeterminados, o define las tres juntas para un OCR autoalojado o sin conexión. Las sobrescrituras parciales de OCR se rechazan porque el worker, el runtime principal y el directorio de traineddata deben coincidir. Para una salida de PDF con texto buscable totalmente sin conexión, define también `VITE_OCR_FONT_BASE_URL` para que las fuentes de la capa de texto del OCR se carguen desde tu servidor interno en lugar de las URL públicas de las fuentes Noto.
`VITE_DEFAULT_LANGUAGE` define el idioma de la interfaz para quienes visitan por primera vez. Valores admitidos: `en`, `ar`, `be`, `fr`, `de`, `es`, `zh`, `zh-TW`, `vi`, `tr`, `id`, `it`, `pt`, `nl`, `da`. Los usuarios pueden seguir cambiando de idioma: esto solo cambia el valor predeterminado.
Ejemplo:
```bash
# Build with French as the default language
docker build --build-arg VITE_DEFAULT_LANGUAGE=fr -t bentopdf .
docker run -d -p 3000:8080 bentopdf
```
### Marca personalizada
Sustituye el logo, el nombre y el texto de pie de BentoPDF por los tuyos. Coloca tu archivo de logo en la carpeta `public/` (o usa una imagen existente) y pasa las variables de marca al compilar:
```bash
docker build \
--build-arg VITE_BRAND_NAME="AcmePDF" \
--build-arg VITE_BRAND_LOGO="images/acme-logo.svg" \
--build-arg VITE_FOOTER_TEXT="© 2026 Acme Corp. Internal use only." \
-t acmepdf .
```
La marca personalizada funciona tanto en el modo completo como en Simple Mode, y se puede combinar con todas las demás opciones de tiempo de compilación.
### Desactivar herramientas concretas
Oculta herramientas de la interfaz por requisitos de cumplimiento o seguridad. Las herramientas desactivadas desaparecen de la página de inicio, los resultados de búsqueda, los atajos de teclado y el constructor de flujos de trabajo. Si se accede directamente por URL, se muestra una página de "herramienta no disponible".
Los ID de herramienta son la URL de la página sin `.html`. Por ejemplo, si la herramienta está en `bentopdf.com/edit-pdf.html`, el ID es `edit-pdf`.
#### Encontrar los ID de herramienta
La forma más fácil: abre cualquier herramienta en BentoPDF y mira la URL. La última parte de la ruta (sin `.html`) es el ID de la herramienta.
<details>
<summary>Lista completa de ID de herramientas</summary>
**Editar y anotar:** `edit-pdf`, `bookmark`, `table-of-contents`, `page-numbers`, `add-page-labels`, `bates-numbering`, `add-watermark`, `header-footer`, `invert-colors`, `scanner-effect`, `adjust-colors`, `background-color`, `text-color`, `sign-pdf`, `add-stamps`, `remove-annotations`, `crop-pdf`, `form-filler`, `form-creator`, `remove-blank-pages`
**Convertir a PDF:** `image-to-pdf`, `jpg-to-pdf`, `png-to-pdf`, `webp-to-pdf`, `svg-to-pdf`, `bmp-to-pdf`, `heic-to-pdf`, `tiff-to-pdf`, `txt-to-pdf`, `markdown-to-pdf`, `json-to-pdf`, `csv-to-pdf`, `rtf-to-pdf`, `odt-to-pdf`, `word-to-pdf`, `excel-to-pdf`, `powerpoint-to-pdf`, `xps-to-pdf`, `mobi-to-pdf`, `epub-to-pdf`, `fb2-to-pdf`, `cbz-to-pdf`, `wpd-to-pdf`, `wps-to-pdf`, `xml-to-pdf`, `pages-to-pdf`, `odg-to-pdf`, `ods-to-pdf`, `odp-to-pdf`, `pub-to-pdf`, `vsd-to-pdf`, `psd-to-pdf`, `email-to-pdf`
**Convertir desde PDF:** `pdf-to-jpg`, `pdf-to-png`, `pdf-to-webp`, `pdf-to-bmp`, `pdf-to-tiff`, `pdf-to-cbz`, `pdf-to-svg`, `pdf-to-csv`, `pdf-to-excel`, `pdf-to-greyscale`, `pdf-to-json`, `pdf-to-docx`, `extract-images`, `pdf-to-markdown`, `prepare-pdf-for-ai`, `pdf-to-text`
**Organizar y gestionar:** `ocr-pdf`, `merge-pdf`, `alternate-merge`, `organize-pdf`, `add-attachments`, `extract-attachments`, `edit-attachments`, `pdf-multi-tool`, `pdf-layers`, `extract-tables`, `split-pdf`, `divide-pages`, `extract-pages`, `delete-pages`, `add-blank-page`, `reverse-pages`, `rotate-pdf`, `rotate-custom`, `n-up-pdf`, `pdf-booklet`, `combine-single-page`, `view-metadata`, `edit-metadata`, `pdf-to-zip`, `compare-pdfs`, `posterize-pdf`, `page-dimensions`
**Optimizar y reparar:** `compress-pdf`, `pdf-to-pdfa`, `fix-page-size`, `linearize-pdf`, `remove-restrictions`, `repair-pdf`, `rasterize-pdf`, `deskew-pdf`, `font-to-outline`
**Seguridad:** `encrypt-pdf`, `sanitize-pdf`, `decrypt-pdf`, `flatten-pdf`, `remove-metadata`, `change-permissions`, `digital-sign-pdf`, `validate-signature-pdf`, `timestamp-pdf`
</details>
#### Opción 1: En tiempo de compilación (build arg de Docker)
```bash
docker build \
--build-arg DISABLE_TOOLS="edit-pdf,sign-pdf,encrypt-pdf" \
-t bentopdf .
```
Esto incorpora la lista de herramientas desactivadas en el bundle de JavaScript. Para cambiarla hay que volver a compilar.
#### Opción 2: En tiempo de ejecución (config.json)
Monta un archivo `config.json` en el directorio servido, sin necesidad de recompilar:
```json
{
"disabledTools": ["edit-pdf", "sign-pdf", "encrypt-pdf"]
}
```
```bash
docker run -d \
-p 3000:8080 \
-v ./config.json:/usr/share/nginx/html/config.json:ro \
ghcr.io/alam00000/bentopdf-simple:latest
```
O con Docker Compose:
```yaml
services:
bentopdf:
image: ghcr.io/alam00000/bentopdf-simple:latest
ports:
- '3000:8080'
volumes:
- ./config.json:/usr/share/nginx/html/config.json:ro
```
Ambos métodos se pueden combinar: las listas se fusionan. Si una herramienta aparece en cualquiera de ellas, se desactiva.
#### Desactivar funciones del editor
También puedes desactivar funciones concretas dentro del editor de PDF (p. ej., censura, anotaciones, formularios) sin desactivar toda la herramienta del editor. Añade `editorDisabledCategories` a tu `config.json`:
```json
{
"editorDisabledCategories": ["redaction", "annotation-stamp"]
}
```
<details>
<summary>Lista completa de categorías del editor</summary>
**Zoom:** `zoom`, `zoom-in`, `zoom-out`, `zoom-fit-page`, `zoom-fit-width`, `zoom-marquee`, `zoom-level`
**Anotación:** `annotation`, `annotation-markup`, `annotation-highlight`, `annotation-underline`, `annotation-strikeout`, `annotation-squiggly`, `annotation-ink`, `annotation-text`, `annotation-stamp`
**Formas:** `annotation-shape`, `annotation-rectangle`, `annotation-circle`, `annotation-line`, `annotation-arrow`, `annotation-polygon`, `annotation-polyline`
**Formulario:** `form`, `form-textfield`, `form-checkbox`, `form-radio`, `form-select`, `form-listbox`, `form-fill-mode`
**Censura:** `redaction`, `redaction-area`, `redaction-text`, `redaction-apply`, `redaction-clear`
**Documento:** `document`, `document-open`, `document-close`, `document-print`, `document-capture`, `document-export`, `document-fullscreen`, `document-protect`
**Página:** `page`, `spread`, `rotate`, `scroll`, `navigation`
**Panel:** `panel`, `panel-sidebar`, `panel-search`, `panel-comment`
**Herramientas:** `tools`, `pan`, `pointer`, `capture`
**Selección:** `selection`, `selection-copy`
**Historial:** `history`, `history-undo`, `history-redo`
</details>
Las categorías son jerárquicas: al desactivar una categoría padre (p. ej., `annotation`) se desactivan todas sus hijas.
### Desactivar el contador de estrellas de GitHub
La barra de navegación muestra un contador de estrellas de GitHub en vivo, obtenido de `api.github.com` al cargar la página. Es la única solicitud externa que no sirve a una función de PDF. Desactívalo al compilar para eliminar el código de obtención del bundle y quitar `api.github.com` de la Content-Security-Policy:
```bash
docker build --build-arg DISABLE_GITHUB_STARS=true -t bentopdf .
```
Las compilaciones en Simple Mode (`bentopdf-simple`) siempre omiten el contador de estrellas: este indicador solo hace falta en la versión comercial o en compilaciones completas personalizadas.
### URL de WASM personalizadas (aisladas de la red / autoalojadas)
> [!IMPORTANT]
> Las URL de WASM se incorporan al JavaScript en **tiempo de compilación**. Los archivos WASM los descarga el **navegador del usuario** en tiempo de ejecución: Docker no los descarga durante la compilación. Para redes aisladas, debes alojar los archivos WASM en un servidor interno al que lleguen los navegadores.
**Flujo de trabajo completo para redes aisladas:**
```bash
# 1. On a machine WITH internet — download WASM packages
bash scripts/prepare-airgap.sh --list-ocr-languages
bash scripts/prepare-airgap.sh --search-ocr-language german
# 2. Download WASM/OCR packages
npm pack @bentopdf/pymupdf-wasm@0.11.14
npm pack @bentopdf/gs-wasm
npm pack coherentpdf
npm pack tesseract.js@7.0.0
npm pack tesseract.js-core@7.0.0
mkdir -p tesseract-langdata
curl -fsSL https://cdn.jsdelivr.net/npm/@tesseract.js-data/eng/4.0.0_best_int/eng.traineddata.gz -o tesseract-langdata/eng.traineddata.gz
mkdir -p ocr-fonts
curl -fsSL https://raw.githack.com/googlefonts/noto-fonts/main/hinted/ttf/NotoSans/NotoSans-Regular.ttf -o ocr-fonts/NotoSans-Regular.ttf
# 3. Build the image with your internal server URLs
docker build \
--build-arg VITE_WASM_PYMUPDF_URL=https://internal-server.example.com/wasm/pymupdf/ \
--build-arg VITE_WASM_GS_URL=https://internal-server.example.com/wasm/gs/ \
--build-arg VITE_WASM_CPDF_URL=https://internal-server.example.com/wasm/cpdf/ \
--build-arg VITE_TESSERACT_WORKER_URL=https://internal-server.example.com/wasm/ocr/worker.min.js \
--build-arg VITE_TESSERACT_CORE_URL=https://internal-server.example.com/wasm/ocr/core \
--build-arg VITE_TESSERACT_LANG_URL=https://internal-server.example.com/wasm/ocr/lang-data \
--build-arg VITE_TESSERACT_AVAILABLE_LANGUAGES=eng,deu \
--build-arg VITE_OCR_FONT_BASE_URL=https://internal-server.example.com/wasm/ocr/fonts \
-t bentopdf .
# 4. Export the image
docker save bentopdf -o bentopdf.tar
# 5. Transfer bentopdf.tar + the .tgz packages + tesseract-langdata/ + ocr-fonts/ into the air-gapped network
# 6. Inside the air-gapped network — load and run
docker load -i bentopdf.tar
# Extract WASM packages to your internal web server
mkdir -p /var/www/wasm/pymupdf /var/www/wasm/gs /var/www/wasm/cpdf /var/www/wasm/ocr/core /var/www/wasm/ocr/lang-data /var/www/wasm/ocr/fonts
tar xzf bentopdf-pymupdf-wasm-0.11.14.tgz -C /var/www/wasm/pymupdf --strip-components=1
tar xzf bentopdf-gs-wasm-*.tgz -C /var/www/wasm/gs --strip-components=1
tar xzf coherentpdf-*.tgz -C /var/www/wasm/cpdf --strip-components=1
TEMP_TESS=$(mktemp -d)
tar xzf tesseract.js-7.0.0.tgz -C "$TEMP_TESS"
cp "$TEMP_TESS/package/dist/worker.min.js" /var/www/wasm/ocr/worker.min.js
rm -rf "$TEMP_TESS"
tar xzf tesseract.js-core-7.0.0.tgz -C /var/www/wasm/ocr/core --strip-components=1
cp ./tesseract-langdata/*.traineddata.gz /var/www/wasm/ocr/lang-data/
cp ./ocr-fonts/* /var/www/wasm/ocr/fonts/
# Run BentoPDF
docker run -d -p 3000:8080 --restart unless-stopped bentopdf
```
Usa los códigos que muestra `bash scripts/prepare-airgap.sh --list-ocr-languages`, o busca por nombre con `bash scripts/prepare-airgap.sh --search-ocr-language <term>`, para `--ocr-languages`. Si compilas con un subconjunto restringido de OCR, pasa los mismos códigos a `VITE_TESSERACT_AVAILABLE_LANGUAGES` para que la aplicación solo muestre los idiomas incluidos. Para una salida de OCR totalmente sin conexión, aloja también el directorio incluido `ocr-fonts/` y apunta `VITE_OCR_FONT_BASE_URL` hacia él.
Define una variable como cadena vacía para desactivar ese módulo (los usuarios deberán configurarlo manualmente en Ajustes avanzados).
## Puerto personalizado
Por defecto, BentoPDF escucha en el puerto `8080` dentro del contenedor. Para cambiarlo, define la variable de entorno `PORT` en tiempo de ejecución:
```bash
docker run -p 3000:9090 -e PORT=9090 ghcr.io/alam00000/bentopdf-simple:latest
```
| Variable | Descripción | Predeterminado |
| -------- | ------------------------------------------- | -------------- |
| `PORT` | Puerto de escucha de Nginx en el contenedor | `8080` |
Funciona tanto con el Dockerfile estándar como con el nonroot.
## ID de usuario personalizado (PUID/PGID)
Para entornos que requieren ejecutarse como un usuario concreto que no sea root (dispositivos NAS, Kubernetes con contextos de seguridad, políticas de la organización), BentoPDF ofrece un Dockerfile aparte con compatibilidad PUID/PGID al estilo LSIO.
### Compilar y ejecutar
```bash
# Build the non-root image
docker build -f Dockerfile.nonroot -t bentopdf-nonroot .
# Run with custom UID/GID
docker run -d \
--name bentopdf \
-p 3000:8080 \
-e PUID=1000 \
-e PGID=1000 \
--restart unless-stopped \
bentopdf-nonroot
```
### Variables de entorno
| Variable | Descripción | Predeterminado |
| -------------- | --------------------------------- | -------------- |
| `PUID` | ID de usuario con el que ejecutar | `1000` |
| `PGID` | ID de grupo con el que ejecutar | `1000` |
| `PORT` | Puerto de escucha de Nginx | `8080` |
| `DISABLE_IPV6` | Desactivar el listener IPv6 | `false` |
### Docker Compose
```yaml
services:
bentopdf:
build:
context: .
dockerfile: Dockerfile.nonroot
container_name: bentopdf
ports:
- '3000:8080'
environment:
- PUID=1000
- PGID=1000
restart: unless-stopped
```
### Cómo funciona
El contenedor se inicia como root, crea un usuario con el PUID/PGID indicado, ajusta la propiedad de todos los directorios con permiso de escritura y después reduce privilegios con `su-exec`. El proceso de nginx se ejecuta íntegramente como el usuario que indiques.
> [!NOTE]
> El `Dockerfile` estándar usa `nginx-unprivileged` (UID 101) y es el recomendado para la mayoría de los despliegues. Usa `Dockerfile.nonroot` solo cuando necesites un UID/GID concreto.
> [!WARNING]
> PUID/PGID no pueden ser `0` (root). El entrypoint valida los valores y terminará con un error si son inválidos.
## Con Traefik (proxy inverso)
```yaml
services:
traefik:
image: traefik:v2.10
command:
- '--providers.docker=true'
- '--entrypoints.web.address=:80'
- '--entrypoints.websecure.address=:443'
- '--certificatesresolvers.letsencrypt.acme.email=you@example.com'
- '--certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json'
- '--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web'
ports:
- '80:80'
- '443:443'
volumes:
- /var/run/docker.sock:/var/run/docker.sock:ro
- ./letsencrypt:/letsencrypt
bentopdf:
image: ghcr.io/alam00000/bentopdf-simple:latest
labels:
- 'traefik.enable=true'
- 'traefik.http.routers.bentopdf.rule=Host(`pdf.example.com`)'
- 'traefik.http.routers.bentopdf.entrypoints=websecure'
- 'traefik.http.routers.bentopdf.tls.certresolver=letsencrypt'
- 'traefik.http.services.bentopdf.loadbalancer.server.port=8080'
# Required headers for SharedArrayBuffer (LibreOffice WASM)
- 'traefik.http.routers.bentopdf.middlewares=bentopdf-headers'
- 'traefik.http.middlewares.bentopdf-headers.headers.customresponseheaders.Cross-Origin-Opener-Policy=same-origin'
- 'traefik.http.middlewares.bentopdf-headers.headers.customresponseheaders.Cross-Origin-Embedder-Policy=require-corp'
restart: unless-stopped
```
## Con Caddy (proxy inverso)
```yaml
services:
caddy:
image: caddy:2
ports:
- '80:80'
- '443:443'
volumes:
- ./Caddyfile:/etc/caddy/Caddyfile
- caddy_data:/data
bentopdf:
image: ghcr.io/alam00000/bentopdf-simple:latest
restart: unless-stopped
volumes:
caddy_data:
```
Caddyfile:
```
pdf.example.com {
reverse_proxy bentopdf:8080
header Cross-Origin-Opener-Policy "same-origin"
header Cross-Origin-Embedder-Policy "require-corp"
}
```
## Límites de recursos
```yaml
services:
bentopdf:
image: ghcr.io/alam00000/bentopdf-simple:latest
deploy:
resources:
limits:
cpus: '1'
memory: 512M
reservations:
cpus: '0.25'
memory: 128M
```
## Podman Quadlet (integración con systemd)
[Quadlet](https://docs.podman.io/en/latest/markdown/podman-systemd.unit.5.html) te permite ejecutar contenedores de Podman como servicios de systemd. Es ideal para despliegues de producción en sistemas Linux.
### Configuración básica de Quadlet
Crea un archivo de unidad de contenedor en `~/.config/containers/systemd/bentopdf.container` (usuario) o `/etc/containers/systemd/bentopdf.container` (sistema):
```ini
[Unit]
Description=BentoPDF - Privacy-first PDF toolkit
After=network-online.target
Wants=network-online.target
[Container]
Image=ghcr.io/alam00000/bentopdf-simple:latest
ContainerName=bentopdf
PublishPort=3000:8080
AutoUpdate=registry
[Service]
Restart=always
TimeoutStartSec=300
[Install]
WantedBy=default.target
```
### Habilitar e iniciar
```bash
# Reload systemd to detect new unit
systemctl --user daemon-reload
# Start the service
systemctl --user start bentopdf
# Enable on boot
systemctl --user enable bentopdf
# Check status
systemctl --user status bentopdf
# View logs
journalctl --user -u bentopdf -f
```
> [!TIP]
> Para un despliegue a nivel de sistema, usa `systemctl` sin la opción `--user` y coloca el archivo en `/etc/containers/systemd/`.
### Quadlet con comprobación de estado
```ini
[Unit]
Description=BentoPDF with health monitoring
After=network-online.target
Wants=network-online.target
[Container]
Image=ghcr.io/alam00000/bentopdf-simple:latest
ContainerName=bentopdf
PublishPort=3000:8080
AutoUpdate=registry
HealthCmd=wget --spider -q http://localhost:8080 || exit 1
HealthInterval=30s
HealthTimeout=10s
HealthRetries=3
[Service]
Restart=always
TimeoutStartSec=300
[Install]
WantedBy=default.target
```
### Actualización automática con Quadlet
Podman puede actualizar los contenedores automáticamente cuando hay imágenes nuevas disponibles:
```bash
# Enable auto-update timer
systemctl --user enable --now podman-auto-update.timer
# Check for updates manually
podman auto-update
# Dry run (check without updating)
podman auto-update --dry-run
```
### Configuración de red de Quadlet
Para una configuración de red personalizada, crea un archivo de red `bentopdf.network`:
```ini
[Network]
Subnet=10.89.0.0/24
Gateway=10.89.0.1
```
Después haz referencia a él en tu archivo de contenedor:
```ini
[Container]
Image=ghcr.io/alam00000/bentopdf-simple:latest
ContainerName=bentopdf
PublishPort=3000:8080
Network=bentopdf.network
```
## Actualización
```bash
# Pull latest image
docker compose pull
# Recreate container
docker compose up -d
```
docs/es/self-hosting/hostinger.md
+266
View File
@@ -0,0 +1,266 @@
# Desplegar en Hostinger
[Hostinger](https://hostinger.com) es un proveedor de alojamiento compartido muy popular. Esta guía explica cómo desplegar BentoPDF en el alojamiento compartido de Hostinger.
## Requisitos previos
- Plan de alojamiento de Hostinger con acceso al administrador de archivos
- Node.js instalado localmente para compilar
## Paso 1: Compilar el proyecto
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
npm install
npm run build
```
Los archivos compilados estarán en la carpeta `dist`.
## Paso 2: Subir a Hostinger
### Despliegue en el dominio raíz
1. Inicia sesión en tu cuenta de Hostinger
2. Ve a **File Manager** → **public_html**
3. **Elimina** los archivos existentes (haz una copia de seguridad si hace falta)
4. **Sube** todo el contenido de tu carpeta local `dist` a `public_html`
### Despliegue en un subdirectorio
Si despliegas en un subdirectorio (p. ej., `yourdomain.com/pdf-tools/`):
1. Compila con la URL base correcta:
```bash
BASE_URL=/pdf-tools/ npm run build
```
2. Crea la carpeta en Hostinger:
- Ve a **File Manager** → **public_html**
- Crea una carpeta nueva: `pdf-tools`
3. Sube todo el contenido de `dist` a `public_html/pdf-tools/`
## Paso 3: Crear el archivo .htaccess
Crea un archivo `.htaccess` en la raíz de tu carpeta de despliegue (`public_html` o `public_html/pdf-tools/`):
::: warning Importante
Para el despliegue en un subdirectorio, cambia `RewriteBase /` por `RewriteBase /pdf-tools/` (o el nombre de tu carpeta).
:::
```apache
RewriteEngine On
RewriteBase /
# ============================================
# 1. SECURITY HEADERS (CRITICAL FOR WASM)
# ============================================
<IfModule mod_headers.c>
Header always set X-Frame-Options "SAMEORIGIN"
Header always set X-Content-Type-Options "nosniff"
Header always set X-XSS-Protection "1; mode=block"
Header always set Referrer-Policy "strict-origin-when-cross-origin"
Header always set Permissions-Policy "geolocation=(), microphone=(), camera=()"
# REQUIRED for soffice.js (SharedArrayBuffer)
Header always set Cross-Origin-Opener-Policy "same-origin"
Header always set Cross-Origin-Embedder-Policy "require-corp"
</IfModule>
# ============================================
# 2. BROWSER CACHING
# ============================================
<IfModule mod_expires.c>
ExpiresActive On
ExpiresByType image/jpeg "access plus 1 year"
ExpiresByType image/png "access plus 1 year"
ExpiresByType image/gif "access plus 1 year"
ExpiresByType image/webp "access plus 1 year"
ExpiresByType image/svg+xml "access plus 1 year"
ExpiresByType image/x-icon "access plus 1 year"
ExpiresByType font/woff2 "access plus 1 year"
ExpiresByType font/woff "access plus 1 year"
ExpiresByType font/ttf "access plus 1 year"
ExpiresByType text/css "access plus 1 month"
ExpiresByType application/javascript "access plus 1 month"
ExpiresByType application/wasm "access plus 1 year"
ExpiresByType application/gzip "access plus 1 year"
ExpiresByType text/html "access plus 0 seconds"
</IfModule>
# ============================================
# 3. COMPRESSION (STANDARD)
# ============================================
# Prevent server from double-compressing files
SetEnvIfNoCase Request_URI "\.gz$" no-gzip
SetEnvIfNoCase Request_URI "\.br$" no-gzip
SetEnvIfNoCase Request_URI "\.wasm$" no-gzip
<IfModule mod_deflate.c>
AddOutputFilterByType DEFLATE text/plain
AddOutputFilterByType DEFLATE text/html
AddOutputFilterByType DEFLATE text/xml
AddOutputFilterByType DEFLATE text/css
AddOutputFilterByType DEFLATE application/xml
AddOutputFilterByType DEFLATE application/xhtml+xml
AddOutputFilterByType DEFLATE application/rss+xml
AddOutputFilterByType DEFLATE application/javascript
AddOutputFilterByType DEFLATE application/x-javascript
AddOutputFilterByType DEFLATE application/json
AddOutputFilterByType DEFLATE image/svg+xml
AddOutputFilterByType DEFLATE font/woff
AddOutputFilterByType DEFLATE font/ttf
</IfModule>
# ============================================
# 4. MIME TYPES & SPECIAL FILE HANDLING
# ============================================
AddType application/javascript .js .mjs
AddType application/wasm .wasm
AddType font/woff2 .woff2
AddType font/woff .woff
AddType image/webp .webp
# Handle soffice.wasm.gz correctly
<FilesMatch "soffice\.wasm\.gz$">
ForceType application/wasm
Header set Content-Encoding "gzip"
Header set Cross-Origin-Resource-Policy "cross-origin"
Header append Vary Accept-Encoding
</FilesMatch>
# Handle data.gz
<FilesMatch "soffice\.data\.gz$">
ForceType application/octet-stream
Header set Content-Encoding "gzip"
Header append Vary Accept-Encoding
</FilesMatch>
# ============================================
# 5. REDIRECTS & ROUTING
# ============================================
# Canonical WWW (update domain as needed)
RewriteCond %{HTTP_HOST} ^bentopdf\.com [NC]
RewriteRule ^(.*)$ https://www.bentopdf.com/$1 [L,R=301]
# Force HTTPS
RewriteCond %{HTTPS} off
RewriteRule ^(.*)$ https://%{HTTP_HOST}%{REQUEST_URI} [L,R=301]
# Remove trailing slash (except for language root directories)
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_URI} !^/(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/$
RewriteCond %{REQUEST_URI} (.+)/$
RewriteRule ^ %1 [R=301,L]
# Existing files/dirs - serve directly
RewriteCond %{REQUEST_FILENAME} -f [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^ - [L]
# ============================================
# 5.1. LANGUAGE ROUTES
# ============================================
# Supported languages: de, es, zh, zh-TW, vi, it, id, tr, fr, pt
# English has no prefix - served from root
# English prefix redirects to root (for SEO consistency)
RewriteRule ^en/?$ / [R=301,L]
RewriteRule ^en/(.+)$ /$1 [R=301,L]
# Language prefix root (e.g., /de/ -> /de/index.html)
RewriteCond %{DOCUMENT_ROOT}/$1/index.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/?$ /$1/index.html [L]
# Language prefix with path (e.g., /de/merge-pdf -> /de/merge-pdf.html)
RewriteCond %{DOCUMENT_ROOT}/$1/$2.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/([^/]+)/?$ /$1/$2.html [L]
# ============================================
# 5.5. DOCS ROUTING (VitePress)
# ============================================
RewriteCond %{REQUEST_URI} ^/docs
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME}\.html -f
RewriteRule ^(.*)$ $1.html [L]
# ============================================
# 6. ADD .HTML EXTENSION IF FILE EXISTS (ROOT LEVEL ONLY)
# ============================================
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME}.html -f
RewriteRule ^([^/]+)$ $1.html [L]
# ============================================
# 7. ERROR PAGES
# ============================================
ErrorDocument 404 /404.html
```
## Ejemplo de .htaccess para un subdirectorio
Para `yourdomain.com/pdf-tools/`, actualiza estas líneas:
```apache
RewriteBase /pdf-tools/
# ... (same content as above, but update paths) ...
# Language prefix root
RewriteCond %{DOCUMENT_ROOT}/pdf-tools/$1/index.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/?$ /pdf-tools/$1/index.html [L]
# Language prefix with path
RewriteCond %{DOCUMENT_ROOT}/pdf-tools/$1/$2.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/([^/]+)/?$ /pdf-tools/$1/$2.html [L]
# Root level .html extension
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME}.html -f
RewriteRule ^([^/]+)$ $1.html [L]
ErrorDocument 404 /pdf-tools/404.html
```
## Solución de problemas
### Los archivos WASM no se cargan
Asegúrate de que los tipos MIME estén bien definidos en `.htaccess`:
```apache
AddType application/wasm .wasm
```
### Las herramientas de LibreOffice no funcionan
Las cabeceras de seguridad son críticas para SharedArrayBuffer:
```apache
Header always set Cross-Origin-Opener-Policy "same-origin"
Header always set Cross-Origin-Embedder-Policy "require-corp"
```
Si las cabeceras no se aplican, contacta con el soporte de Hostinger para que habiliten `mod_headers`.
### Errores 404 al recargar la página
Asegúrate de que la regla de la extensión `.html` y las rutas de idioma estén bien configuradas. BentoPDF usa archivos HTML estáticos, no enrutamiento SPA:
```apache
# Language routes serve actual files from language directories
RewriteCond %{DOCUMENT_ROOT}/$1/$2.html -f
RewriteRule ^(de|es|zh|zh-TW|vi|it|id|tr|fr|pt)/([^/]+)/?$ /$1/$2.html [L]
# Root level pages
RewriteCond %{REQUEST_FILENAME}.html -f
RewriteRule ^([^/]+)$ $1.html [L]
```
### Límites de subida de archivos
Hostinger puede tener límites de tamaño de archivo. Sube los archivos WASM por separado si falla la subida en bloque.
docs/es/self-hosting/index.md
+538
View File
@@ -0,0 +1,538 @@
# Guía de autoalojamiento
BentoPDF se puede autoalojar en tu propia infraestructura. Esta guía cubre las distintas opciones de despliegue.
## Inicio rápido con Docker / Podman
La forma más rápida de autoalojar BentoPDF:
> [!TIP]
> BentoPDF se distribuye en dos compilaciones:
>
> - **Compilación autoalojada**: `ghcr.io/alam00000/bentopdf-simple:latest`. Todas las herramientas de PDF, **sin** el aparato de marketing (sin hero, preguntas frecuentes, testimonios ni pie de página). Úsala para despliegues internos, de equipo o de organización. **No** es una versión "lite" con menos funciones.
> - **Compilación comercial**: `ghcr.io/alam00000/bentopdf:latest`. El sitio de marketing completo, que usa el propio bentopdf.com y los titulares de licencias comerciales que ejecutan despliegues de cara al público.
>
> Si dudas: descarga la compilación autoalojada.
> [!IMPORTANT]
> La conversión de archivos de Office requiere `SharedArrayBuffer`, lo que significa que la aplicación debe estar aislada entre orígenes (cross-origin isolated) y servirse desde un contexto seguro. La imagen oficial ya envía las cabeceras COOP/COEP necesarias, pero los navegadores siguen desactivando `SharedArrayBuffer` en orígenes HTTP simples de red local, como `http://192.168.x.x`.
>
> Usa `http://localhost` solo para pruebas en el mismo dispositivo. Si los usuarios acceden a BentoPDF mediante una IP o un nombre de host de la red local, termina la conexión con HTTPS.
```bash
# Docker
docker run -d -p 3000:8080 ghcr.io/alam00000/bentopdf-simple:latest
# Podman
podman run -d -p 3000:8080 ghcr.io/alam00000/bentopdf-simple:latest
```
O con Docker Compose / Podman Compose:
```yaml
# docker-compose.yml
services:
bentopdf:
image: ghcr.io/alam00000/bentopdf-simple:latest
ports:
- '3000:8080'
restart: unless-stopped
```
```bash
# Docker Compose
docker compose up -d
# Podman Compose
podman-compose up -d
```
## Podman Quadlet (Linux Systemd)
Ejecuta BentoPDF como un servicio de systemd. Crea `~/.config/containers/systemd/bentopdf.container`:
```ini
[Container]
Image=ghcr.io/alam00000/bentopdf-simple:latest
ContainerName=bentopdf
PublishPort=3000:8080
AutoUpdate=registry
[Service]
Restart=always
[Install]
WantedBy=default.target
```
```bash
systemctl --user daemon-reload
systemctl --user enable --now bentopdf
```
Consulta la [guía de despliegue con Docker](/es/self-hosting/docker) para ver la documentación completa de Quadlet.
## Compilar desde el código fuente
```bash
# Clone and build
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
npm install
npm run build
# The built files are in the `dist` folder
```
## Opciones de configuración
### Compilación autoalojada (Modo Simple)
La compilación autoalojada (la imagen `bentopdf-simple`, también llamada Modo Simple) es **funcionalmente idéntica** a la compilación comercial: todas las herramientas de PDF están presentes y se comportan igual. Simplemente oculta el aparato de marketing que solo tiene sentido en el propio bentopdf.com o en un despliegue comercial de cara al público. **No es una versión "lite" ni con menos funciones.**
**Qué oculta la compilación autoalojada** (solo cosmético, no se elimina ninguna función de PDF):
- Barra de navegación, sección hero, sección de características, preguntas frecuentes, testimonios, pie de página
- Cambia el título de la página a "Herramientas PDF"
**Qué conserva la compilación autoalojada** (todo lo que realmente trabaja con PDF):
- Todas las herramientas de PDF (fusionar, dividir, editar, firmar, OCR, conversión de Office, etc.)
- Compatibilidad con marca personalizada y toda la configuración de compilación y de tiempo de ejecución
La compilación comercial (`ghcr.io/alam00000/bentopdf:latest`) es la que impulsa el propio bentopdf.com y la usan los titulares de licencias comerciales que ejecutan despliegues de cara al público. Añade el hero, las preguntas frecuentes, los testimonios y el pie de página, que no tendrían sentido en una herramienta interna.
Si autoalojas BentoPDF para tu equipo, tu organización o como herramienta interna, descarga la compilación autoalojada:
```bash
# Use the pre-built image (recommended)
docker run -p 3000:8080 ghcr.io/alam00000/bentopdf-simple:latest
# Or build it yourself
SIMPLE_MODE=true npm run build
```
Consulta [SIMPLE_MODE.md](https://github.com/alam00000/bentopdf/blob/main/SIMPLE_MODE.md) para ver todos los detalles.
### Compilación comercial (despliegues de cara al público con tu propia marca)
La compilación comercial (la imagen `bentopdf`, sin el sufijo `-simple`) es la que impulsa el propio bentopdf.com. Incluye el sitio de marketing completo (hero, características, preguntas frecuentes, testimonios, pie de página) además de todas las herramientas de PDF. Usa esta compilación cuando quieras **desplegar BentoPDF como un servicio de PDF de cara al público bajo tu propia marca**, por ejemplo:
- Ejecutas BentoPDF como un SaaS alojado para usuarios finales en tu propio dominio
- Quieres la experiencia de la página de inicio (secciones de marketing y herramientas), no solo la superficie básica de herramientas
- Eres titular de una licencia comercial e integras BentoPDF en un producto comercial
**Ejecútala tal cual** (con la marca BentoPDF, útil para previsualizar la compilación):
```bash
docker run -p 3000:8080 ghcr.io/alam00000/bentopdf:latest
```
**Compila con tu propia marca** (el flujo comercial típico):
```bash
docker build \
--build-arg VITE_BRAND_NAME="AcmePDF" \
--build-arg VITE_BRAND_LOGO="images/acme-logo.svg" \
--build-arg VITE_FOOTER_TEXT="© 2026 Acme Corp. All rights reserved." \
-t acmepdf .
docker run -p 3000:8080 acmepdf
```
Todas las demás opciones de compilación (`BASE_URL`, `VITE_DEFAULT_LANGUAGE`, `DISABLE_TOOLS`, sustitución de URL de WASM, etc.) funcionan igual que en la compilación autoalojada.
::: warning Licencias
Ejecutar la compilación comercial está permitido bajo cualquiera de las dos opciones de licencia de BentoPDF:
- **AGPL-3.0** (gratuita): permitida si tu despliegue publica todo su código fuente bajo AGPL, incluidas las modificaciones de marca y la lógica de negocio asociada.
- **Licencia comercial** (79 $ de por vida): necesaria para despliegues de código cerrado o propietarios en los que no publicas tu fork con la marca ni tu código de negocio.
Consulta la [página de licencias](https://www.bentopdf.com/licensing) para ver la comparación completa. Los módulos WASM con licencia AGPL (PyMuPDF, Ghostscript, CoherentPDF) se cargan desde una CDN en tiempo de ejecución, por lo que no entran en tu imagen y no cambian tu situación de licencias.
:::
### URL base
Despliega en un subdirectorio:
```bash
BASE_URL=/pdf-tools/ npm run build
```
### Marca personalizada
Sustituye el logotipo, el nombre y el texto del pie de página de BentoPDF por los tuyos en tiempo de compilación:
| Variable | Descripción | Valor por defecto |
| ------------------ | ------------------------------------------------------------ | --------------------------------------- |
| `VITE_BRAND_NAME` | Nombre de marca que se muestra en el encabezado y el pie | `BentoPDF` |
| `VITE_BRAND_LOGO` | Ruta del logotipo relativa a `public/` | `images/favicon-no-bg.svg` |
| `VITE_FOOTER_TEXT` | Texto personalizado del pie de página y de derechos de autor | `© 2026 BentoPDF. All rights reserved.` |
```bash
# Place your logo in public/, then build
VITE_BRAND_NAME="AcmePDF" \
VITE_BRAND_LOGO="images/acme-logo.svg" \
VITE_FOOTER_TEXT="© 2026 Acme Corp. Internal use only." \
npm run build
```
O mediante Docker:
```bash
docker build \
--build-arg VITE_BRAND_NAME="AcmePDF" \
--build-arg VITE_BRAND_LOGO="images/acme-logo.svg" \
--build-arg VITE_FOOTER_TEXT="© 2026 Acme Corp. Internal use only." \
-t acmepdf .
```
La marca personalizada funciona tanto en el modo completo como en el Modo Simple, y se puede combinar con todas las demás opciones de compilación (`BASE_URL`, `SIMPLE_MODE`, `VITE_DEFAULT_LANGUAGE`).
### Desactivar herramientas específicas
Oculta herramientas concretas por motivos de cumplimiento o seguridad. Las herramientas desactivadas se eliminan de la página de inicio, la búsqueda, los atajos, el generador de flujos de trabajo y el acceso directo por URL.
Los ID de las herramientas son la URL de la página sin `.html`: abre cualquier herramienta y mira la URL (p. ej., `edit-pdf`, `sign-pdf`, `encrypt-pdf`).
**En tiempo de compilación** (incluido en el bundle):
```bash
DISABLE_TOOLS="edit-pdf,sign-pdf" npm run build
```
**En tiempo de ejecución** (sin recompilar: monta un `config.json`):
```json
{
"disabledTools": ["edit-pdf", "sign-pdf"]
}
```
```bash
docker run -d -p 3000:8080 \
-v ./config.json:/usr/share/nginx/html/config.json:ro \
ghcr.io/alam00000/bentopdf-simple:latest
```
Se pueden combinar ambos métodos: las listas se fusionan.
También puedes desactivar funciones específicas dentro del Editor de PDF (p. ej., la redacción) sin desactivar la herramienta completa, añadiendo `editorDisabledCategories` a `config.json`. Consulta la [guía de Docker](/es/self-hosting/docker#desactivar-funciones-del-editor) para ver la lista completa de categorías.
## Guías de despliegue
Elige tu plataforma:
- [Vercel](/es/self-hosting/vercel)
- [Netlify](/es/self-hosting/netlify)
- [Cloudflare Pages](/es/self-hosting/cloudflare)
- [AWS S3 + CloudFront](/es/self-hosting/aws)
- [Hostinger](/es/self-hosting/hostinger)
- [Nginx](/es/self-hosting/nginx)
- [Apache](/es/self-hosting/apache)
- [Docker](/es/self-hosting/docker)
- [Kubernetes](/es/self-hosting/kubernetes)
- [Proxy CORS](/es/self-hosting/cors-proxy): necesario para las firmas digitales
## Problemas comunes
### La conversión de Word / ODT / Excel / PowerPoint a PDF se cuelga (SharedArrayBuffer no disponible)
**Síntoma**: las conversiones de documentos basadas en LibreOffice (Word, ODT, Excel, PowerPoint a PDF) se quedan colgadas en torno al 55% o no llegan a iniciarse. La consola del navegador puede mostrar:
> `ReferenceError: SharedArrayBuffer is not defined`
...o `window.crossOriginIsolated` devuelve `false`, o la compilación de WASM informa `expected magic word 00 61 73 6d, found 1f 8b 08 08`.
**Causa**: LibreOffice WASM requiere `SharedArrayBuffer`, que el navegador solo activa cuando la página está **aislada entre orígenes (cross-origin isolated)** Y se sirve desde un **contexto seguro**. Eso significa que deben cumplirse dos cosas:
1. Todas las respuestas incluyen ambas cabeceras:
- `Cross-Origin-Embedder-Policy: require-corp`
- `Cross-Origin-Opener-Policy: same-origin`
2. La página se sirve desde `https://...` o `http://localhost`. HTTP simple sobre una IP de red local (p. ej. `http://192.168.x.x`) NO cuenta como seguro: los navegadores desactivan `SharedArrayBuffer` allí.
La discrepancia `00 61 73 6d / 1f 8b 08 08` es un subsíntoma distinto: a los archivos precomprimidos `.wasm.gz` / `.data.gz` les falta la cabecera de respuesta `Content-Encoding: gzip`, por lo que el navegador recibe bytes gzip sin procesar en lugar de WASM descomprimido.
**Solución**: consulta la guía de despliegue de tu plataforma para ver la configuración exacta:
- [Nginx →](/es/self-hosting/nginx#la-conversion-de-word-odt-excel-a-pdf-no-funciona)
- [Apache →](/es/self-hosting/apache#word-odt-excel-a-pdf-no-funciona)
- [AWS S3 + CloudFront →](/es/self-hosting/aws#paso-3b-politica-de-cabeceras-de-respuesta-necesaria-para-libreoffice-wasm)
- [Cloudflare Pages →](/es/self-hosting/cloudflare#archivo-de-configuracion) (archivo `_headers`)
- [Netlify →](/es/self-hosting/netlify#la-conversion-de-word-odt-excel-a-pdf-se-queda-atascada-en-el-55) (`netlify.toml`)
- [Vercel →](/es/self-hosting/vercel#la-conversion-de-word-odt-excel-a-pdf-no-funciona) (`vercel.json`)
- [Hostinger →](/es/self-hosting/hostinger#las-herramientas-de-libreoffice-no-funcionan) (`.htaccess`)
- [Kubernetes →](/es/self-hosting/kubernetes#como-comprobar-que-las-cabeceras-de-sharedarraybuffer-siguen-funcionando-ingress-gateway)
- **Docker**: lo gestiona automáticamente la configuración de nginx incluida, no hace falta hacer nada.
**Verificación**: abre la consola de DevTools en cualquier página de BentoPDF y ejecuta:
```js
console.log(window.crossOriginIsolated); // should be true
console.log(typeof SharedArrayBuffer); // should be "function"
```
Si la página usa HTTPS o `http://localhost` Y ambas cabeceras COEP/COOP están presentes en todas las respuestas, ambas comprobaciones se superan. Si estás en `http://192.168.x.x` u otro origen HTTP que no sea de loopback, termina la conexión con HTTPS: no hay una solución que dependa solo de cabeceras.
### Archivos `.mjs` servidos como `application/octet-stream`
**Síntoma**: Firmar PDF / Rellenar formularios / otras herramientas muestran un visor en blanco o no se cargan. La consola del navegador informa:
> `Failed to load module script: The server responded with a non-JavaScript MIME type of "application/octet-stream". Strict MIME type checking is enforced for module scripts per HTML spec.`
**Causa**: tu servidor web o proxy inverso no tiene una asignación de tipo MIME para los archivos `.mjs` (el visor de PDF incluido incorpora módulos ES con esa extensión). Muchas configuraciones de servidor por defecto usan `application/octet-stream` para las extensiones desconocidas, y los navegadores se niegan a ejecutarlas como módulos ES.
**Solución**: consulta la guía de despliegue de tu plataforma para ver el fragmento exacto:
- [Nginx →](/es/self-hosting/nginx#firmar-pdf-o-rellenar-formularios-muestra-un-visor-en-blanco-error-mime-de-mjs)
- [Apache →](/es/self-hosting/apache#firmar-pdf-o-el-rellenador-de-formularios-muestra-un-visor-en-blanco-error-mime-de-mjs)
- [AWS S3 + CloudFront →](/es/self-hosting/aws#paso-2-compilar-y-subir) (consulta `aws s3 cp ... --include "*.mjs"`)
- [Kubernetes →](/es/self-hosting/kubernetes#errores-de-tipo-mime-de-mjs-iframe-en-blanco-en-firmar-pdf-rellenar-formularios)
- **Docker, Vercel, Netlify, Cloudflare Pages, Hostinger**: se gestiona automáticamente, no hace falta hacer nada.
**Verificación**: abre DevTools → pestaña Network, busca la petición `.mjs` que falla y revisa la cabecera de respuesta `Content-Type`. Debería ser `application/javascript`. Si sigue siendo `application/octet-stream`, puede que un proxy inverso o una CDN externos estén volviendo a detectar el tipo: revisa cada capa de tu cadena de servicio.
## Configuración de WASM (componentes AGPL)
BentoPDF **no incluye** en su código fuente las bibliotecas de procesamiento con licencia AGPL, pero **preconfigura las URL de CDN** para que todas las funciones funcionen de inmediato, sin configuración manual.
::: tip Cero configuración por defecto
Desde la v2.0.0, los módulos WASM están preconfigurados para cargarse desde la CDN de jsDelivr mediante variables de entorno. Todas las funciones avanzadas funcionan de inmediato sin ninguna configuración del usuario.
:::
| Componente | Licencia | Funciones |
| --------------- | -------- | ----------------------------------------------------------------------------- |
| **PyMuPDF** | AGPL-3.0 | Conversión de EPUB/MOBI/FB2/XPS, extracción de imágenes, extracción de tablas |
| **Ghostscript** | AGPL-3.0 | Conversión a PDF/A, compresión, corrección de inclinación, rasterización |
| **CoherentPDF** | AGPL-3.0 | Tabla de contenido, adjuntos, fusión de PDF con marcadores |
### Variables de entorno por defecto
Se definen en `.env.production` y se incluyen en la compilación:
```bash
VITE_WASM_PYMUPDF_URL=https://cdn.jsdelivr.net/npm/@bentopdf/pymupdf-wasm@0.11.16/
VITE_WASM_GS_URL=https://cdn.jsdelivr.net/npm/@bentopdf/gs-wasm@0.1.1/assets/
VITE_WASM_CPDF_URL=https://cdn.jsdelivr.net/npm/coherentpdf@2.5.5/dist/
VITE_TESSERACT_WORKER_URL=
VITE_TESSERACT_CORE_URL=
VITE_TESSERACT_LANG_URL=
VITE_TESSERACT_AVAILABLE_LANGUAGES=
VITE_OCR_FONT_BASE_URL=
```
### Sustituir las URL de WASM
Puedes sustituir los valores por defecto en tiempo de compilación para despliegues personalizados:
```bash
# Via Docker build args
docker build \
--build-arg VITE_WASM_PYMUPDF_URL=https://your-server.com/pymupdf/ \
--build-arg VITE_WASM_GS_URL=https://your-server.com/gs/ \
--build-arg VITE_WASM_CPDF_URL=https://your-server.com/cpdf/ \
--build-arg VITE_TESSERACT_WORKER_URL=https://your-server.com/ocr/worker.min.js \
--build-arg VITE_TESSERACT_CORE_URL=https://your-server.com/ocr/core \
--build-arg VITE_TESSERACT_LANG_URL=https://your-server.com/ocr/lang-data \
--build-arg VITE_TESSERACT_AVAILABLE_LANGUAGES=eng,deu \
--build-arg VITE_OCR_FONT_BASE_URL=https://your-server.com/ocr/fonts \
-t bentopdf .
# Or via .env.production before building from source
VITE_WASM_PYMUPDF_URL=https://your-server.com/pymupdf/ npm run build
```
Para desactivar un módulo por completo (requiere configuración manual del usuario en Ajustes avanzados), asigna una cadena vacía a su variable.
Para OCR, deja vacías todas las variables `VITE_TESSERACT_*` y mantén los recursos en línea por defecto, o define juntas las URL de worker, core e idiomas para un OCR autoalojado o sin conexión. Si incluyes solo idiomas de OCR concretos, define también `VITE_TESSERACT_AVAILABLE_LANGUAGES` con los mismos códigos separados por comas para que la interfaz solo ofrezca los idiomas instalados y las selecciones no admitidas fallen con un error descriptivo. Para obtener PDF con capa de texto totalmente sin conexión, define también `VITE_OCR_FONT_BASE_URL` con el directorio interno que sirve las fuentes de OCR incluidas.
Los usuarios también pueden sustituir estos valores por defecto en cualquier momento mediante **Ajustes avanzados** en la interfaz: las sustituciones del usuario guardadas en el navegador tienen prioridad sobre los valores por defecto del entorno.
### Despliegue aislado de la red / sin conexión
Para redes sin acceso a internet (gobierno, sanidad, finanzas, etc.). Las URL de WASM se incluyen en el JavaScript en **tiempo de compilación**: los archivos WASM reales los descarga el **navegador del usuario** en tiempo de ejecución. Por eso debes preparar todo en una máquina con internet y luego transferirlo a la red aislada.
#### Script automatizado (recomendado)
El script incluido `prepare-airgap.sh` automatiza todo el proceso: descarga los paquetes WASM, compila la imagen de Docker y genera un paquete autocontenido con un script de configuración.
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
# Show supported OCR language codes (for --ocr-languages)
bash scripts/prepare-airgap.sh --list-ocr-languages
# Search OCR language codes by name or abbreviation
bash scripts/prepare-airgap.sh --search-ocr-language german
# Interactive mode — prompts for all options
bash scripts/prepare-airgap.sh
# Or fully automated
bash scripts/prepare-airgap.sh --wasm-base-url https://internal.example.com/wasm
```
Esto genera un directorio con el paquete:
```
bentopdf-airgap-bundle/
bentopdf.tar # Docker image
*.tgz # WASM packages (PyMuPDF, Ghostscript, CoherentPDF, Tesseract)
tesseract-langdata/ # OCR traineddata files
ocr-fonts/ # OCR text-layer font files
setup.sh # Setup script for the air-gapped side
README.md # Instructions
```
Transfiere el paquete a la red aislada mediante USB, un repositorio interno de artefactos o un método aprobado. Después ejecuta el script de configuración incluido:
```bash
cd bentopdf-airgap-bundle
bash setup.sh
```
El script de configuración carga la imagen de Docker, extrae los archivos WASM y, opcionalmente, inicia el contenedor.
**Opciones del script:**
| Opción | Descripción | Valor por defecto |
| ------------------------------ | ----------------------------------------------------------- | ------------------------------------- |
| `--wasm-base-url <url>` | Dónde se alojarán los WASM internamente | _(obligatorio, se pregunta si falta)_ |
| `--image-name <name>` | Etiqueta de la imagen de Docker | `bentopdf` |
| `--output-dir <path>` | Directorio de salida del paquete | `./bentopdf-airgap-bundle` |
| `--simple-mode` | Activa el Modo Simple | desactivado |
| `--base-url <path>` | URL base de subdirectorio (p. ej. `/pdf/`) | `/` |
| `--language <code>` | Idioma predeterminado de la interfaz (p. ej. `fr`, `de`) | _(ninguno)_ |
| `--brand-name <name>` | Nombre de marca personalizado | _(ninguno)_ |
| `--brand-logo <path>` | Ruta del logotipo relativa a `public/` | _(ninguno)_ |
| `--footer-text <text>` | Texto personalizado del pie de página | _(ninguno)_ |
| `--ocr-languages <list>` | Idiomas de OCR separados por comas que se incluirán | `eng` |
| `--list-ocr-languages` | Muestra los códigos y nombres de OCR admitidos y sale | desactivado |
| `--search-ocr-language <term>` | Busca códigos de OCR por nombre o abreviatura | desactivado |
| `--dockerfile <path>` | Dockerfile que se usará | `Dockerfile` |
| `--skip-docker` | Omite la compilación y exportación de Docker | desactivado |
| `--skip-wasm` | Omite la descarga de WASM (reutiliza los `.tgz` existentes) | desactivado |
El prompt interactivo también acepta `list` para mostrar la lista completa de códigos de Tesseract admitidos y `search <term>` para encontrar coincidencias como `search german` o `search chi`.
::: warning Requisito de mismo origen
Los archivos WASM deben servirse desde el **mismo origen** que la aplicación BentoPDF. Los Web Workers usan `importScripts()`, que no puede cargar scripts de otro origen. Por ejemplo, si BentoPDF se ejecuta en `https://internal.example.com`, la URL base de WASM también debe ser `https://internal.example.com/wasm`.
:::
#### Pasos manuales
<details>
<summary>Si prefieres hacerlo manualmente sin el script</summary>
**Paso 1: Descargar los paquetes de WASM y OCR** (en una máquina con internet)
```bash
npm pack @bentopdf/pymupdf-wasm@0.11.14
npm pack @bentopdf/gs-wasm
npm pack coherentpdf
npm pack tesseract.js@7.0.0
npm pack tesseract.js-core@7.0.0
mkdir -p tesseract-langdata
curl -fsSL https://cdn.jsdelivr.net/npm/@tesseract.js-data/eng/4.0.0_best_int/eng.traineddata.gz -o tesseract-langdata/eng.traineddata.gz
mkdir -p ocr-fonts
curl -fsSL https://raw.githack.com/googlefonts/noto-fonts/main/hinted/ttf/NotoSans/NotoSans-Regular.ttf -o ocr-fonts/NotoSans-Regular.ttf
```
**Paso 2: Compilar la imagen de Docker con URL internas**
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
docker build \
--build-arg VITE_WASM_PYMUPDF_URL=https://internal-server.example.com/wasm/pymupdf/ \
--build-arg VITE_WASM_GS_URL=https://internal-server.example.com/wasm/gs/ \
--build-arg VITE_WASM_CPDF_URL=https://internal-server.example.com/wasm/cpdf/ \
--build-arg VITE_TESSERACT_WORKER_URL=https://internal-server.example.com/wasm/ocr/worker.min.js \
--build-arg VITE_TESSERACT_CORE_URL=https://internal-server.example.com/wasm/ocr/core \
--build-arg VITE_TESSERACT_LANG_URL=https://internal-server.example.com/wasm/ocr/lang-data \
--build-arg VITE_OCR_FONT_BASE_URL=https://internal-server.example.com/wasm/ocr/fonts \
-t bentopdf .
```
**Paso 3: Exportar la imagen de Docker**
```bash
docker save bentopdf -o bentopdf.tar
```
**Paso 4: Transferir a la red aislada**
Copia mediante USB, un repositorio interno de artefactos o un método de transferencia aprobado:
- `bentopdf.tar`: la imagen de Docker
- Los cinco paquetes `.tgz` de WASM/OCR del Paso 1
- El directorio `tesseract-langdata/` del Paso 1
- El directorio `ocr-fonts/` del Paso 1
**Paso 5: Configurar dentro de la red aislada**
```bash
# Load the Docker image
docker load -i bentopdf.tar
# Extract WASM packages
mkdir -p ./wasm/pymupdf ./wasm/gs ./wasm/cpdf ./wasm/ocr/core ./wasm/ocr/lang-data ./wasm/ocr/fonts
tar xzf bentopdf-pymupdf-wasm-0.11.14.tgz -C ./wasm/pymupdf --strip-components=1
tar xzf bentopdf-gs-wasm-*.tgz -C ./wasm/gs --strip-components=1
tar xzf coherentpdf-*.tgz -C ./wasm/cpdf --strip-components=1
TEMP_TESS=$(mktemp -d)
tar xzf tesseract.js-7.0.0.tgz -C "$TEMP_TESS"
cp "$TEMP_TESS/package/dist/worker.min.js" ./wasm/ocr/worker.min.js
rm -rf "$TEMP_TESS"
tar xzf tesseract.js-core-7.0.0.tgz -C ./wasm/ocr/core --strip-components=1
cp ./tesseract-langdata/*.traineddata.gz ./wasm/ocr/lang-data/
cp ./ocr-fonts/* ./wasm/ocr/fonts/
# Run BentoPDF
docker run -d -p 3000:8080 --restart unless-stopped bentopdf
```
Asegúrate de que los archivos sean accesibles en las URL que configuraste en el Paso 2, incluidas `.../ocr/worker.min.js`, `.../ocr/core`, `.../ocr/lang-data` y `.../ocr/fonts`.
</details>
::: info ¿Compilas desde el código fuente en lugar de usar Docker?
Define las variables en `.env.production` antes de ejecutar `npm run build`:
```bash
VITE_WASM_PYMUPDF_URL=https://internal-server.example.com/wasm/pymupdf/
VITE_WASM_GS_URL=https://internal-server.example.com/wasm/gs/
VITE_WASM_CPDF_URL=https://internal-server.example.com/wasm/cpdf/
VITE_TESSERACT_WORKER_URL=https://internal-server.example.com/wasm/ocr/worker.min.js
VITE_TESSERACT_CORE_URL=https://internal-server.example.com/wasm/ocr/core
VITE_TESSERACT_LANG_URL=https://internal-server.example.com/wasm/ocr/lang-data
VITE_OCR_FONT_BASE_URL=https://internal-server.example.com/wasm/ocr/fonts
```
:::
### Alojar tu propio proxy de WASM
Si necesitas servir archivos WASM con licencia AGPL con las cabeceras CORS adecuadas, puedes desplegar un proxy sencillo. Consulta la [guía del proxy de WASM en Cloudflare](https://github.com/alam00000/bentopdf/blob/main/cloudflare/WASM-PROXY.md) para ver una implementación de ejemplo.
::: tip ¿Por qué por separado?
Esta separación garantiza:
- Un cumplimiento legal claro para los usuarios comerciales
- Que el núcleo de BentoPDF siga bajo su doble licencia (AGPL-3.0 / Comercial)
- Que los archivos WASM se carguen en tiempo de ejecución, no incluidos en el código fuente
:::
## Requisitos del sistema
| Requisito | Mínimo |
| -------------- | --------------------------------- |
| Almacenamiento | ~100 MB (núcleo sin módulos AGPL) |
| RAM | 512 MB |
| CPU | Cualquier procesador moderno |
::: tip
BentoPDF es un sitio estático: no se necesita base de datos ni servidor backend.
:::
docs/es/self-hosting/kubernetes.md
+211
View File
@@ -0,0 +1,211 @@
# Despliegue con Kubernetes
Kubernetes puede ser excesivo para un sitio estático, pero puede encajar muy bien si ya estandarizas con Helm + GitOps.
> [!IMPORTANT]
> **Cabeceras necesarias para la conversión de archivos de Office**
>
> Las herramientas basadas en LibreOffice (conversión de Word, Excel y PowerPoint) requieren estas cabeceras HTTP para la compatibilidad con `SharedArrayBuffer`:
>
> - `Cross-Origin-Opener-Policy: same-origin`
> - `Cross-Origin-Embedder-Policy: require-corp`
>
> Las imágenes oficiales de BentoPDF con nginx incluyen estas cabeceras. En Kubernetes, **los controladores de Ingress/Gateway también son proxies inversos**, así que asegúrate de que estas cabeceras se conserven (o añádelas en el borde).
## Requisitos previos
- Clúster de Kubernetes
- Helm v3
- Una imagen de BentoPDF con nginx (p. ej. `ghcr.io/alam00000/bentopdf:<tag>`) que sirva en el **puerto 8080**
## Despliegue con Helm
### Instalar desde este repositorio (chart local)
```bash
kubectl create namespace bentopdf
helm upgrade --install bentopdf /path/to/bentopdf/chart \
--namespace bentopdf \
--set image.repository=ghcr.io/alam00000/bentopdf \
--set image.tag=latest
```
### Instalar desde GHCR (chart OCI)
Si el chart está publicado en GHCR como artefacto OCI:
```bash
export GHCR_USERNAME="<github-org-or-user>"
helm upgrade --install bentopdf oci://ghcr.io/$GHCR_USERNAME/charts/bentopdf \
--namespace bentopdf \
--create-namespace \
--version 0.1.0 \
--set image.repository=ghcr.io/alam00000/bentopdf \
--set image.tag=latest
```
## Exponerlo
### Port-forward (prueba rápida)
```bash
kubectl -n bentopdf port-forward deploy/bentopdf 8080:8080
```
### Ingress (opcional)
Activa Ingress (ejemplo para nginx-ingress):
```yaml
ingress:
enabled: true
className: nginx
hosts:
- host: pdf.example.com
paths:
- path: /
pathType: Prefix
```
### Gateway API (opcional)
Este chart es compatible con `Gateway` + `HTTPRoute` de Gateway API.
Ejemplo (operador de Gateway API de Cloudflare):
```yaml
gateway:
enabled: true
name: bento-tunnel
namespace: bentopdf
gatewayClassName: cloudflare
httpRoute:
enabled: true
parentRefs:
- name: bento-tunnel
namespace: bentopdf
sectionName: http
hostnames:
- pdfs.example.com
```
## Cómo comprobar que las cabeceras de SharedArrayBuffer siguen funcionando (Ingress/Gateway)
### Lo que "debería" pasar
La configuración de nginx de BentoPDF establece las cabeceras de respuesta necesarias. La mayoría de los controladores de Ingress/Gateway **pasan las cabeceras de respuesta del upstream sin modificarlas**.
### Qué puede romperlo
- Una política del controlador o del borde que **sobrescriba** o **elimine** cabeceras de respuesta
- Un middleware de "cabeceras de seguridad" que establezca valores de COOP/COEP distintos
### Cómo verificarlo
Ejecuta esto contra tu endpoint público:
```bash
curl -I https://pdf.example.com/ | egrep -i 'cross-origin-opener-policy|cross-origin-embedder-policy'
```
Deberías ver:
- `Cross-Origin-Opener-Policy: same-origin`
- `Cross-Origin-Embedder-Policy: require-corp`
### Si tu controlador de Ingress no las conserva
Añade las cabeceras en el borde (depende del controlador). Ejemplo para **nginx-ingress**:
```yaml
ingress:
enabled: true
className: nginx
annotations:
nginx.ingress.kubernetes.io/configuration-snippet: |
add_header Cross-Origin-Opener-Policy "same-origin" always;
add_header Cross-Origin-Embedder-Policy "require-corp" always;
```
## Errores de tipo MIME de `.mjs` (iframe en blanco en Firmar PDF / Rellenar formularios)
Si la consola del navegador muestra `Failed to load module script: ... non-JavaScript MIME type "application/octet-stream"` en una petición `.mjs`, un controlador de Ingress/Gateway situado delante del nginx de BentoPDF está reemplazando la cabecera `Content-Type` del upstream por `application/octet-stream`.
El nginx de la imagen de BentoPDF ya sirve `.mjs` como `application/javascript`. La solución es evitar que el controlador la elimine o la reemplace. Para nginx-ingress:
```yaml
ingress:
annotations:
nginx.ingress.kubernetes.io/configuration-snippet: |
location ~* \.mjs$ {
types {} default_type application/javascript;
}
```
O bien usa un filtro `ResponseHeaderModifier` en Gateway API para establecer `Content-Type: application/javascript` en las rutas `.mjs`. Verifica con DevTools → pestaña Network: la petición `.mjs` que fallaba ahora debería mostrar `content-type: application/javascript`.
### Si usas Gateway API y quieres forzar la adición de cabeceras
Gateway API admite un filtro `ResponseHeaderModifier`. Puedes asociarlo en `httpRoute.rules[*].filters`:
```yaml
httpRoute:
enabled: true
hostnames: [pdf.example.com]
parentRefs:
- name: bento-tunnel
namespace: misc
sectionName: http
rules:
- matches:
- path: { type: PathPrefix, value: / }
filters:
- type: ResponseHeaderModifier
responseHeaderModifier:
set:
- name: Cross-Origin-Opener-Policy
value: same-origin
- name: Cross-Origin-Embedder-Policy
value: require-corp
```
La compatibilidad con filtros concretos depende de tu controlador de Gateway; si se ignora un filtro, añade las cabeceras en la capa del borde o del controlador.
## Desactivar herramientas específicas
Usa un ConfigMap para desactivar herramientas en tiempo de ejecución sin reconstruir la imagen:
```yaml
apiVersion: v1
kind: ConfigMap
metadata:
name: bentopdf-config
namespace: bentopdf
data:
config.json: |
{
"disabledTools": ["edit-pdf", "sign-pdf", "encrypt-pdf"]
}
```
Móntalo en el directorio servido:
```yaml
spec:
containers:
- name: bentopdf
volumeMounts:
- name: config
mountPath: /usr/share/nginx/html/config.json
subPath: config.json
readOnly: true
volumes:
- name: config
configMap:
name: bentopdf-config
```
Los ID de las herramientas son la URL de la página sin `.html`: abre cualquier herramienta y mira la URL (p. ej., `edit-pdf`, `merge-pdf`, `compress-pdf`). Las herramientas desactivadas se ocultan en la página de inicio, la búsqueda, los atajos, el generador de flujos de trabajo y el acceso directo por URL. Consulta la [guía de Docker](/es/self-hosting/docker#desactivar-herramientas-concretas) para ver la lista completa de opciones.
docs/es/self-hosting/netlify.md
+139
View File
@@ -0,0 +1,139 @@
# Despliegue en Netlify
[Netlify](https://netlify.com) ofrece un excelente alojamiento de sitios estáticos con un generoso plan gratuito.
## Despliegue con un clic
[![Deploy to Netlify](https://www.netlify.com/img/deploy/button.svg)](https://app.netlify.com/start/deploy?repository=https://github.com/alam00000/bentopdf)
## Despliegue manual
### Paso 1: Conectar el repositorio
1. Inicia sesión en [Netlify](https://app.netlify.com)
2. Haz clic en "Add new site" → "Import an existing project"
3. Conecta tu cuenta de GitHub
4. Selecciona tu fork de BentoPDF
### Paso 2: Configurar los ajustes de compilación
| Ajuste | Valor |
| ------------------------- | --------------- |
| Comando de compilación | `npm run build` |
| Directorio de publicación | `dist` |
| Versión de Node | 18+ |
### Paso 3: Desplegar
Haz clic en "Deploy site" y espera a que termine la compilación.
## Archivo de configuración
Crea `netlify.toml` en la raíz de tu proyecto:
```toml
[build]
command = "npm run build"
publish = "dist"
[build.environment]
NODE_VERSION = "18"
# Required security headers for SharedArrayBuffer (used by LibreOffice WASM)
[[headers]]
for = "/*"
[headers.values]
Cross-Origin-Embedder-Policy = "require-corp"
Cross-Origin-Opener-Policy = "same-origin"
Cross-Origin-Resource-Policy = "cross-origin"
# Pre-compressed LibreOffice WASM binary - must be served with Content-Encoding
[[headers]]
for = "/libreoffice-wasm/soffice.wasm.gz"
[headers.values]
Content-Type = "application/wasm"
Content-Encoding = "gzip"
Cache-Control = "public, max-age=31536000, immutable"
# Pre-compressed LibreOffice WASM data - must be served with Content-Encoding
[[headers]]
for = "/libreoffice-wasm/soffice.data.gz"
[headers.values]
Content-Type = "application/octet-stream"
Content-Encoding = "gzip"
Cache-Control = "public, max-age=31536000, immutable"
# Cache other WASM files
[[headers]]
for = "*.wasm"
[headers.values]
Cache-Control = "public, max-age=31536000, immutable"
Content-Type = "application/wasm"
# SPA routing
[[redirects]]
from = "/*"
to = "/index.html"
status = 200
```
::: warning Importante
Las cabeceras `Cross-Origin-Embedder-Policy` y `Cross-Origin-Opener-Policy` son necesarias para las conversiones de Word/ODT/Excel/PowerPoint a PDF. Sin ellas, `SharedArrayBuffer` no está disponible y el motor LibreOffice WASM no podrá inicializarse.
Las cabeceras `Content-Encoding: gzip` en los archivos `.wasm.gz` y `.data.gz` indican al navegador que los descomprima automáticamente. Sin ellas, el navegador recibe bytes gzip sin procesar y la compilación de WASM falla.
:::
## Variables de entorno
Configúralas en Site settings → Environment variables:
| Variable | Descripción |
| ----------------------- | -------------------------------------------------------------------- |
| `SIMPLE_MODE` | Ponla en `true` para una compilación mínima |
| `VITE_BRAND_NAME` | Nombre de marca personalizado (reemplaza "BentoPDF") |
| `VITE_BRAND_LOGO` | Ruta del logotipo relativa a `public/` (p. ej. `images/my-logo.svg`) |
| `VITE_FOOTER_TEXT` | Texto personalizado del pie de página y de derechos de autor |
| `VITE_DEFAULT_LANGUAGE` | Idioma predeterminado de la interfaz (p. ej. `fr`, `de`, `es`) |
## Dominio personalizado
1. Ve a Site settings → Domain management
2. Haz clic en "Add custom domain"
3. Sigue las instrucciones de configuración de DNS
## Archivos multimedia grandes
Para archivos WASM grandes, considera activar [Netlify Large Media](https://docs.netlify.com/large-media/overview/):
```bash
netlify lm:setup
git lfs track "*.wasm"
```
## Solución de problemas
### La conversión de Word/ODT/Excel a PDF se queda atascada en el 55%
Si las conversiones de documentos se quedan colgadas en el 55%, abre la consola de DevTools y comprueba:
```js
console.log(window.crossOriginIsolated); // should be true
console.log(typeof SharedArrayBuffer); // should be "function"
```
Si `crossOriginIsolated` es `false`, las cabeceras COEP/COOP de tu `netlify.toml` no se están aplicando. Asegúrate de que el archivo esté en la raíz de tu proyecto y vuelve a desplegar.
Si ves `expected magic word 00 61 73 6d, found 1f 8b 08 08` en la consola, a los archivos `.wasm.gz` les faltan las cabeceras `Content-Encoding: gzip`. Asegúrate de que los bloques `[[headers]]` de `soffice.wasm.gz` y `soffice.data.gz` estén en tu `netlify.toml`.
### Falla la compilación
Comprueba la compatibilidad de la versión de Node:
```toml
[build.environment]
NODE_VERSION = "20"
```
### Carga inicial lenta
Activa la optimización de recursos en Site settings → Build & deploy → Asset optimization.
docs/es/self-hosting/nginx.md
+232
View File
@@ -0,0 +1,232 @@
# Despliegue con Nginx
Aloja BentoPDF en tu propio servidor con Nginx.
## Requisitos previos
- Servidor Ubuntu/Debian
- Nginx instalado
- Certificado SSL (recomendado: Let's Encrypt)
## Paso 1: Compilar el proyecto
```bash
git clone https://github.com/alam00000/bentopdf.git
cd bentopdf
npm install
npm run build
```
Para personalizar la marca, define variables de entorno antes de compilar:
```bash
VITE_BRAND_NAME="AcmePDF" VITE_BRAND_LOGO="images/acme-logo.svg" npm run build
```
## Paso 2: Copiar los archivos
```bash
sudo mkdir -p /var/www/bentopdf
sudo cp -r dist/* /var/www/bentopdf/
sudo chown -R www-data:www-data /var/www/bentopdf
```
## Paso 3: Configuración de Nginx
Crea `/etc/nginx/sites-available/bentopdf`:
```nginx
server {
listen 80;
server_name your-domain.com;
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl http2;
server_name your-domain.com;
# SSL Configuration
ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem;
root /var/www/bentopdf;
index index.html;
# Gzip compression
gzip on;
gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/wasm;
gzip_min_length 1000;
# WASM MIME type
types {
application/wasm wasm;
}
# Required headers for SharedArrayBuffer (LibreOffice WASM)
# These must be on every response - especially HTML pages
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
add_header Cross-Origin-Resource-Policy "cross-origin" always;
# Security headers
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-Content-Type-Options "nosniff" always;
add_header X-XSS-Protection "1; mode=block" always;
# Pre-compressed LibreOffice WASM binary
location ~* /libreoffice-wasm/soffice\.wasm\.gz$ {
gzip off;
types {} default_type application/wasm;
add_header Content-Encoding gzip;
add_header Cache-Control "public, immutable";
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
}
# Pre-compressed LibreOffice WASM data
location ~* /libreoffice-wasm/soffice\.data\.gz$ {
gzip off;
types {} default_type application/octet-stream;
add_header Content-Encoding gzip;
add_header Cache-Control "public, immutable";
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
}
# Cache static assets
location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|wasm)$ {
expires 1y;
add_header Cache-Control "public, immutable";
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
}
# SPA routing - serve index.html for all routes
location / {
try_files $uri $uri/ /index.html;
add_header Cross-Origin-Embedder-Policy "require-corp" always;
add_header Cross-Origin-Opener-Policy "same-origin" always;
}
}
```
## Paso 4: Activar el sitio
```bash
sudo ln -s /etc/nginx/sites-available/bentopdf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx
```
## Paso 5: SSL con Let's Encrypt
```bash
sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d your-domain.com
```
## Despliegue en un subdirectorio
Para alojarlo en `/pdf/`:
```nginx
location /pdf/ {
alias /var/www/bentopdf/;
try_files $uri $uri/ /pdf/index.html;
}
```
Compila con:
```bash
BASE_URL=/pdf/ npm run build
```
## Ajuste del rendimiento
Añade a `nginx.conf`:
```nginx
http {
# Enable sendfile
sendfile on;
tcp_nopush on;
tcp_nodelay on;
# Increase buffer sizes
client_max_body_size 100M;
# Worker connections
worker_connections 2048;
}
```
## Solución de problemas
### WASM no se carga
Asegúrate de que el tipo MIME esté definido:
```nginx
types {
application/wasm wasm;
}
```
### Firmar PDF o Rellenar formularios muestra un visor en blanco (error MIME de `.mjs`)
Si la consola del navegador muestra:
```
Failed to load module script: The server responded with a non-JavaScript
MIME type of "application/octet-stream". Strict MIME type checking is
enforced for module scripts per HTML spec.
```
...y la petición que falla termina en `.mjs`, a tu nginx le falta la asignación `.mjs → application/javascript`. El visor de PDF incluido (usado por Firmar PDF, Rellenar formularios y algunas otras herramientas) incorpora archivos de módulos ES con extensión `.mjs`, y el `mime.types` por defecto de nginx no los incluye.
Para solucionarlo, añade `mjs` a la línea `application/javascript` existente en `/etc/nginx/mime.types`:
```nginx
application/javascript js mjs;
```
> NO añadas una _segunda_ línea `application/javascript`: nginx analiza `mime.types` línea por línea y solo prevalece una asignación de tipo a extensión, así que en algunas versiones la segunda línea se ignora sin avisar. Edita la línea existente para añadir `mjs` junto a `js`.
O bien sobrescríbelo localmente dentro de tu bloque server (sin editar el archivo global):
```nginx
types {
application/javascript js mjs;
application/wasm wasm;
}
```
Recarga nginx después del cambio:
```bash
sudo nginx -t && sudo systemctl reload nginx
```
Para confirmarlo: en DevTools del navegador → pestaña Network, busca la petición `.mjs` que fallaba y revisa la cabecera de respuesta `Content-Type`. Ahora debería ser `application/javascript`, no `application/octet-stream`.
### La conversión de Word/ODT/Excel a PDF no funciona
LibreOffice WASM requiere `SharedArrayBuffer`, que necesita las cabeceras `Cross-Origin-Embedder-Policy` y `Cross-Origin-Opener-Policy`. También necesita un contexto seguro, así que `http://localhost` sirve para pruebas locales, pero `http://192.168.x.x` u otras IP de la red local normalmente requieren HTTPS. Ten en cuenta que las directivas `add_header` de nginx dentro de un bloque `location` **sobrescriben** las directivas `add_header` del nivel de servidor: no se combinan. Todo bloque `location` con sus propios `add_header` debe incluir las cabeceras COEP/COOP.
Verifica con:
```bash
curl -I https://your-domain.com/ | grep -i cross-origin
```
Si usas un proxy inverso delante de nginx, asegúrate de que conserve estas cabeceras.
### 502 Bad Gateway
Revisa los registros de errores de Nginx:
```bash
sudo tail -f /var/log/nginx/error.log
```
docs/es/self-hosting/vercel.md
+122
View File
@@ -0,0 +1,122 @@
# Despliegue en Vercel
[Vercel](https://vercel.com) ofrece la experiencia de despliegue más sencilla para sitios estáticos.
## Despliegue con un clic
[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https://github.com/alam00000/bentopdf)
## Despliegue manual
### Paso 1: Hacer un fork del repositorio
Haz un fork de [bentopdf/bentopdf](https://github.com/alam00000/bentopdf) en tu cuenta de GitHub.
### Paso 2: Importar en Vercel
1. Ve a [vercel.com/new](https://vercel.com/new)
2. Selecciona tu repositorio con el fork
3. Configura el proyecto:
| Ajuste | Valor |
| ---------------------- | --------------- |
| Framework Preset | Vite |
| Comando de compilación | `npm run build` |
| Directorio de salida | `dist` |
| Comando de instalación | `npm install` |
### Paso 3: Variables de entorno (opcional)
Añádelas si las necesitas:
| Variable | Descripción |
| ----------------------- | -------------------------------------------------------------------- |
| `SIMPLE_MODE` | Ponla en `true` para una interfaz mínima |
| `VITE_BRAND_NAME` | Nombre de marca personalizado (reemplaza "BentoPDF") |
| `VITE_BRAND_LOGO` | Ruta del logotipo relativa a `public/` (p. ej. `images/my-logo.svg`) |
| `VITE_FOOTER_TEXT` | Texto personalizado del pie de página y de derechos de autor |
| `VITE_DEFAULT_LANGUAGE` | Idioma predeterminado de la interfaz (p. ej. `fr`, `de`, `es`) |
### Paso 4: Desplegar
Haz clic en "Deploy" y espera a que termine la compilación.
## Dominio personalizado
1. Ve a los ajustes de tu proyecto
2. Ve a "Domains"
3. Añade tu dominio personalizado
4. Configura el DNS según las instrucciones
## Limitaciones
::: warning Archivos grandes
Las funciones serverless de Vercel tienen un límite de 50 MB. Como BentoPDF es un sitio estático, esto no debería afectarte, pero los módulos WASM son grandes (~100 MB en total). Asegúrate de que se sirvan desde la carpeta `/public`.
:::
## Solución de problemas
### Tiempo de espera agotado en la compilación
Si las compilaciones agotan el tiempo de espera, prueba lo siguiente:
```json
// vercel.json
{
"buildCommand": "npm run build",
"outputDirectory": "dist"
}
```
### Error 404 al recargar
Añade un `vercel.json` para el enrutamiento SPA:
```json
{
"rewrites": [{ "source": "/(.*)", "destination": "/index.html" }]
}
```
### La conversión de Word/ODT/Excel a PDF no funciona
Las conversiones de LibreOffice WASM requieren `SharedArrayBuffer`, que necesita estas cabeceras de respuesta en todas las páginas:
- `Cross-Origin-Embedder-Policy: require-corp`
- `Cross-Origin-Opener-Policy: same-origin`
Los archivos precomprimidos `.wasm.gz` y `.data.gz` también necesitan `Content-Encoding: gzip` para que el navegador los descomprima.
Añade esto a tu `vercel.json`:
```json
{
"rewrites": [{ "source": "/(.*)", "destination": "/index.html" }],
"headers": [
{
"source": "/(.*)",
"headers": [
{ "key": "Cross-Origin-Embedder-Policy", "value": "require-corp" },
{ "key": "Cross-Origin-Opener-Policy", "value": "same-origin" },
{ "key": "Cross-Origin-Resource-Policy", "value": "cross-origin" }
]
},
{
"source": "/libreoffice-wasm/soffice.wasm.gz",
"headers": [
{ "key": "Content-Type", "value": "application/wasm" },
{ "key": "Content-Encoding", "value": "gzip" }
]
},
{
"source": "/libreoffice-wasm/soffice.data.gz",
"headers": [
{ "key": "Content-Type", "value": "application/octet-stream" },
{ "key": "Content-Encoding", "value": "gzip" }
]
}
]
}
```
Para verificarlo, abre la consola de DevTools y ejecuta `console.log(window.crossOriginIsolated)`: debería devolver `true`.
docs/es/tools/add-attachments.md
+49
View File
@@ -0,0 +1,49 @@
---
title: Agregar adjuntos
description: Incrusta archivos de cualquier tipo en un PDF a nivel de documento o asociados a páginas concretas.
---
# Agregar adjuntos
Incrusta uno o varios archivos directamente dentro de un documento PDF. Los adjuntos pueden añadirse a nivel de documento (visibles en el panel de adjuntos de cualquier lector de PDF) o vincularse a páginas concretas.
## Cómo funciona
1. Sube el PDF al que quieres adjuntar archivos.
2. Usa la zona de carga de adjuntos para seleccionar los archivos que quieres incrustar (de cualquier tipo).
3. Elige el nivel del adjunto: **Documento** (predeterminado) o **Página**.
4. Si eliges el nivel de página, introduce un rango de páginas (por ejemplo, `1-3` o `5`).
5. Haz clic en el botón de procesar. El PDF modificado se descarga con tus archivos incrustados.
## Características
- Adjunta cualquier tipo de archivo: imágenes, hojas de cálculo, archivos comprimidos, ejecutables, lo que sea
- Colocación de adjuntos a nivel de documento o de página
- Se pueden adjuntar varios archivos en una sola operación
- Muestra los nombres y tamaños de todos los adjuntos seleccionados
- El resultado conserva el contenido original del PDF con los archivos incrustados añadidos
## Opciones
| Opción | Descripción |
| ---------------------- | -------------------------------------------------------------------------------- |
| **Nivel de documento** | Adjunta los archivos al PDF completo, accesibles desde el panel de adjuntos |
| **Nivel de página** | Adjunta los archivos a páginas concretas, indicadas mediante un rango de páginas |
## Casos de uso
- Incluir datos de origen (archivos de Excel, CSV) junto con un informe en PDF
- Adjuntar los archivos de imagen originales a un PDF de portafolio fotográfico
- Incrustar documentos de respaldo dentro de un contrato o una propuesta
- Añadir material complementario a páginas específicas de un manual de formación
## Consejos
- Los adjuntos a nivel de documento son los más compatibles entre lectores de PDF. Es posible que los adjuntos a nivel de página no se vean en todos los visores.
- No hay límite de tamaño para los adjuntos, pero los archivos incrustados muy grandes aumentarán el tamaño del PDF de forma proporcional.
## Herramientas relacionadas
- [Extraer Adjuntos](./extract-attachments)
- [Editar Adjuntos](./edit-attachments)
- [Fusionar PDF](./merge-pdf)
docs/es/tools/add-blank-page.md
+40
View File
@@ -0,0 +1,40 @@
---
title: Agregar página en blanco
description: Inserta una o varias páginas en blanco en cualquier posición de un documento PDF.
---
# Agregar página en blanco
Inserta páginas vacías en un PDF en la posición que indiques. Tú controlas dónde van las páginas en blanco y cuántas añadir.
## Cómo funciona
1. Sube un archivo PDF. La herramienta muestra el número de páginas.
2. Introduce la **posición** donde se insertarán las páginas en blanco. Usa `0` para insertar al principio del todo, o el número total de páginas para añadirlas al final.
3. Introduce el **número** de páginas en blanco que quieres añadir (por defecto es 1).
4. Haz clic en el botón de procesar. El PDF modificado se descarga con las páginas en blanco insertadas.
## Características
- Inserta en cualquier posición: al principio, en medio o al final del documento
- Añade varias páginas en blanco en una sola operación
- La sugerencia de posición se actualiza dinámicamente según el número de páginas del PDF subido
- Páginas en blanco de tamaño A4 estándar
## Casos de uso
- Añadir una página separadora en blanco entre las secciones de un documento recopilado
- Insertar páginas en blanco para alinear la impresión a doble cara
- Dejar espacio para notas a mano en una guía de estudio impresa
- Rellenar un documento para cumplir con un requisito de número mínimo de páginas
## Consejos
- La posición `0` inserta antes de la primera página. Una posición igual al número total de páginas añade después de la última página.
- Si necesitas insertar contenido (no solo páginas en blanco) en una posición concreta, usa [Multiherramienta PDF](./pdf-multi-tool) para insertar otro PDF después de una página determinada.
## Herramientas relacionadas
- [Duplicar y Organizar](./organize-pdf)
- [Multiherramienta PDF](./pdf-multi-tool)
- [Fusionar PDF](./merge-pdf)
docs/es/tools/add-page-labels.md
+53
View File
@@ -0,0 +1,53 @@
---
title: Agregar etiquetas de página
description: Agrega etiquetas de página PDF con números romanos, prefijos de letras, numeración personalizada y varias reglas por documento.
---
# Agregar etiquetas de página
Las etiquetas de página controlan cómo se muestran los números de página en los visores de PDF (el número que aparece en la barra de herramientas, no impreso en la página). Esta herramienta te permite asignar distintos esquemas de etiquetado a distintos rangos de páginas: números romanos para las páginas preliminares, números decimales para el cuerpo, apéndices con letras y más.
## Cómo funciona
1. Sube tu archivo PDF.
2. Aparece el panel de opciones con una regla de etiquetas por defecto.
3. Configura cada regla con un rango de páginas, un estilo, un prefijo opcional y un valor inicial.
4. Haz clic en **Agregar regla** para crear reglas adicionales para otras secciones.
5. Haz clic en **Agregar etiquetas de página** para aplicar todas las reglas y descargar el resultado.
## Opciones
Cada regla de etiquetas tiene estos ajustes:
- **Rango de páginas**: las páginas a las que se aplica la regla. Déjalo vacío para todas las páginas. Admite rangos como `1-4`, `7`, `odd` o `1-9,30-40`.
- **Estilo de etiqueta**: Arábigo decimal, Romanos en minúsculas (i, ii, iii), Romanos en mayúsculas (I, II, III), Letras en minúsculas (a, b, c), Letras en mayúsculas (A, B, C) o Sin etiqueta (solo prefijo).
- **Prefijo de etiqueta**: texto opcional que se antepone a cada etiqueta, como "A-" para crear etiquetas como A-1, A-2, A-3.
- **Valor inicial**: el número desde el que empezar a contar. Por defecto es 1. Ponlo en 0 para una numeración que empiece en cero.
- **Continuar la numeración entre rangos no contiguos**: actívalo cuando una regla se dirija a páginas no contiguas (como `1-9,30-40` u `odd`) y quieras que la numeración continúe de forma secuencial.
- **Eliminar las etiquetas de página existentes**: marcado por defecto. Borra las etiquetas anteriores antes de aplicar tus nuevas reglas.
## Características
- Varias reglas de etiquetas por documento para esquemas de numeración complejos
- Seis estilos de etiqueta que cubren todos los sistemas de numeración estándar
- Compatibilidad con prefijos personalizados para etiquetar por secciones
- Compatibilidad con rangos no contiguos con numeración progresiva
- Opción para conservar o eliminar las etiquetas existentes
## Casos de uso
- Establecer etiquetas con números romanos (i, ii, iii) para el prefacio de un libro y etiquetas decimales para el texto principal
- Etiquetar las páginas de apéndices con prefijos de letras como "A-1", "A-2", "B-1", "B-2"
- Corregir las etiquetas de página en un documento escaneado donde los números de página físicos no coinciden con el orden de páginas del PDF
- Agregar numeración desde cero para documentos técnicos
## Consejos
- Las etiquetas de página son metadatos que los visores de PDF muestran en su barra de navegación. No se imprimen en la página. Para números visibles, usa [Números de Página](./page-numbers).
- Esta herramienta requiere que CoherentPDF (CPDF) esté configurado en tus Ajustes de WASM. Si no está configurado, se te pedirá que lo hagas.
## Herramientas relacionadas
- [Números de Página](./page-numbers)
- [Numeración Bates](./bates-numbering)
- [Editar Marcadores](./bookmark)
docs/es/tools/add-stamps.md
+45
View File
@@ -0,0 +1,45 @@
---
title: Agregar sellos
description: Agrega sellos de imagen a las páginas de tu PDF con una barra de herramientas de anotaciones integrada y atribución por nombre de usuario.
---
# Agregar sellos
Coloca sellos de imagen en las páginas de tu PDF usando un visor integrado con una barra de herramientas de anotaciones de sellos. Los sellos pueden incluir tu nombre como atribución, lo que resulta útil para flujos de aprobación, procesos de revisión y marcado de documentos.
## Cómo funciona
1. Escribe tu nombre en el campo **Nombre de usuario del sello**. Este nombre aparecerá en los sellos que crees.
2. Sube tu archivo PDF haciendo clic o arrastrándolo a la zona de carga.
3. El editor de sellos se abre con tu documento cargado en un visor.
4. Usa la herramienta de sello de imagen de la barra de herramientas para seleccionar y colocar sellos en cualquier página.
5. Coloca y cambia el tamaño de los sellos según necesites.
6. Haz clic en **Guardar PDF sellado** para descargar el resultado.
## Características
- Visor de PDF integrado con una barra de herramientas de anotaciones específica para sellos
- Atribución por nombre de usuario en los sellos creados
- Colocación de sellos de imagen en cualquier página
- Posicionamiento y cambio de tamaño con arrastrar y soltar
- Ajuste automático del tamaño del visor según la proporción de la página
- Visualización del archivo con su nombre y tamaño
## Casos de uso
- Añadir sellos de imagen de "APROBADO" o "REVISADO" a documentos en un flujo de revisión
- Colocar imágenes del sello de la empresa o de un notario en documentos oficiales
- Marcar páginas con sellos de "RECIBIDO" que incluyan el nombre del revisor
- Añadir sellos de control de calidad a informes de inspección
## Consejos
- Define tu nombre de usuario del sello antes de subir el PDF. El nombre de usuario se incrusta en los metadatos del sello.
- El visor ajusta su altura según la proporción de la primera página del PDF para una visualización óptima.
- Si quieres marcas de agua de texto en lugar de sellos de imagen, usa la herramienta [Agregar Marca de Agua](./add-watermark).
## Herramientas relacionadas
- [Firmar PDF](./sign-pdf)
- [Agregar Marca de Agua](./add-watermark)
- [Editor de PDF](./edit-pdf)
docs/es/tools/add-watermark.md
+79
View File
@@ -0,0 +1,79 @@
---
title: Agregar marca de agua
description: Estampa marcas de agua de texto o imagen en las páginas del PDF con un editor visual de arrastrar y soltar y vista previa en vivo.
---
# Agregar marca de agua
Agrega marcas de agua de texto o imagen a las páginas de tu PDF con un editor visual. Puedes colocar la marca de agua arrastrándola directamente en la vista previa, cambiar su tamaño con los tiradores de las esquinas y configurar la opacidad, la rotación, la fuente y el color. Cada página puede tener su propia posición de marca de agua, o puedes aplicar la misma marca de agua a todas las páginas a la vez.
## Cómo funciona
1. Sube tu archivo PDF.
2. El editor se abre con una vista previa en vivo de la primera página y una marca de agua superpuesta que se puede arrastrar.
3. Elige entre el modo de marca de agua de **Texto** o de **Imagen** con los botones de alternancia.
4. Configura los ajustes de la marca de agua en el panel lateral.
5. Arrastra la marca de agua en la vista previa para colocarla exactamente donde quieras. Usa los tiradores de las esquinas para cambiar su tamaño.
6. Navega entre las páginas para definir marcas de agua por página, o deja marcada la opción **Aplicar a todas las páginas**.
7. Haz clic en **Agregar Marca de Agua** para procesar y descargar.
## Opciones
**Ajustes de marca de agua de texto:**
- **Texto**: el texto de la marca de agua (por ejemplo, "CONFIDENCIAL", "BORRADOR").
- **Tamaño de fuente**: de 10 a 200 puntos. Por defecto es 72.
- **Color**: cualquier color mediante el selector de color.
- **Opacidad**: controla la transparencia, desde totalmente transparente hasta totalmente opaco.
- **Rotación**: gira el texto de la marca de agua de -180 a 180 grados.
**Ajustes de marca de agua de imagen:**
- **Subir imagen**: sube un archivo PNG, JPG u otro formato de imagen para usarlo como marca de agua.
- **Opacidad**: controla la transparencia de la imagen.
- **Escala**: cambia el tamaño de la imagen de la marca de agua.
**Ajustes de diseño:**
- **Única**: una marca de agua por página, colocada arrastrándola o con las posiciones predefinidas.
- **En mosaico**: repite la marca de agua por toda la página en una cuadrícula diagonal que sigue el ángulo de rotación, de modo que la marca cubre el documento de un borde a otro.
- **Espacio horizontal**: separación entre los mosaicos a lo largo de la dirección del texto, como porcentaje del ancho de la marca de agua (solo en modo mosaico).
- **Espacio vertical**: separación entre las filas de mosaicos, como porcentaje de la altura de la marca de agua (solo en modo mosaico).
**Ajustes generales:**
- **Aplicar a todas las páginas**: cuando está marcada, la misma marca de agua se aplica a todas las páginas. Desmárcala para definir marcas de agua individuales por página.
- **Rango de páginas**: indica qué páginas llevan la marca de agua (por ejemplo, "1-3, 5, 7-9" o "all").
## Características
- Posicionamiento visual de arrastrar y soltar sobre una vista previa del PDF en vivo
- Marca de agua redimensionable con tiradores en las esquinas
- Modos de marca de agua de texto e imagen
- Diseño único o en mosaico (repetido) a página completa con espaciado ajustable
- Aplicación de la marca de agua por página o global
- Navegación página por página en la vista previa
- Controles de opacidad y rotación
- Filtrado por rango de páginas
## Casos de uso
- Marcar documentos en borrador con "BORRADOR" antes de circularlos para su revisión
- Agregar marcas de agua de "CONFIDENCIAL" a informes financieros sensibles
- Dar identidad de marca a los documentos con una marca de agua de imagen con el logotipo de la empresa
- Estampar "MUESTRA" en documentación de producto compartida con clientes potenciales
- Agregar avisos de derechos de autor a materiales en PDF distribuidos
## Consejos
- Para marcas de agua diagonales en la página, establece una rotación de alrededor de 45 grados y aumenta el tamaño de fuente.
- El modo en mosaico hace que sea mucho más difícil reutilizar un documento recortándolo, ya que quitar una marca deja docenas más. Baja la opacidad al usar mosaico para que el texto de fondo siga siendo legible.
- Las marcas de agua de imagen con fondo transparente (formato PNG) se integran de forma más natural con el contenido del documento.
- Si necesitas un texto de marca de agua distinto en páginas diferentes, desmarca "Aplicar a todas las páginas" y navega página por página.
## Herramientas relacionadas
- [Encabezado y Pie de Página](./header-footer)
- [Agregar Sellos](./add-stamps)
- [Numeración Bates](./bates-numbering)
- [Firmar PDF](./sign-pdf)
docs/es/tools/adjust-colors.md
+55
View File
@@ -0,0 +1,55 @@
---
title: Ajustar colores
description: Ajusta con precisión el brillo, el contraste, la saturación, el tono, la temperatura, el matiz, el gamma y el sepia de tu PDF.
---
# Ajustar colores
Un conjunto completo de herramientas de corrección de color para PDF. Ajusta ocho parámetros independientes (brillo, contraste, saturación, cambio de tono, temperatura, matiz, gamma y sepia) con una vista previa en vivo que se actualiza a medida que mueves cada control deslizante.
## Cómo funciona
1. Sube tu archivo PDF.
2. Se abre el editor con una vista previa de la primera página y un panel de ajustes de color.
3. Mueve los controles deslizantes para ajustar cada parámetro de color. La vista previa se actualiza en tiempo real.
4. Haz clic en **Restablecer** para devolver todos los controles a sus posiciones por defecto.
5. Haz clic en **Aplicar** para procesar todas las páginas y descargar el PDF ajustado.
## Opciones
- **Brillo**: aclara u oscurece toda la página (de -100 a +100).
- **Contraste**: aumenta o reduce la diferencia entre las zonas claras y oscuras (de -100 a +100).
- **Saturación**: aumenta o reduce la intensidad del color (de -100 a +100). Si lo pones en -100, el resultado es en escala de grises.
- **Cambio de tono**: gira la rueda de color para desplazar todos los colores de manera uniforme.
- **Temperatura**: desplaza los colores hacia tonos más cálidos (amarillo/naranja) o más fríos (azul).
- **Matiz**: añade una dominante verde o magenta.
- **Gamma**: ajusta el brillo de los medios tonos mediante una curva gamma. Los valores inferiores a 1.0 oscurecen los medios tonos; los valores superiores a 1.0 los aclaran.
- **Sepia**: aplica un efecto de tono sepia clásico. Los valores más altos producen un tinte marrón más fuerte.
## Características
- Ocho parámetros de color ajustables de forma independiente
- Vista previa en vivo que responde de inmediato a los cambios en los controles deslizantes
- Botón de restablecer para volver rápidamente a los valores por defecto
- Procesa todas las páginas del documento
- Funciona con cualquier contenido del PDF (texto, imágenes, gráficos)
## Casos de uso
- Aclarar un escaneo oscuro o corregir páginas sobreexpuestas
- Reducir la saturación de un documento colorido para gastar menos tinta antes de imprimir
- Aplicar un tono sepia para dar un aspecto antiguo a certificados o diplomas
- Corregir la temperatura de color de fotos incrustadas en un PDF
- Aumentar el contraste en documentos escaneados desvaídos o de baja calidad
## Consejos
- Para una conversión rápida a escala de grises, arrastra el control de saturación hasta -100.
- El control de gamma es especialmente útil para mejorar la legibilidad de documentos escaneados cuyos medios tonos son demasiado oscuros o demasiado claros.
- Como las demás herramientas de efectos de imagen, esta rasteriza cada página. El resultado estará basado en imágenes, por lo que el texto no se podrá seleccionar.
## Herramientas relacionadas
- [Invertir Colores](./invert-colors)
- [Efecto escáner](./scanner-effect)
- [Color de Fondo](./background-color)
docs/es/tools/alternate-merge.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Alternar y mezclar páginas
description: Fusiona PDF intercalando las páginas de cada archivo en orden alterno, conservando los marcadores.
---
# Alternar y mezclar páginas
Intercala las páginas de varios archivos PDF para que las páginas se alternen entre documentos. Es la herramienta a la que recurres cuando una fusión normal solo añadiría los archivos uno detrás de otro, pero necesitas la página 1 del Archivo A, luego la página 1 del Archivo B, luego la página 2 del Archivo A, y así sucesivamente.
## Cómo funciona
1. Sube al menos dos archivos PDF usando la zona de carga.
2. La herramienta muestra cada archivo con su número de páginas y tamaño.
3. Arrastra los tiradores para reordenar las páginas de qué archivo van primero en la secuencia de intercalado.
4. Haz clic en **Mezclar páginas** para generar el resultado intercalado.
5. El resultado se descarga como `alternated-mixed.pdf`.
## Características
- Intercala páginas de cualquier cantidad de PDF (mínimo dos)
- Reordenación de archivos con arrastrar y soltar para controlar la prioridad del intercalado
- Conserva los marcadores de los documentos de origen
- Muestra el número de páginas y el tamaño de cada archivo subido
- Se procesa mediante un web worker dedicado para mantener la interfaz fluida
## Casos de uso
- Reconstruir escaneos a doble cara en los que las páginas impares y pares se escanearon por separado
- Combinar hojas de preguntas con sus claves de respuestas para que cada pregunta vaya seguida de su respuesta
- Fusionar documentos en dos idiomas página por página (por ejemplo, inglés en una cara y la traducción en la siguiente)
- Intercalar los escaneos del anverso y del reverso de un escáner de una sola cara
## Consejos
- Si tus PDF de origen tienen distinto número de páginas, las páginas del documento más corto se acabarán primero y las páginas restantes del documento más largo aparecerán al final.
- El orden de los archivos importa: el primer archivo de la lista aporta la primera página del resultado. Arrastra para reorganizar si es necesario.
## Herramientas relacionadas
- [Fusionar PDF](./merge-pdf)
- [Duplicar y Organizar](./organize-pdf)
- [Dividir PDF](./split-pdf)
docs/es/tools/background-color.md
+45
View File
@@ -0,0 +1,45 @@
---
title: Color de fondo
description: Cambia el color de fondo de todas las páginas de tu PDF conservando todo el contenido por encima.
---
# Color de fondo
Establece un color de fondo sólido detrás de todo el contenido existente de tu PDF. La herramienta crea un rectángulo de color en cada página y coloca el contenido original encima, de modo que el texto, las imágenes y los gráficos siguen siendo totalmente visibles sobre el nuevo fondo.
## Cómo funciona
1. Sube tu archivo PDF.
2. Elige un color de fondo con el selector de color. El valor por defecto es un amarillo claro (#FFFFCC).
3. Haz clic en **Cambiar Color de Fondo** para procesar.
4. El PDF actualizado se descarga automáticamente.
## Opciones
- **Color de Fondo**: un selector de color estándar para elegir cualquier color sólido. Por defecto es amarillo claro.
## Características
- Aplica un color de fondo uniforme a todas las páginas
- Conserva todo el contenido original (texto, imágenes, gráficos vectoriales) sobre la capa de color
- Mantiene las dimensiones originales de la página
- Funciona con documentos de cualquier número de páginas
## Casos de uso
- Añadir un fondo crema o marfil claro para dar a los documentos un aspecto más suave, parecido al papel
- Clasificar por colores conjuntos de documentos aplicando distintos colores de fondo a distintas categorías
- Crear versiones visualmente distintas del mismo documento para diferentes públicos
- Añadir un tinte de fondo claro para mejorar la legibilidad al proyectar documentos en pantalla
## Consejos
- Los colores claros y suaves funcionan mejor. Un fondo muy oscuro puede dificultar la lectura del texto, a menos que este ya sea de color claro.
- Si quieres cambiar tanto el color de fondo como el del texto, aplica primero el color de fondo y luego usa [Cambiar Color de Texto](./text-color) sobre el resultado.
- Esta herramienta trabaja a nivel estructural del PDF (sin rasterizar), por lo que el texto sigue siendo seleccionable y se puede buscar en el resultado.
## Herramientas relacionadas
- [Cambiar Color de Texto](./text-color)
- [Invertir Colores](./invert-colors)
- [Ajustar colores](./adjust-colors)
docs/es/tools/bates-numbering.md
+62
View File
@@ -0,0 +1,62 @@
---
title: Numeración Bates
description: Aplica números Bates a uno o varios PDF con plantillas, relleno, fuentes y posicionamiento personalizables.
---
# Numeración Bates
La numeración Bates estampa identificadores secuenciales en cada página de tus PDF. Es el método estándar para etiquetar documentos en procedimientos legales, auditorías y flujos de cumplimiento normativo. Esta herramienta admite varios archivos y plantillas personalizables, y genera PDF numerados individualmente o un único archivo ZIP.
## Cómo funciona
1. Sube uno o varios archivos PDF. Puedes arrastrar varios archivos a la vez.
2. Elige un estilo predefinido o crea una plantilla personalizada.
3. Configura la posición, la fuente, el tamaño, el color y los números iniciales.
4. Haz clic en **Aplicar números Bates** para procesar.
5. Un solo archivo se descarga directamente. Varios archivos se descargan como un archivo ZIP.
## Opciones
- **Estilo predefinido**: elige entre los formatos integrados:
- Exhibit + Case + Bates + Page (p. ej., "Exhibit 1 Case XYZ 000001 Page 1")
- Exhibit + Case + Bates (sin número de página)
- Case + Bates
- Solo número Bates (p. ej., "000001")
- Personalizado (escribe tu propia plantilla)
- **Personalizar estilo**: una cadena de plantilla con marcadores: `[BATES]`, `[PAGE]`, `[FILE]`, `[FILENAME]`.
- **Relleno Bates**: número de dígitos (de 3 a 6) para los números Bates rellenados con ceros. Solo visible en modo personalizado.
- **Posición**: encabezado o pie de página, a la izquierda, al centro o a la derecha.
- **Los Bates empiezan en**: el primer número Bates. Por defecto es 1. La numeración continúa entre archivos.
- **El contador de archivos empieza en**: el número inicial para el marcador `[FILE]`.
- **Fuente**: Helvetica, Times New Roman o Courier.
- **Tamaño de fuente**: tamaño del texto estampado.
- **Color**: selector de color para el texto del número Bates.
## Características
- Vista previa en vivo que muestra cómo aparecerán los números Bates en todos los archivos subidos
- Compatibilidad con varios archivos con numeración continua entre documentos
- Reordenación de archivos con arrastrar y soltar para controlar la secuencia de numeración
- Seis opciones de posición (encabezado/pie, izquierda/centro/derecha)
- Cálculo adaptativo de márgenes que respeta los distintos tamaños de página
- Salida en ZIP para lotes de varios archivos
- Marcadores de plantilla para la máxima flexibilidad
## Casos de uso
- Estampar documentos de descubrimiento probatorio en litigios con números de exhibit secuenciales
- Numerar paquetes de evidencia de auditoría que abarcan docenas de archivos
- Aplicar números de referencia regulatorios a la documentación de cumplimiento
- Etiquetar los anexos de una solicitud de patente con identificadores específicos del caso
## Consejos
- Arrastra los archivos en la lista para reordenarlos antes de procesar. La secuencia de numeración Bates sigue este orden.
- Usa el marcador `[FILENAME]` para incluir el nombre del archivo original en el sello, lo que ayuda a rastrear las páginas hasta los documentos de origen.
- El cuadro de vista previa se actualiza en tiempo real al cambiar los ajustes, así que puedes verificar el formato antes de procesar.
## Herramientas relacionadas
- [Números de Página](./page-numbers)
- [Agregar etiquetas de página](./add-page-labels)
- [Encabezado y Pie de Página](./header-footer)
docs/es/tools/bmp-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: BMP a PDF
description: Convierte imágenes de mapa de bits BMP a formato PDF directamente en tu navegador, sin subir nada a ningún servidor.
---
# BMP a PDF
Convierte archivos Windows Bitmap (BMP) a PDF. BMP es un formato de imagen sin comprimir que aún se encuentra en sistemas heredados, imagen médica y escáneres industriales. Esta herramienta los convierte a PDF sin necesidad de instalar nada.
## Formatos compatibles
| Formato | Extensiones |
| :------ | :---------- |
| BMP | `.bmp` |
## Cómo funciona
1. Haz clic en la zona de carga o arrastra y suelta tus archivos BMP.
2. Revisa la lista de archivos. Añade más archivos o quita los que no quieras.
3. Haz clic en **Convertir a PDF**. El resultado se descarga como `from_bmps.pdf`.
Cada BMP se dibuja en un canvas, se exporta como PNG y luego se incrusta en el PDF con pdf-lib. El tamaño de la página coincide con las dimensiones originales de la imagen.
## Opciones
Esta herramienta no ofrece ajustes de calidad adicionales. Las imágenes se incrustan en su resolución original como PNG sin pérdida dentro del PDF.
## Casos de uso
- Convertir documentos escaneados antiguos guardados como BMP en PDF de archivo
- Convertir capturas de pantalla BMP de aplicaciones antiguas de Windows en documentos fáciles de compartir
- Procesar la salida de escáneres médicos o industriales que usan BMP por defecto
- Migrar archivos de imágenes antiguos a un formato más portátil
## Consejos
- Los archivos BMP no están comprimidos, por lo que suelen ser grandes. El PDF resultante será bastante más pequeño porque las imágenes se recodifican internamente como PNG.
- Si tienes archivos BMP junto con otros formatos de imagen, usa la herramienta [Imágenes a PDF](./image-to-pdf) para convertir todo en un solo lote.
## Herramientas relacionadas
- [Imágenes a PDF](./image-to-pdf)
- [PNG a PDF](./png-to-pdf)
- [TIFF a PDF](./tiff-to-pdf)
docs/es/tools/bookmark.md
+57
View File
@@ -0,0 +1,57 @@
---
title: Editar marcadores
description: Agrega, edita, importa, exporta y elimina marcadores de PDF con un editor visual y compatibilidad con CSV/JSON.
---
# Editar marcadores
El editor de marcadores te da control total sobre los marcadores de navegación del PDF (también llamados esquemas). Puedes agregar marcadores nuevos, editar los existentes, reorganizar la jerarquía e importar o exportar los datos de los marcadores en formatos CSV y JSON.
## Cómo Funciona
1. Sube tu PDF haciendo clic o arrastrando un archivo a la zona de carga.
2. Opcionalmente, marca **Extraer automáticamente marcadores existentes** para traer el árbol de marcadores actual del documento.
3. El editor se abre con una vista dividida: visor de PDF a la izquierda y panel de marcadores a la derecha.
4. Escribe el título de un marcador y haz clic en **Añadir a la página** para crear un marcador que apunte a la página actual.
5. Usa los botones de la barra de herramientas para reorganizar, dar estilo o eliminar marcadores.
6. Haz clic en **Guardar PDF con marcadores** para descargar el archivo actualizado.
## Características
- Visor de PDF visual con navegación de páginas, controles de zoom y campo para ir a una página
- Agrega marcadores a cualquier página con un solo clic
- Haz clic directamente en el PDF para fijar un destino de marcador preciso (modo de selección)
- Jerarquía de marcadores anidados con reordenación mediante arrastrar y soltar
- Operaciones por lotes: selecciona varios marcadores para cambiar el color, el estilo o eliminarlos a la vez
- Búsqueda de marcadores para encontrar entradas rápidamente en árboles grandes
- Deshacer y rehacer para todos los cambios
- Importa marcadores desde archivos CSV (título, página, nivel) o JSON
- Exporta marcadores a CSV o JSON para editarlos externamente
- Estilo de marcadores: color (rojo, azul, verde, amarillo, morado) y estilo de fuente (negrita, cursiva, negrita cursiva)
- Navegación rápida: recorre las páginas con las teclas Re Pág y Av Pág
## Opciones
- **Extraer automáticamente marcadores existentes**: al activarla, la herramienta lee y muestra los marcadores actuales del PDF al cargarlo.
- **Modo por lotes**: actívalo para seleccionar varios marcadores y aplicar cambios masivos de color, estilo o eliminación.
- **Expandir todo / Contraer todo**: muestra u oculta rápidamente los marcadores secundarios anidados.
## Casos de Uso
- Agregar una tabla de contenidos a un libro de texto o manual que no tiene marcadores
- Reestructurar los marcadores de un documento escaneado después del procesamiento OCR
- Exportar marcadores a CSV, editarlos en una hoja de cálculo y volver a importarlos
- Limpiar marcadores generados automáticamente que tienen referencias de página incorrectas
- Agregar marcadores de colores para señalar secciones importantes en un escrito jurídico
## Consejos
- Usa la importación CSV para crear marcadores en masa. El formato es simple: `title,page,level`, donde el nivel 1 es el nivel superior.
- El modo de selección te permite hacer clic en un punto exacto de la página del PDF para fijar el destino del marcador, lo cual es más preciso que apuntar solo a un número de página.
- Exporta tus marcadores antes de hacer cambios importantes para tener una copia de seguridad.
## Herramientas Relacionadas
- [Tabla de Contenidos](./table-of-contents)
- [Editor PDF](./edit-pdf)
- [Agregar etiquetas de página](./add-page-labels)
docs/es/tools/cbz-to-pdf.md
+47
View File
@@ -0,0 +1,47 @@
---
title: CBZ a PDF
description: Convierte archivos de cómics CBZ y CBR a PDF en tu navegador. Gratis, privado, sin subir archivos.
---
# CBZ a PDF
Convierte archivos de cómics en PDF. CBZ y CBR son los formatos estándar de los cómics digitales: son simplemente archivos ZIP o RAR llenos de imágenes. Esta herramienta extrae cada página, conserva el orden de lectura y produce un PDF limpio donde cada imagen se convierte en una página a tamaño completo.
## Formatos Compatibles
| Formato | Extensión | Notas |
| :------ | :-------- | :------------------------------------------------------------------- |
| CBZ | `.cbz` | Archivo de cómic basado en ZIP (procesado localmente con pdf-lib) |
| CBR | `.cbr` | Archivo de cómic basado en RAR (procesado mediante el motor PyMuPDF) |
El conversor de CBZ reconoce imágenes JPEG, PNG, GIF, BMP, WebP, AVIF, TIFF, HEIC y JXL dentro del archivo. Los formatos no estándar se convierten automáticamente a PNG antes de incrustarse.
## Cómo Funciona
1. Haz clic en el área de carga o arrastra y suelta tus archivos CBZ o CBR. Puedes mezclar ambos formatos en un mismo lote.
2. Revisa los archivos listados. Quita los que no necesites o haz clic en **Agregar Más Archivos** para agregar más.
3. Haz clic en **Convertir a PDF**. Con los archivos CBZ, la herramienta descomprime el archivo, ordena las imágenes por nombre en orden natural, detecta el formato real de cada imagen y las incrusta en un PDF con pdf-lib. Los archivos CBR se procesan con el motor PyMuPDF.
4. Un solo archivo se descarga como PDF. Varios archivos producen un ZIP llamado `comic-converted.zip`.
## Opciones
No se requiere configuración. Cada imagen se convierte en una página del mismo tamaño que sus dimensiones originales, así que las páginas dobles siguen siendo anchas y las páginas sencillas siguen siendo estrechas.
## Casos de Uso
- Leer cómics en una tableta o una app de teléfono que admite PDF pero no CBZ/CBR
- Imprimir páginas específicas de un cómic digital
- Archivar una colección de cómics en un formato que cualquier visor de archivos pueda abrir
- Compartir un cómic con alguien que no tiene un lector de cómics dedicado
## Consejos
- Las imágenes dentro del archivo se ordenan con orden natural (así `page2.jpg` va antes que `page10.jpg`). Nombra tus archivos con una numeración consistente para obtener la secuencia de páginas correcta.
- El conversor detecta los formatos de imagen por sus firmas binarias, no por las extensiones. Un PNG nombrado por error `.jpg` se incrustará correctamente.
- Los archivos CBZ se procesan por completo en el navegador sin cargar el motor PyMuPDF, por lo que se convierten más rápido que los CBR.
## Herramientas Relacionadas
- [EPUB a PDF](./epub-to-pdf)
- [MOBI a PDF](./mobi-to-pdf)
- [Imágenes a PDF](./image-to-pdf)
docs/es/tools/change-permissions.md
+61
View File
@@ -0,0 +1,61 @@
---
title: Cambiar permisos
description: Establece o modifica los permisos de uso de un PDF para imprimir, copiar, editar y anotar. Usa cifrado AES de 256 bits.
---
# Cambiar permisos
Ajusta con precisión lo que los destinatarios pueden hacer con tu PDF. A diferencia del cifrado básico, que solo bloquea el archivo con una contraseña, esta herramienta te permite permitir o denegar de forma selectiva la impresión, la copia, la edición, las anotaciones, el llenado de formularios, el ensamblaje de documentos y la extracción de páginas, todo aplicado mediante cifrado AES de 256 bits.
## Cómo Funciona
1. Sube un archivo PDF.
2. Si el PDF ya está cifrado, ingresa la **Contraseña actual**.
3. Establece una **Nueva contraseña de usuario** (necesaria para abrir) y/o una **Nueva contraseña de propietario** (controla los permisos).
4. Activa o desactiva cada permiso con las casillas.
5. Haz clic en **Cambiar permisos**.
6. Descarga el PDF actualizado.
Si dejas vacíos ambos campos de contraseña nueva, la herramienta descifra el PDF por completo y elimina todo el cifrado y las restricciones.
## Controles de Permisos
| Permiso | Qué Controla |
| ----------------------------------- | ------------------------------------------------------------ |
| **Permitir imprimir** | Si el documento se puede imprimir |
| **Permitir copiar texto** | Si se puede seleccionar y copiar texto e imágenes |
| **Permitir modificar** | Si se puede editar el contenido del documento |
| **Permitir anotar** | Si se pueden agregar comentarios, resaltados y sellos |
| **Permitir rellenar formularios** | Si se pueden completar los campos de formulario interactivos |
| **Permitir ensamblar el documento** | Si se pueden insertar, eliminar o rotar páginas |
| **Permitir extraer páginas** | Si se pueden extraer páginas individuales |
Todos los permisos requieren una contraseña de propietario para aplicarse. Sin contraseña de propietario, la mayoría de los lectores de PDF ignoran las marcas de permisos.
## Cómo Funcionan los Permisos en PDF
Los permisos del PDF forman parte de la especificación de cifrado. Se almacenan como indicadores de bits en el diccionario de cifrado y los aplican los lectores de PDF compatibles. La diferencia clave:
- **Contraseña de usuario**: necesaria para abrir el archivo.
- **Contraseña de propietario**: necesaria para cambiar los permisos o quitar las restricciones. Sin ella, las marcas de permisos controlan qué operaciones puede realizar el usuario.
Si estableces solo una contraseña de propietario (sin contraseña de usuario), cualquiera puede abrir el archivo, pero queda limitado a las operaciones permitidas. Si estableces ambas, el archivo requiere una contraseña para abrirse y queda restringido después de la autenticación.
## Casos de Uso
- Distribuir un informe que se pueda ver e imprimir, pero no editar ni copiar
- Compartir una plantilla de contrato que los destinatarios puedan llenar pero no modificar
- Publicar un catálogo en PDF con la copia de imágenes deshabilitada
- Permitir anotaciones en un borrador de revisión e impedir cambios estructurales
## Consejos
- Para que sea efectivo, establece siempre una contraseña de propietario. Los permisos sin contraseña de propietario no se pueden hacer cumplir.
- Algunas herramientas de PDF de terceros ignoran las marcas de permisos. Para una protección más sólida, considera rasterizar el PDF o usar DRM.
- Usa esta herramienta para actualizar PDFs antiguos cifrados con RC4 a AES-256.
## Herramientas Relacionadas
- [Cifrar PDF](./protect-pdf): protección simple con contraseña, sin permisos granulares
- [Descifrar PDF](./unlock-pdf): elimina el cifrado por completo
- [Eliminar Restricciones](./remove-restrictions): quita todas las restricciones cuando tienes la contraseña de propietario
docs/es/tools/combine-single-page.md
+55
View File
@@ -0,0 +1,55 @@
---
title: Combinar en una sola página
description: Une todas las páginas de un PDF en un solo desplazamiento continuo, vertical u horizontal.
---
# Combinar en una sola página
Fusiona todas las páginas de un PDF en una única página larga. Las páginas se unen verticalmente (como un pergamino) u horizontalmente (una al lado de otra), y el resultado es una página continua.
## Cómo Funciona
1. Sube un archivo PDF.
2. Selecciona la dirección del diseño: **Vertical** (páginas apiladas de arriba abajo) u **Horizontal** (páginas colocadas una al lado de otra).
3. Define el espacio entre páginas en puntos.
4. Elige un color de fondo para los espacios entre páginas.
5. Opcionalmente, activa los separadores (líneas finas entre páginas) y configura su grosor y color.
6. Haz clic en el botón de procesar. El resultado es un PDF de una sola página.
## Características
- Unión de páginas vertical u horizontal
- Espaciado configurable entre páginas
- Selector de color de fondo para las áreas de separación
- Líneas separadoras opcionales con grosor y color ajustables
- Renderiza cada página original a resolución completa sobre el lienzo combinado
## Opciones
| Opción | Descripción |
| ----------------------------- | ------------------------------------------------------ |
| **Dirección del diseño** | Vertical (apiladas) u Horizontal (una al lado de otra) |
| **Espaciado** | Espacio entre páginas en puntos |
| **Color de fondo** | Color del área entre páginas |
| **Añadir líneas separadoras** | Activa líneas finas entre páginas |
| **Grosor del separador** | Grosor de la línea en puntos |
| **Color del separador** | Color de las líneas separadoras |
## Casos de Uso
- Crear una sola imagen larga a partir de un wireframe o maqueta de diseño de varias páginas
- Generar una vista continua con desplazamiento de un documento para incrustarlo en la web
- Unir un cómic o storyboard de varias páginas en una sola tira
- Producir una vista panorámica de páginas secuenciales para su revisión
## Consejos
- La orientación vertical funciona mejor con documentos de páginas verticales. La horizontal es mejor para contenido apaisado.
- Los documentos grandes con muchas páginas producirán un resultado muy alto o muy ancho. Algunos visores de PDF pueden tener dificultades con páginas únicas extremadamente grandes.
- Agregar separadores con un color contrastante facilita ver dónde termina una página original y empieza la siguiente.
## Herramientas Relacionadas
- [N-Up PDF](./n-up-pdf)
- [Fusionar PDF](./merge-pdf)
- [Dividir Páginas](./divide-pages)
docs/es/tools/compare-pdfs.md
+60
View File
@@ -0,0 +1,60 @@
---
title: Comparar PDFs
description: Compara dos documentos PDF lado a lado o en modo superposición, con detección y categorización detallada de cambios.
---
# Comparar PDFs
Sube dos PDFs y ve exactamente qué cambió entre ellos. La herramienta empareja las páginas de forma inteligente, detecta diferencias en texto, imágenes, anotaciones, encabezados y formato, y las presenta en una vista lado a lado o superpuesta.
## Cómo Funciona
1. Sube dos archivos PDF: el original (izquierda) y la versión revisada (derecha).
2. La herramienta empareja las páginas de ambos documentos usando firmas de contenido.
3. Selecciona un modo de vista: **Lado a lado** u **Superponer**.
4. Navega entre los pares de páginas con los controles de paginación.
5. Las diferencias se resaltan y se categorizan. Usa el panel de filtros para centrarte en tipos de cambio específicos.
6. Opcionalmente, exporta la comparación como informe en PDF.
## Características
- Emparejamiento automático de páginas según la similitud del contenido
- Vistas de comparación lado a lado y superpuesta
- Categorización de cambios: texto, imagen, encabezado/pie de página, anotación, formato, fondo
- Filtros por categoría para mostrar u ocultar tipos de cambio específicos
- Búsqueda de cambios de texto con filtrado por consulta
- Compatibilidad con OCR para comparar documentos escaneados
- Controles de zoom para una inspección detallada
- Desplazamiento sincronizado entre paneles en la vista lado a lado
- Exporta los resultados de la comparación como PDF
## Opciones
| Opción | Descripción |
| -------------------------- | ------------------------------------------------------------------------------------------------------------ |
| **Modo de vista** | Lado a lado o Superponer |
| **OCR** | Activa o desactiva el OCR para comparar documentos escaneados |
| **Idioma del OCR** | Idioma para la extracción de texto con OCR |
| **Filtros de categoría** | Alterna la visibilidad de los cambios de texto, imagen, encabezado/pie de página, anotación, formato y fondo |
| **Alcance de los cambios** | En el modo superposición, filtra entre todos los cambios o solo el contenido |
| **Zoom** | Ajusta el nivel de aumento para una inspección detallada |
## Casos de Uso
- Revisar las revisiones de un contrato para encontrar exactamente qué cambió entre versiones
- Comparar maquetas de diseño para verificar que las exportaciones a PDF coincidan con lo esperado
- Auditar cambios en documentos en industrias reguladas donde cada edición debe registrarse
- Verificar que un proceso de conversión de PDF conservó con exactitud el contenido original
- Revisar documentos traducidos frente al original para detectar cambios de diseño
## Consejos
- La vista superpuesta apila ambos documentos uno sobre otro, haciendo visibles al instante las diferencias espaciales (elementos desplazados, imágenes redimensionadas).
- Activa el OCR al comparar documentos escaneados que no tienen capa de texto. El motor de comparación extraerá el texto de las imágenes de las páginas.
- Usa los filtros por categoría para centrarte en lo importante. Por ejemplo, oculta los cambios de formato cuando solo te interesan las diferencias de contenido de texto.
## Herramientas Relacionadas
- [Ver Metadatos](./view-metadata)
- [OCR PDF](./ocr-pdf)
- [Fusionar PDF](./merge-pdf)
docs/es/tools/compress-pdf.md
+73
View File
@@ -0,0 +1,73 @@
---
title: Comprimir PDF
description: Reduce el tamaño de un PDF hasta un 90% con el motor Hyper Compress. Admite tamaños de archivo objetivo, procesamiento por lotes y ajustes de calidad personalizados.
---
# Comprimir PDF
Reduce el tamaño de tus archivos PDF sin destruirlos. Comprimir PDF funciona con [Hyper Compress](https://www.bentopdf.com/hyper-compress), el motor de compresión propio de BentoPDF. Recomprime imágenes, crea subconjuntos de fuentes y las fusiona, y elimina el peso muerto, como las miniaturas incrustadas y los datos privados de aplicaciones. El PDF sigue siendo totalmente funcional: el texto se puede seleccionar y los enlaces y campos de formulario siguen funcionando.
Hyper Compress está compilado a WebAssembly y se incluye con BentoPDF, así que la compresión funciona sin conexión y en despliegues aislados de la red, sin configuración adicional.
## Cómo Funciona
1. Sube uno o más PDFs haciendo clic en la zona de carga o arrastrando los archivos.
2. Elige un **Nivel de compresión**: Bajo, Medio, Alto o Sin pérdidas.
3. Opcionalmente, ingresa un **Tamaño de archivo objetivo**, o expande **Ajustes personalizados** para un control más fino, incluido **Convertir a escala de grises**.
4. Haz clic en **Comprimir PDF**. Con varios archivos, obtienes una sola descarga en ZIP.
## Documentos Especiales
- **Los PDFs firmados digitalmente** se devuelven sin cambios, porque cualquier modificación invalidaría la firma. Activa **Anular la protección del contenido** en Ajustes personalizados para quitar las firmas y comprimirlos; la firma visible permanece en la página, pero el archivo deja de estar firmado.
- **Los archivos PDF/A** pierden su etiqueta PDF/A tras la compresión, para que el archivo nunca declare una conformidad que ya no cumple. Activa **Conservar PDF/A** en Ajustes personalizados para mantener la conformidad del archivo.
- **Los PDFs protegidos con contraseña** muestran un campo de contraseña en su tarjeta de archivo. Ingresa la contraseña allí y Hyper Compress abre el archivo por sí mismo, sin un paso de desbloqueo aparte. Con dos o más archivos bloqueados, un campo compartido desbloquea todos los archivos que usan la misma contraseña. La copia comprimida no tiene contraseña; usa [Proteger PDF](./protect-pdf) para agregarla de nuevo.
- **Los escaneos sin capa de texto** pueden reducirse aún más con **Rasteriza las páginas a imágenes** en Ajustes personalizados, que reemplaza cada página por una imagen optimizada. Se omite en cualquier documento con texto seleccionable, incluidos los escaneos con OCR, a menos que **Anular la protección del contenido** esté activado. En ese caso, las páginas de texto también se convierten en imágenes, por lo que el texto deja de ser seleccionable y los enlaces dejan de funcionar.
## Niveles de Compresión
| Nivel | Calidad de Imagen | Resolución Máxima | Ideal Para |
| ---------------- | ----------------- | ----------------- | ------------------------------ |
| **Bajo** | 80 | 200 DPI | Conservar la calidad visual |
| **Medio** | 50 | 150 DPI | Documentos de uso diario |
| **Alto** | 20 | 72 DPI | Adjuntos de correo, cargas web |
| **Sin pérdidas** | Imágenes intactas | Sin cambios | Copias de archivo |
Alto también quita la incrustación de las 14 fuentes estándar de PDF, además de fuentes similares como Arial cuando es seguro hacerlo.
## Tamaño de Archivo Objetivo
Ingresa un tamaño en KB o MB y Hyper Compress busca la mejor calidad de imagen que aún quepa, partiendo del nivel que elegiste. Si el documento no puede llegar a ese tamaño, obtienes la versión más pequeña posible y un mensaje que lo indica. Las páginas dedicadas, como [Comprimir PDF a 1MB](https://www.bentopdf.com/compress-pdf-to-1mb), se abren con el objetivo ya rellenado.
## Ajustes Personalizados
Expande el panel Ajustes personalizados para ajustar Hyper Compress directamente. Al elegir un nivel de compresión, estos valores se restablecen a los de ese nivel, y al editar cualquiera de ellos el nivel cambia a Personalizado.
- **Anular la protección del contenido**: por defecto, Hyper Compress deja intactos los PDFs firmados y no rasteriza páginas que tienen texto. Al activarlo se omiten ambas protecciones. Se mantiene activado cuando cambias el nivel.
- **Imágenes**: calidad de imagen, resolución máxima, remuestreo forzado, reducción de color, recorte de áreas de imagen invisibles, eliminación de imágenes alternativas, simplificación de perfiles de color, JPEG 2000 y modo sin pérdida
- **Fuentes**: creación de subconjuntos, fusión de duplicados y eliminación de la incrustación de fuentes estándar y sus similares
- **Contenido**: aplanado de anotaciones, campos de formulario o enlaces
- **Limpieza**: eliminación de miniaturas, datos de aplicaciones, hilos de artículos, información de captura web, el árbol de estructura o los perfiles de salida
- **Rasterizar**: reemplazo de páginas por imágenes, para escaneos solo de imagen; se omite cuando el documento tiene texto seleccionable
- **Salida**: Conservar PDF/A y compresión Brotli para lectores de PDF 2.0 que la admitan
## Casos de Uso
- Reducir un informe de 50 MB para que quepa en el límite de adjuntos de un correo
- Lograr que un escaneo quede por debajo del estricto límite de carga de un portal usando un tamaño de archivo objetivo
- Optimizar PDFs de marketing para descargas más rápidas desde un sitio web
- Archivar grandes conjuntos de documentos cuando el costo de almacenamiento importa
- Reducir el uso de datos móviles al compartir PDFs por aplicaciones de mensajería
## Consejos
- Empieza con Medio. Si el resultado sigue siendo demasiado grande, define un tamaño de archivo objetivo o sube a Alto.
- Para un escaneo sin capa de texto, activa Rasteriza las páginas a imágenes en Ajustes personalizados.
- Convertir a escala de grises, en Ajustes personalizados, puede reducir el tamaño de documentos con mucho color.
## Herramientas Relacionadas
- [Linealizar PDF](./linearize-pdf): optimiza el PDF comprimido para verlo rápido en la web
- [Rasterizar PDF](./rasterize-pdf): convierte páginas en imágenes con un DPI específico, incluidas las páginas con texto
- [Reparar PDF](./repair-pdf): arregla un PDF que se dañó durante una compresión en otro lugar
- [Eliminar Metadatos](./remove-metadata): quita datos ocultos por privacidad
docs/es/tools/crop-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: Recortar PDF
description: Recorta visualmente las páginas de un PDF dibujando una región de recorte en cada página con un editor basado en Cropper.js.
---
# Recortar PDF
Recorta los márgenes de las páginas de tu PDF con una interfaz visual. Dibuja un rectángulo de recorte directamente sobre cada página, previsualiza el resultado y aplica el recorte. Puedes definir regiones de recorte distintas para diferentes páginas o aplicar el mismo recorte a todo el documento.
## Cómo Funciona
1. Sube tu archivo PDF.
2. Se abre el editor de recorte, que muestra la primera página con una superposición de recorte que se puede arrastrar.
3. Ajusta el rectángulo de recorte arrastrando sus bordes o esquinas.
4. Usa los botones de navegación de páginas para moverte entre ellas y definir la región de recorte de cada una.
5. Haz clic en **Recortar y descargar** para aplicar el recorte y descargar el resultado.
## Características
- Editor de recorte visual basado en Cropper.js, con controladores para un ajuste preciso
- Navegación página por página para definir regiones de recorte individuales
- Guarda los ajustes de recorte por página, para que puedas definir recortes distintos en páginas distintas
- Vista previa en vivo del área de recorte seleccionada
- Admite PDFs de cualquier tamaño u orientación de página
## Casos de Uso
- Quitar márgenes amplios de documentos escaneados para centrarse en el área de contenido
- Eliminar marcas de corte o de registro de impresora de PDFs de preimpresión
- Recortar diapositivas de clase para quitar el área de notas del presentador
- Quitar encabezados o pies de página de todas las páginas antes de compartir un extracto de un documento
- Redimensionar páginas para adaptarlas a una pantalla o un diseño de impresión específico
## Consejos
- La superposición de recorte se puede redimensionar y reposicionar libremente. Arrastra las esquinas para un cambio de tamaño proporcional o los bordes para un ajuste en un solo eje.
- Si todas las páginas necesitan el mismo recorte, defínelo en la primera página: la herramienta recuerda tu región de recorte mientras navegas por las páginas.
- Si necesitas estandarizar los tamaños de página en lugar de recortar visualmente, la herramienta Fijar Tamaño de Página puede ser más adecuada.
## Herramientas Relacionadas
- [Editor PDF](./edit-pdf)
- [Números de Página](./page-numbers)
- [Eliminar Páginas en Blanco](./remove-blank-pages)
docs/es/tools/csv-to-pdf.md
+51
View File
@@ -0,0 +1,51 @@
---
title: CSV a PDF
description: Convierte hojas de cálculo CSV en tablas PDF con formato directamente en tu navegador.
---
# CSV a PDF
Convierte archivos CSV en documentos PDF limpios y con formato. Cada CSV se analiza y se muestra como una tabla en el PDF resultante. Es útil cuando necesitas imprimir o compartir datos tabulares sin que el destinatario tenga un programa de hojas de cálculo.
## Formatos Compatibles
| Formato | Extensiones |
| :------ | :---------- |
| CSV | `.csv` |
## Cómo Funciona
1. Haz clic en el área de carga o arrastra y suelta uno o más archivos CSV.
2. Revisa la lista de archivos. Agrega más archivos o quita los que no quieras.
3. Haz clic en **Convertir a PDF**. Un indicador de progreso muestra el estado de la conversión.
4. Un solo archivo se descarga directamente como PDF. Varios archivos se empaquetan en `csv-converted.zip`.
## Opciones
Esta herramienta no tiene configuración adicional. El CSV se analiza y se formatea automáticamente como una tabla.
## Resultado
| Cantidad de Entradas | Resultado |
| :------------------- | :------------------------------------------------------------ |
| 1 archivo | Descarga de un solo PDF (p. ej., `data.pdf`) |
| 2+ archivos | Archivo ZIP (`csv-converted.zip`) con un PDF por cada archivo |
## Casos de Uso
- Convertir informes exportados de bases de datos en tablas PDF imprimibles
- Compartir datos financieros o listas de inventario con personas que no tienen Excel
- Crear versiones en PDF de archivos de registro CSV para documentación de cumplimiento
- Imprimir listas de direcciones, hojas de calificaciones o cualquier dato tabular guardado como CSV
## Consejos
- Para obtener los mejores resultados, asegúrate de que tu CSV use delimitadores de coma estándar. La herramienta sigue las convenciones comunes de análisis de CSV.
- Si tu CSV tiene muchas columnas, la tabla puede comprimirse para ajustarse al ancho de la página. Considera dividir los conjuntos de datos anchos en varios archivos.
- Para archivos de Excel (`.xls`, `.xlsx`), usa la herramienta [Excel a PDF](./excel-to-pdf), que conserva el formato de la hoja de cálculo y las múltiples hojas.
## Herramientas Relacionadas
- [Excel a PDF](./excel-to-pdf)
- [Texto a PDF](./txt-to-pdf)
- [JSON a PDF](./json-to-pdf)
docs/es/tools/delete-pages.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Eliminar páginas
description: Quita páginas específicas de un PDF por número de página, rango o selección visual de miniaturas.
---
# Eliminar páginas
Quita las páginas que no quieres de un documento PDF. Indica las páginas a eliminar escribiendo números de página o rangos, o haz clic directamente en las miniaturas para marcarlas.
## Cómo Funciona
1. Sube un archivo PDF. La herramienta genera vistas previas en miniatura de cada página.
2. Ingresa las páginas a eliminar en el campo de texto con la sintaxis de rangos (p. ej., `2, 5-8`), o haz clic en las miniaturas para alternarlas.
3. Las páginas marcadas se resaltan visualmente para que confirmes tu selección.
4. Haz clic en el botón de procesar. Se crea un nuevo PDF sin las páginas seleccionadas.
## Características
- Selección de páginas por texto con sintaxis de rangos (`2, 5-8, 12`)
- Cuadrícula visual de miniaturas para eliminar con un clic
- Resaltado en tiempo real de las páginas marcadas para eliminar
- Validación de la entrada según el número real de páginas
- Conserva todas las páginas no eliminadas en su orden original
## Casos de Uso
- Eliminar páginas en blanco o de relleno de un documento escaneado
- Eliminar portadas o apéndices antes de compartir un documento
- Limpiar páginas de borrador que quedaron por accidente en un PDF final
- Quitar páginas con información sensible antes de distribuir
## Consejos
- Eliminar páginas no afecta el contenido ni el formato de las páginas restantes. El resultado es una copia fiel del original sin las páginas eliminadas.
- Si quieres conservar solo ciertas páginas en lugar de quitar otras específicas, [Extraer Páginas](./extract-pages) es la mejor opción.
- La vista de miniaturas se carga de forma diferida, por lo que los documentos grandes siguen respondiendo con fluidez.
## Herramientas Relacionadas
- [Extraer Páginas](./extract-pages)
- [Organizar y Duplicar](./organize-pdf)
- [Dividir PDF](./split-pdf)
docs/es/tools/deskew-pdf.md
+46
View File
@@ -0,0 +1,46 @@
---
title: Enderezar PDF
description: Endereza automáticamente las páginas inclinadas de PDFs escaneados con detección de inclinación de OpenCV. Umbral y DPI ajustables.
---
# Enderezar PDF
Los documentos escaneados rara vez quedan perfectamente rectos. Incluso una ligera inclinación reduce la precisión del OCR y hace que la impresión se vea descuidada. Esta herramienta usa los algoritmos de procesamiento de imágenes de OpenCV para detectar el ángulo de inclinación de cada página y girarla de nuevo hasta dejarla nivelada.
## Cómo Funciona
1. Sube uno o más PDFs escaneados.
2. Define el **Umbral de inclinación**: las páginas con una inclinación detectada por debajo de este valor se dejan intactas.
3. Elige una **Calidad de procesamiento (DPI)**: un DPI mayor mejora la precisión de la detección, pero tarda más.
4. Haz clic en **Enderezar PDF**.
5. Tras el procesamiento, un panel de resultados muestra el ángulo detectado de cada página y si se corrigió.
## Opciones
| Ajuste | Valores | Predeterminado |
| ---------------------------------- | ------------------------- | -------------- |
| **Umbral de inclinación** | 0.1, 0.5, 1.0, 2.0 grados | 0.5 |
| **Calidad de procesamiento (DPI)** | 100, 150, 200, 300 | 150 |
## Cómo Funciona la Detección de Inclinación
La herramienta renderiza cada página como imagen con el DPI seleccionado y luego usa OpenCV para detectar los ángulos dominantes de las líneas del contenido. Si la inclinación detectada supera el umbral, la página se gira en el ángulo inverso para enderezarla. Las páginas por debajo del umbral pasan sin cambios.
## Casos de Uso
- Limpiar contratos o documentos legales escaneados por lotes
- Preparar recibos o facturas escaneados para el procesamiento OCR
- Enderezar páginas de un escáner de cama plana con una colocación del papel irregular
- Mejorar la calidad visual de materiales de archivo digitalizados
## Consejos
- Reduce el umbral a 0.1 grados si necesitas una alineación perfecta para el OCR.
- 150 DPI es rápido y preciso para la mayoría de los documentos. Usa 300 DPI para texto muy pequeño o páginas con detalles finos.
- Enderezar funciona mejor con documentos que tienen líneas de texto horizontales claras. Puede tener dificultades con páginas compuestas sobre todo por imágenes o elementos de diseño diagonales.
## Herramientas Relacionadas
- [Rasterizar PDF](./rasterize-pdf): convierte el resultado enderezado en un PDF plano basado en imágenes
- [Comprimir PDF](./compress-pdf): reduce el tamaño del archivo después de enderezar
- [Reparar PDF](./repair-pdf): arregla problemas estructurales en PDFs escaneados
docs/es/tools/digital-sign-pdf.md
+65
View File
@@ -0,0 +1,65 @@
---
title: Firma Digital
description: Agrega firmas digitales criptográficas a PDFs con certificados X.509. Admite los formatos PKCS#12 y PEM con opciones de firma visible.
---
# Firma Digital
Una firma digital es una prueba criptográfica de que una persona específica firmó un documento y de que este no se ha alterado desde entonces. A diferencia de una firma dibujada (que es solo una imagen), una firma digital usa certificados X.509 y estándares PKCS#7 para ofrecer autenticidad e integridad verificables.
BentoPDF aplica las firmas digitales por completo en tu navegador. Tu clave privada nunca sale de tu dispositivo.
## Cómo Funciona
1. Sube un archivo PDF.
2. Sube tu archivo de certificado (.pfx, .p12 o .pem).
3. Ingresa la contraseña del certificado para desbloquearlo. La herramienta muestra el sujeto, el emisor y el período de validez del certificado.
4. Opcionalmente, configura los metadatos de la firma (motivo, ubicación, información de contacto).
5. Opcionalmente, activa una **firma visible** con personalización de posición, tamaño, imagen y texto.
6. Haz clic en **Firmar PDF**.
## Formatos de Certificado Compatibles
| Formato | Extensiones | Descripción |
| ----------- | ----------- | ----------------------------------------------------------------------------------------------------------------------------- |
| **PKCS#12** | .pfx, .p12 | Paquete estándar de la industria que contiene la clave privada y la cadena de certificados. El formato más común. |
| **PEM** | .pem | Formato basado en texto. Debe contener el certificado y la clave privada en un solo archivo. Admite claves privadas cifradas. |
## Opciones de Firma Visible
Al activarla, se renderiza un bloque de firma visible en la página del PDF:
- **Posición**: coordenadas X/Y y ancho/alto en puntos
- **Página**: primera página, última página, todas las páginas o un número de página específico
- **Imagen**: sube una imagen PNG, JPG o WebP (tu firma manuscrita, el sello de tu empresa, etc.)
- **Texto**: texto personalizado con color y tamaño de fuente configurables. Si no se proporciona imagen ni texto, la herramienta genera automáticamente un texto a partir del nombre común del certificado y la fecha actual.
## Metadatos de la Firma
- **Motivo**: por qué se firmó el documento (p. ej., "Aprobado", "Revisado")
- **Ubicación**: dónde se realizó la firma (p. ej., "Nueva York, NY")
- **Información de contacto**: cómo comunicarse con el firmante (p. ej., una dirección de correo electrónico)
## Nota sobre la Conexión a Internet
Es posible que firmar requiera una conexión a internet. La biblioteca de firma obtiene la cadena de certificados desde las URL incluidas en la extensión Authority Information Access (AIA) de tu certificado. Si esos servidores no están disponibles, la firma fallará con los certificados que requieren validación de la cadena.
## Casos de Uso
- Firmar contratos, propuestas y acuerdos con firmas digitales jurídicamente vinculantes
- Certificar documentos oficiales en flujos de trabajo que requieren autenticación basada en PKI
- Firmar facturas en PDF para cumplir con la normativa (muchos países de la UE exigen facturas electrónicas firmadas digitalmente)
- Agregar la aprobación de una organización a planos de ingeniería o documentos de calidad
## Consejos
- Los certificados autofirmados sirven para pruebas, pero mostrarán advertencias en Adobe Reader. Usa un certificado de una Autoridad de Certificación de confianza para documentos en producción.
- La firma visible es solo visual. La firma criptográfica se incrusta independientemente de que el bloque visible esté activado.
- Verifica tu PDF firmado con la herramienta Validar Firma para confirmar que la firma está intacta.
## Herramientas Relacionadas
- [Validar Firma](./validate-signature-pdf): verifica las firmas digitales de PDFs firmados
- [Aplanar PDF](./flatten-pdf): aplana los formularios antes de firmar para evitar modificaciones
- [Cifrar PDF](./protect-pdf): agrega protección con contraseña sobre la firma digital
- [Eliminar Metadatos](./remove-metadata): quita los metadatos antes de firmar
docs/es/tools/divide-pages.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Dividir páginas
description: Divide las páginas de un PDF horizontal o verticalmente en subpáginas más pequeñas.
---
# Dividir páginas
Corta páginas individuales de un PDF por la mitad, de forma horizontal o vertical. Es útil cuando una sola página contiene contenido que debería separarse en páginas distintas, por ejemplo, un diseño de dos columnas escaneado como una sola página ancha.
## Cómo Funciona
1. Sube un archivo PDF.
2. Selecciona la dirección de la división: **Vertical** (mitades izquierda/derecha) u **Horizontal** (mitades superior/inferior).
3. Opcionalmente, especifica un rango de páginas para limitar cuáles se dividen. Déjalo en blanco para dividir todas las páginas.
4. Haz clic en el botón de procesar para generar el PDF dividido.
## Características
- División vertical: divide cada página en mitades izquierda y derecha
- División horizontal: divide cada página en mitades superior e inferior
- Filtro de rango de páginas para dividir solo páginas específicas
- Las páginas no seleccionadas pasan sin cambios
- Conserva la calidad del contenido sin volver a renderizar
## Casos de Uso
- Separar páginas escaneadas de dos en dos (p. ej., el escaneo de un libro con las páginas izquierda y derecha en una sola hoja)
- Dividir un PDF apaisado con contenido en paralelo en páginas verticales individuales
- Dividir infografías o pósteres altos en secciones superior e inferior separadas
- Preparar documentos de formato ancho para imprimirlos en papel estándar
## Consejos
- Si el contenido de tus páginas no está distribuido de forma uniforme, la división se hace igualmente en el punto medio exacto. Para divisiones asimétricas, considera usar [Recortar PDF](./crop-pdf).
- Combina esta herramienta con [Rotar PDF](./rotate-pdf) si tus páginas necesitan girarse antes o después de dividirlas.
## Herramientas Relacionadas
- [Dividir PDF](./split-pdf)
- [Recortar PDF](./crop-pdf)
- [N-Up PDF](./n-up-pdf)
- [Posterizar PDF](./posterize-pdf)
docs/es/tools/duplex-collate.md
+55
View File
@@ -0,0 +1,55 @@
---
title: Intercalar escaneo a doble cara
description: Reordena PDFs de escaneo a doble cara que contienen las páginas frontales y traseras en bloques separados, para dejarlas en el orden correcto de anverso y reverso.
---
# Intercalar escaneo a doble cara
Intercalar escaneo a doble cara está pensado para flujos de escaneo con alimentador automático (ADF) donde un PDF contiene dos bloques de páginas:
- primero todos los anversos
- después todos los reversos
En lugar de dividir y reensamblar manualmente, esta herramienta intercala los dos bloques en el orden natural de lectura: anverso1, reverso1, anverso2, reverso2, y así sucesivamente.
## Cómo Funciona
1. Sube un único PDF creado al escanear una pila a doble cara.
2. Define el punto de división donde termina el bloque de anversos.
3. Elige cómo tratar el bloque de reversos:
- **Invertir el bloque de reversos** (habitual cuando se voltea la pila antes de escanear los reversos)
- **Mantener el bloque de reversos tal cual**
4. Haz clic en **Intercalar PDF** para descargar el resultado reordenado.
## Opciones
- **Detectar división automáticamente (mitad)**: fija el punto de división en `ceil(totalPages / 2)`.
- **Aviso de páginas impares**: avisa cuando el total de páginas es impar (a menudo indica un desajuste en el escaneo).
- **Confirmación de bloques desiguales**: pide confirmación cuando los bloques de anversos y reversos tienen tamaños distintos.
- **Exportación agrupada**: divide el resultado intercalado en PDFs separados según el número de páginas del documento original y los descarga como ZIP.
## Comportamiento de la Salida
- **Predeterminado**: un PDF de salida (un solo PDF de entrada, un solo PDF de salida).
- **Modo agrupado**: la salida se divide en fragmentos según tu valor de páginas por documento; si se producen varios fragmentos, se descargan en un único ZIP; de lo contrario, se descarga un solo PDF.
Si los bloques tienen tamaños distintos, primero se intercalan las páginas emparejadas y las páginas restantes sin pareja se agregan al final.
## Casos de Uso Comunes
- Restaurar el orden después de escanear una pila de formularios a doble cara en dos pasadas.
- Reconstruir paquetes de anverso y reverso a partir de escáneres de oficina que entregan todos los anversos y luego todos los reversos.
- Posprocesar escaneos de archivo antes de dividirlos en archivos por documento.
## Consejos
- La mayoría de los lotes a doble cara deberían tener un total de páginas par.
- Si los reversos se ven invertidos en el resultado, alterna entre **Invertir el bloque de reversos** y **Mantener el bloque de reversos tal cual**.
- Para originales de 2 páginas (anverso y reverso), usa la exportación agrupada con `2` páginas por documento.
## Herramientas Relacionadas
- [Alternar y Mezclar Páginas](./alternate-merge)
- [Dividir PDF](./split-pdf)
- [Fusionar PDF](./merge-pdf)
- [Organizar y Duplicar](./organize-pdf)
docs/es/tools/edit-attachments.md
+43
View File
@@ -0,0 +1,43 @@
---
title: Editar adjuntos
description: Consulta y elimina de forma selectiva los archivos adjuntos incrustados en un documento PDF.
---
# Editar adjuntos
Inspecciona y administra los archivos adjuntos dentro de un PDF. La herramienta lista cada archivo incrustado con su nombre y su nivel de adjunto, y te permite marcar adjuntos individuales para eliminarlos o quitarlos todos a la vez.
## Cómo Funciona
1. Sube un archivo PDF.
2. La herramienta busca automáticamente los adjuntos y los muestra en una lista.
3. Cada adjunto muestra su nombre de archivo y si es un adjunto a nivel de documento o de página.
4. Haz clic en el icono de la papelera junto a un adjunto para marcarlo para eliminarlo (haz clic de nuevo para desmarcarlo).
5. Usa el botón **Quitar todos los adjuntos** para seleccionar todo a la vez, o **Deseleccionar todo** para borrar tus selecciones.
6. Haz clic en el botón de procesar para guardar un nuevo PDF sin los adjuntos seleccionados.
## Características
- Lista todos los adjuntos a nivel de documento y de página
- Eliminación individual o masiva de adjuntos
- Activa y desactiva la selección antes de confirmar los cambios
- Texto tachado y cambio de opacidad en los elementos marcados para eliminar
- Descarga el PDF modificado sin los adjuntos seleccionados
## Casos de Uso
- Quitar archivos obsoletos o incorrectos incrustados en un documento antes de redistribuirlo
- Eliminar adjuntos sensibles (datos financieros, información personal) de un PDF antes de compartirlo
- Reducir el tamaño de un PDF quitando archivos incrustados grandes que ya no se necesitan
- Auditar el contenido incrustado y limpiar un documento antes de archivarlo
## Consejos
- Los adjuntos marcados para eliminar se muestran tachados. Puedes volver a activarlos antes de procesar si cambias de opinión.
- Si no se encuentran adjuntos, la herramienta muestra un mensaje claro de "No se encontraron adjuntos": el PDF simplemente no contiene archivos incrustados.
## Herramientas Relacionadas
- [Agregar Adjuntos](./add-attachments)
- [Extraer Adjuntos](./extract-attachments)
- [Ver Metadatos](./view-metadata)
docs/es/tools/edit-metadata.md
+58
View File
@@ -0,0 +1,58 @@
---
title: Editar metadatos
description: Consulta y modifica los campos de metadatos de un PDF, como título, autor, palabras clave, fechas y propiedades personalizadas.
---
# Editar metadatos
Edita los metadatos incrustados en un archivo PDF. La herramienta rellena un formulario con los metadatos existentes del documento, te permite modificar cualquier campo y guarda los cambios en un nuevo PDF.
## Cómo Funciona
1. Sube un archivo PDF. La herramienta lee sus metadatos actuales y rellena el formulario.
2. Edita cualquiera de los campos estándar: Título, Autor, Asunto, Palabras clave, Creador, Productor.
3. Ajusta Fecha de creación y Fecha de modificación con los selectores de fecha y hora.
4. Agrega campos de metadatos personalizados haciendo clic en el botón de agregar e ingresando un par clave-valor.
5. Haz clic en el botón de procesar para guardar el PDF modificado.
## Características
- Rellena todos los metadatos existentes del PDF subido
- Campos estándar: Título, Autor, Asunto, Palabras clave, Creador, Productor
- Selectores de fecha y hora para Fecha de creación y Fecha de modificación
- Campos de metadatos personalizados de clave-valor para propiedades arbitrarias
- Guarda los cambios directamente en el diccionario de información del documento PDF
## Campos Editables
| Campo | Descripción |
| ------------------------- | ------------------------------------------------------------- |
| **Título** | El título del documento que se muestra en los lectores de PDF |
| **Autor** | La persona u organización que creó el documento |
| **Asunto** | Una breve descripción del tema del documento |
| **Palabras clave** | Términos separados por comas para búsqueda y categorización |
| **Creador** | La aplicación que creó originalmente el contenido |
| **Productor** | La aplicación que generó el PDF |
| **Fecha de creación** | Cuándo se creó el documento originalmente |
| **Fecha de modificación** | Cuándo se modificó el documento por última vez |
| **Campos personalizados** | Cualquier par clave-valor adicional que definas |
## Casos de Uso
- Establecer un título y un autor adecuados antes de publicar un documento
- Agregar palabras clave para mejorar la capacidad de búsqueda en sistemas de gestión documental
- Actualizar la fecha de modificación para reflejar la revisión actual
- Agregar campos de metadatos personalizados como Departamento, ID de proyecto o Clasificación
- Limpiar los metadatos dejados por el software de creación original
## Consejos
- Los campos personalizados se escriben directamente en el diccionario de información del PDF. Algunos lectores de PDF pueden no mostrar los campos personalizados, pero se conservan en el archivo.
- Deja un campo en blanco para borrarlo de los metadatos. El botón de procesar guarda lo que haya en el formulario.
- Para ver los metadatos sin editarlos, usa [Ver Metadatos](./view-metadata). Para eliminar todos los metadatos por completo, usa Eliminar Metadatos.
## Herramientas Relacionadas
- [Ver Metadatos](./view-metadata)
- [Capas PDF (OCG)](./pdf-layers)
- [Comprimir PDF](./compress-pdf)
docs/es/tools/edit-pdf.md
+48
View File
@@ -0,0 +1,48 @@
---
title: Editor PDF
description: Anota, resalta, tacha, agrega formas e imágenes, busca y visualiza PDFs directamente en tu navegador.
---
# Editor PDF
El Editor PDF de BentoPDF te permite anotar, resaltar, tachar contenido (redactar), comentar, agregar formas e imágenes y buscar dentro de tus PDFs. Carga un editor completo directamente en tu navegador, sin subir nada a ningún servidor.
## Cómo Funciona
1. Sube tu PDF haciendo clic en la zona de carga o arrastrando un archivo sobre ella.
2. El editor de PDF integrado se abre automáticamente con tu documento cargado.
3. Usa la barra de herramientas para anotar, resaltar, redactar, agregar texto, dibujar formas o insertar imágenes.
4. Haz clic en **Descargar PDF editado** para guardar tus cambios.
## Características
- Barra de herramientas de anotación completa con resaltado, subrayado, tachado y dibujo a mano alzada
- Inserción de texto y comentarios
- Herramientas de redacción que eliminan de forma permanente el contenido marcado una vez que aplicas la redacción. Si alguna marca no se ha aplicado cuando haces clic en **Descargar PDF editado**, el editor te ofrece aplicarlas primero.
- Herramientas de formas para rectángulos, círculos, líneas y flechas
- Inserción de imágenes en las páginas del PDF
- Búsqueda de texto integrada en todo el documento
- Compatibilidad con varios documentos mediante pestañas (hasta 10 documentos abiertos simultáneamente)
- Carga de archivos con arrastrar y soltar
## Casos de Uso
- Revisar contratos y marcar cambios con resaltados y comentarios
- Redactar información confidencial, como números de seguro social o datos financieros, antes de compartir
- Agregar anotaciones a planos arquitectónicos o dibujos de ingeniería
- Insertar logotipos o sellos de empresa en las páginas de un documento
- Buscar términos específicos en documentos legales extensos
## Consejos
- Puedes abrir varios PDFs a la vez y cambiar entre ellos con la barra de pestañas en la parte superior del editor.
- El editor conserva la estructura original del PDF, por lo que las fuentes, los diseños y los campos de formulario permanecen intactos.
- Marcar texto o un área para redactar no elimina nada hasta que se aplica la redacción. Cuando redactas texto seleccionado, también se eliminan de la descarga las copias de ese texto en las propiedades del archivo, los marcadores, los comentarios y los adjuntos, a menos que el archivo esté cifrado.
- Para marcas de agua o numeración de páginas en lote, usa las herramientas dedicadas, que ofrecen más control sobre el formato.
## Herramientas Relacionadas
- [Agregar Marca de Agua](./add-watermark)
- [Firmar PDF](./sign-pdf)
- [Agregar Sellos](./add-stamps)
- [Eliminar Anotaciones](./remove-annotations)
docs/es/tools/email-to-pdf.md
+50
View File
@@ -0,0 +1,50 @@
---
title: Email a PDF
description: Convierte archivos de correo EML y MSG a PDF en tu navegador. Conserva los encabezados, el cuerpo y la lista de adjuntos.
---
# Email a PDF
Convierte correos electrónicos guardados en PDFs limpios e imprimibles. La herramienta analiza archivos EML y MSG, extrae el mensaje completo (encabezados, contenido del cuerpo y metadatos de los adjuntos) y lo renderiza todo en un PDF estructurado. Es útil para peritajes legales, archivo de registros o simplemente para imprimir un correo importante.
## Formatos Compatibles
| Formato | Extensión | Notas |
| :------ | :-------- | :------------------------------------------------------------------------------------- |
| EML | `.eml` | Formato estándar de correo MIME (exportado desde la mayoría de los clientes de correo) |
| MSG | `.msg` | Formato propietario de Microsoft Outlook |
## Cómo Funciona
1. Haz clic en el área de carga o arrastra y suelta tus archivos EML o MSG. Puedes mezclar ambos formatos en un mismo lote.
2. Revisa la lista de archivos. Quita las entradas que no quieras con el icono de la papelera, o haz clic en **Agregar Más Archivos** para incluir más correos.
3. Configura las opciones de conversión (ver abajo).
4. Haz clic en **Convertir a PDF**. La herramienta analiza cada correo, renderiza el contenido como HTML con estilo y lo convierte a PDF con el motor PyMuPDF.
5. Un solo correo se descarga directamente como PDF. Varios correos se empaquetan en `emails-converted.zip`.
## Opciones
| Opción | Predeterminado | Descripción |
| :-------------------------------------------------- | :------------- | :---------------------------------------------------------------------------------------------------------------- |
| **Tamaño de página** | A4 | Elige entre las dimensiones de página A4, Letter o Legal. |
| **Incluir destinatarios CC y CCO en el encabezado** | Activado | Si está activada, las listas de destinatarios CC y CCO aparecen en la sección de encabezado del correo en el PDF. |
| **Incluir lista de archivos adjuntos del correo** | Activado | Si está activada, en el PDF aparece una lista de los archivos adjuntos del correo (con nombres y tamaños). |
## Casos de Uso
- Archivar correspondencia comercial importante como PDF para cumplimiento normativo o auditorías
- Imprimir cadenas de correos para procedimientos legales o solicitudes de pruebas
- Crear un registro permanente de confirmaciones de pedidos, recibos o contratos recibidos por correo
- Respaldar archivos MSG de Outlook en un formato que no requiere Outlook para leerse
- Documentar interacciones de atención al cliente a partir de archivos EML exportados
## Consejos
- Se admiten tanto EML (usado por Thunderbird, Apple Mail y la mayoría de los clientes de correo) como archivos MSG de Outlook. Exporta los correos desde tu cliente de correo y suéltalos directamente en la herramienta.
- Los correos con formato HTML conservan su estilo en el PDF. Los correos de texto plano se renderizan con un formato limpio y legible.
- La lista de adjuntos muestra nombres de archivo y tamaños, pero no incrusta los archivos adjuntos reales en el PDF.
## Herramientas Relacionadas
- [XML a PDF](./xml-to-pdf)
- [XPS a PDF](./xps-to-pdf)
docs/es/tools/epub-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: EPUB a PDF
description: Convierte libros electrónicos EPUB a PDF en tu navegador. Gratis, sin subir archivos, con conversión que prioriza la privacidad.
---
# EPUB a PDF
Convierte libros electrónicos EPUB en archivos PDF sin salir de tu navegador. EPUB es el estándar abierto para libros digitales, pero a veces necesitas un PDF de diseño fijo para imprimir, anotar o compartir con personas que no tienen un lector de libros electrónicos.
## Formatos Compatibles
| Formato | Extensión | Notas |
| :------ | :-------- | :----------------------- |
| EPUB | `.epub` | Archivos EPUB 2 y EPUB 3 |
## Cómo Funciona
1. Haz clic en el área de carga o arrastra y suelta tus archivos EPUB. Se admite la selección múltiple.
2. Revisa los archivos subidos. Quita las entradas que no quieras con el icono de la papelera, o haz clic en **Agregar Más Archivos** para ampliar el lote.
3. Haz clic en **Convertir a PDF**. El motor PyMuPDF renderiza el contenido del EPUB (texto, imágenes y formato) en un PDF paginado.
4. Un solo EPUB se descarga directamente como PDF. Varios archivos se empaquetan en un ZIP llamado `epub-converted.zip`.
## Opciones
La conversión se ejecuta con valores predeterminados razonables y no requiere configuración. El texto se reajusta a las dimensiones de página estándar, y las fuentes e imágenes incrustadas pasan al PDF.
## Casos de Uso
- Imprimir un libro electrónico sin DRM para leerlo lejos de las pantallas
- Enviar un manuscrito EPUB como PDF de diseño fijo para su revisión
- Archivar libros digitales en un formato que cualquier sistema operativo pueda abrir de forma nativa
- Compartir un capítulo con un colega que no tiene un lector de EPUB
- Convertir documentación técnica distribuida en EPUB en PDFs que se pueden anotar
## Consejos
- Las funciones de EPUB 3, como el audio y el video incrustados, no pasan al PDF, pero todo el texto, las imágenes y las tablas se convierten sin problemas.
- Para obtener los mejores resultados con EPUBs de estilo muy elaborado, revisa las primeras páginas del resultado para confirmar la fidelidad del diseño.
## Herramientas Relacionadas
- [MOBI a PDF](./mobi-to-pdf)
- [FB2 a PDF](./fb2-to-pdf)
- [CBZ a PDF](./cbz-to-pdf)
docs/es/tools/excel-to-pdf.md
+55
View File
@@ -0,0 +1,55 @@
---
title: Excel a PDF
description: Convierte hojas de cálculo de Excel (XLS, XLSX), ODS y archivos CSV a PDF conservando el formato.
---
# Excel a PDF
Convierte hojas de cálculo a PDF. La herramienta admite archivos modernos de Excel, el formato XLS heredado, hojas de cálculo OpenDocument e incluso CSV, todo renderizado con un motor LibreOffice que se ejecuta en el navegador y conserva el formato de las celdas, las fórmulas (como valores calculados), los gráficos y los diseños de varias hojas.
## Formatos Compatibles
| Formato | Extensiones |
| :--------------------------- | :---------- |
| Excel (moderno) | `.xlsx` |
| Excel (heredado) | `.xls` |
| Hoja de cálculo OpenDocument | `.ods` |
| CSV | `.csv` |
## Cómo Funciona
1. Haz clic en el área de carga o arrastra y suelta tus hojas de cálculo.
2. Revisa la lista de archivos. Agrega más archivos o quita los que no quieras.
3. Haz clic en **Convertir a PDF**. El motor LibreOffice se inicializa en el primer uso y luego procesa cada archivo.
4. Un solo archivo se descarga directamente como PDF. Varios archivos se entregan como `excel-converted.zip`.
## Opciones
Esta herramienta no tiene configuración adicional. El motor LibreOffice determina el diseño de página, la escala y el área de impresión según los ajustes integrados de la hoja de cálculo.
## Resultado
| Cantidad de Entradas | Resultado |
| :------------------- | :------------------------------------------------------------------------ |
| 1 archivo | Descarga de un solo PDF (nombre de archivo original con extensión `.pdf`) |
| 2+ archivos | Archivo ZIP (`excel-converted.zip`) con un PDF por cada archivo |
## Casos de Uso
- Convertir informes financieros o presupuestos de Excel a PDF para distribuirlos
- Crear PDFs listos para imprimir a partir de hojas de cálculo de inventario o catálogos de productos
- Compartir resultados de análisis de datos con personas que no tienen Excel instalado
- Archivar informes trimestrales en un formato no editable
- Convertir archivos ODS de LibreOffice Calc a PDF
## Consejos
- Los gráficos incrustados en la hoja de cálculo se renderizan en el PDF. Asegúrate de que se vean correctos en el archivo de origen antes de convertir.
- Si tu hoja de cálculo tiene varias hojas, todas se incluyen en el PDF resultante.
- Para datos CSV simples sin formato, la herramienta [CSV a PDF](./csv-to-pdf) ofrece una conversión más ligera. Usa Excel a PDF cuando necesites conservar formato, gráficos o varias hojas.
## Herramientas Relacionadas
- [CSV a PDF](./csv-to-pdf)
- [Word a PDF](./word-to-pdf)
- [PowerPoint a PDF](./powerpoint-to-pdf)
docs/es/tools/extract-attachments.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Extraer adjuntos
description: Extrae todos los archivos adjuntos incrustados de uno o más PDFs y descárgalos como un archivo ZIP.
---
# Extraer adjuntos
Saca todos los adjuntos incrustados de uno o más archivos PDF. Todos los archivos extraídos se agrupan en un único ZIP para su descarga.
## Cómo Funciona
1. Sube uno o más archivos PDF que contengan adjuntos incrustados.
2. Haz clic en **Extraer adjuntos**.
3. La herramienta busca en cada PDF los adjuntos a nivel de documento y de página.
4. Todos los archivos encontrados se empaquetan en un ZIP y se descargan automáticamente.
5. Un mensaje de estado confirma cuántos adjuntos se encontraron y su tamaño total.
## Características
- Extracción por lotes de varios PDFs a la vez
- Extrae tanto los adjuntos a nivel de documento como de página
- Genera un único archivo ZIP con todos los archivos extraídos
- Muestra la cantidad total de adjuntos y el tamaño combinado de los archivos
- Mensajes de estado claros si no se encuentran adjuntos
## Casos de Uso
- Recuperar archivos de datos incrustados en el PDF de un informe
- Sacar recursos de imagen de un portafolio o de un documento de especificaciones
- Extraer materiales complementarios de PDFs de capacitación o de cumplimiento
- Auditar qué archivos están incrustados en un lote de PDFs
## Consejos
- Si la herramienta indica que no hay adjuntos, el PDF puede contener imágenes incrustadas o datos de formulario, que no son archivos adjuntos. Usa [Extraer imágenes](./extract-images) para las imágenes incrustadas.
- Al procesar varios PDFs, todos los adjuntos de cada archivo terminan en un solo ZIP. Los nombres de archivo se conservan tal como estaban en las incrustaciones originales.
## Herramientas Relacionadas
- [Agregar Adjuntos](./add-attachments)
- [Editar Adjuntos](./edit-attachments)
- [Extraer imágenes](./extract-images)
docs/es/tools/extract-images.md
+45
View File
@@ -0,0 +1,45 @@
---
title: Extraer imágenes
description: Extrae todas las imágenes incrustadas de archivos PDF. Previsualízalas en una cuadrícula y descárgalas individualmente o como un archivo ZIP.
---
# Extraer imágenes
Saca todas las imágenes incrustadas de uno o más archivos PDF. Las imágenes extraídas se muestran en una cuadrícula de vista previa donde puedes descargarlas individualmente o todas a la vez como un ZIP. Funciona con PyMuPDF.
## Cómo Funciona
1. Sube uno o más PDFs haciendo clic en la zona de carga o arrastrando archivos sobre ella. Agrega más archivos o quita archivos individuales según necesites.
2. Haz clic en **Extraer imágenes** para iniciar el procesamiento.
3. La herramienta recorre cada página de cada PDF subido, buscando y extrayendo las imágenes incrustadas.
4. Las imágenes extraídas aparecen en una cuadrícula con miniaturas. Cada imagen tiene un botón de descarga.
5. Haz clic en **Descargar todo** para guardar todo como un archivo ZIP.
## Opciones
Esta herramienta no tiene opciones configurables. Todas las imágenes incrustadas se extraen en su formato original (normalmente PNG, JPEG o el formato que se usó cuando la imagen se incrustó en el PDF).
## Formato de Salida
- Las imágenes se muestran en una cuadrícula de vista previa con nombres como `image_1.png`, `image_2.jpg`, etc.
- **Descargar todo** genera `extracted-images.zip` con todas las imágenes.
- Las imágenes individuales se pueden descargar una por una desde la cuadrícula.
## Casos de Uso
- Recuperar fotos o gráficos de un PDF para reutilizarlos en otro proyecto.
- Extraer imágenes de productos del PDF de un catálogo para un listado de comercio electrónico.
- Sacar diagramas de documentación técnica para usarlos en presentaciones.
- Auditar qué imágenes están incrustadas en un documento antes de compartirlo.
## Consejos
- La herramienta extrae las imágenes exactamente como están almacenadas en el PDF. No vuelve a renderizar las páginas como imágenes; para eso, usa [PDF a PNG](./pdf-to-png) o [PDF a JPG](./pdf-to-jpg).
- Si la herramienta muestra "No se encontraron imágenes", es posible que el PDF use gráficos vectoriales en lugar de imágenes raster incrustadas, o que sea un documento escaneado donde toda la página es una sola imagen grande.
- El procesamiento por lotes funciona con varios PDFs. Todas las imágenes de todos los archivos se combinan en una sola cuadrícula y un solo ZIP.
## Herramientas Relacionadas
- [PDF a PNG](./pdf-to-png)
- [PDF a JPG](./pdf-to-jpg)
- [Constructor de flujos de trabajo PDF](./pdf-workflow)
docs/es/tools/extract-pages.md
+41
View File
@@ -0,0 +1,41 @@
---
title: Extraer páginas
description: Guarda un rango específico de páginas de un PDF como un documento nuevo.
---
# Extraer páginas
Saca un conjunto de páginas de un PDF y guárdalas como un archivo nuevo. Indica exactamente qué páginas quieres con la sintaxis de rangos, y la herramienta crea un PDF limpio que contiene solo esas páginas.
## Cómo Funciona
1. Sube un archivo PDF. La herramienta muestra el nombre del archivo, su tamaño y el total de páginas.
2. Ingresa las páginas que quieres extraer con la sintaxis de rangos (p. ej., `1-5`, `3, 7, 10-12`).
3. Opcionalmente, elige descargar cada rango como un PDF separado dentro de un archivo ZIP.
4. Haz clic en el botón de procesar. Las páginas extraídas se descargan como un nuevo PDF (o ZIP).
## Características
- Sintaxis flexible de rangos de páginas: páginas individuales, rangos o combinaciones separadas por comas
- Muestra el total de páginas después de la carga para consultarlo fácilmente
- Opción de generar un único PDF combinado o archivos separados en un ZIP
- Conserva el contenido y el formato originales de las páginas
## Casos de Uso
- Sacar el resumen ejecutivo (las primeras páginas) de un informe extenso
- Extraer un solo capítulo del PDF de un libro de texto
- Guardar páginas específicas de un paquete de formularios como documentos independientes
- Crear un documento de muestra con páginas seleccionadas de un archivo más grande
## Consejos
- Los números de página empiezan en 1. Usa `1` para la primera página, no `0`.
- Para quitar páginas en lugar de extraerlas, usa [Eliminar Páginas](./delete-pages), que es la operación inversa.
- Si necesitas selección visual de páginas con miniaturas, usa [Dividir PDF](./split-pdf) en el modo Visual Select.
## Herramientas Relacionadas
- [Dividir PDF](./split-pdf)
- [Eliminar Páginas](./delete-pages)
- [Fusionar PDF](./merge-pdf)
docs/es/tools/extract-tables.md
+46
View File
@@ -0,0 +1,46 @@
---
title: Extraer Tablas de PDF
description: Detecta y extrae tablas de documentos PDF. Exporta como CSV, JSON o Markdown con granularidad por tabla.
---
# Extraer Tablas de PDF
Detecta todas las tablas de un PDF y te permite exportarlas en el formato que prefieras: CSV, JSON o Markdown. Cada tabla se extrae de forma individual con metadatos de página y posición. Funciona con el motor de detección de tablas de PyMuPDF.
## Cómo Funciona
1. Sube un PDF haciendo clic en la zona de carga o arrastrando un archivo sobre ella.
2. Selecciona tu **formato de exportación** preferido: CSV, JSON o Markdown.
3. Haz clic en **Extraer tablas** para iniciar el procesamiento.
4. Si se encuentra una tabla, se descarga como un solo archivo. Si hay varias tablas, se genera un archivo ZIP con un archivo por tabla.
## Opciones
- **Formato de exportación**: elige entre:
- **CSV**: valores separados por comas con las comillas adecuadas para campos que contienen comas, comillas o saltos de línea. Adecuado para hojas de cálculo y bases de datos.
- **JSON**: estructura de arreglos de arreglos, con formato legible y sangría de 2 espacios. Adecuado para su consumo por programas.
- **Markdown**: formato de tabla delimitado por barras verticales, generado por PyMuPDF. Adecuado para documentación y archivos README.
## Formato de Salida
- **Una sola tabla**: `filename_table.csv` (o `.json` / `.md`)
- **Varias tablas**: `filename_tables.zip` con archivos llamados `table_1_page3.csv`, `table_2_page5.csv`, etc.
## Casos de Uso
- Extraer tablas específicas de informes PDF extensos sin sacar los datos de todo el documento.
- Obtener tablas en formato Markdown para pegarlas directamente en issues de GitHub, wikis o documentación.
- Sacar datos JSON estructurados de tablas de PDF para integraciones de API o scripts.
- Comparar tablas entre distintas versiones de un PDF exportando ambas a CSV y comparando las diferencias.
## Consejos
- Esta herramienta te da control por tabla. Si solo quieres volcar todas las tablas en un único CSV, usa [PDF a CSV](./pdf-to-csv). Para un libro completo de Excel, usa [PDF a Excel](./pdf-to-excel).
- Las tablas que abarcan varias páginas pueden detectarse como tablas separadas por página. Es posible que debas concatenarlas manualmente.
- Si no se detecta ninguna tabla, el PDF podría ser una imagen escaneada. Pásalo primero por OCR para agregar una capa de texto.
## Herramientas Relacionadas
- [PDF a CSV](./pdf-to-csv)
- [PDF a Excel](./pdf-to-excel)
- [PDF a Texto](./pdf-to-text)
docs/es/tools/fb2-to-pdf.md
+43
View File
@@ -0,0 +1,43 @@
---
title: FB2 a PDF
description: Convierte libros electrónicos FictionBook (FB2) a PDF en tu navegador. Gratis, privado, sin subir nada a ningún servidor.
---
# FB2 a PDF
Convierte archivos FictionBook 2 (FB2) en documentos PDF. FB2 es un formato de libro electrónico basado en XML, popular en Rusia y Europa del Este. Aunque tiene buen soporte en ciertas plataformas, en otras es prácticamente desconocido: convertirlo a PDF hace que tus libros se puedan leer en cualquier parte.
## Formatos compatibles
| Formato | Extensión | Notas |
| :------------ | :-------- | :----------------------------- |
| FictionBook 2 | `.fb2` | Formato de libro basado en XML |
## Cómo funciona
1. Haz clic en el área de carga o arrastra y suelta tus archivos FB2. Puedes seleccionar varios a la vez.
2. Revisa la lista de archivos. Usa el icono de papelera para quitar entradas individuales, o **Agregar Más Archivos** para incluir más.
3. Haz clic en **Convertir a PDF**. El motor PyMuPDF analiza la estructura XML del FB2 y la renderiza como contenido PDF paginado.
4. Un solo archivo se descarga directamente como PDF. Varias conversiones se agrupan en `fb2-converted.zip`.
## Opciones
No hace falta configurar nada. El conversor gestiona automáticamente la estructura XML del FB2 y conserva los saltos de capítulo, el formato y las imágenes incrustadas.
## Casos de uso
- Leer libros FB2 en dispositivos o aplicaciones que solo admiten PDF
- Imprimir literatura en ruso distribuida en formato FB2
- Archivar una biblioteca FB2 en un formato compatible con todo
- Compartir un libro con alguien cuyo lector no admite FictionBook
## Consejos
- Los archivos FB2 son XML plano, así que suelen ser pequeños y se convierten rápido incluso en el navegador.
- Si tus archivos FB2 están comprimidos como `.fb2.zip`, extráelos antes de subirlos.
## Herramientas relacionadas
- [EPUB a PDF](./epub-to-pdf)
- [MOBI a PDF](./mobi-to-pdf)
- [XML a PDF](./xml-to-pdf)
docs/es/tools/fix-page-size.md
+44
View File
@@ -0,0 +1,44 @@
---
title: Ajustar tamaño de página
description: Unifica todas las páginas de un PDF en un mismo tamaño. Elige entre tamaños de papel estándar o define dimensiones personalizadas.
---
# Ajustar tamaño de página
Los PDF creados a partir de varias fuentes suelen tener páginas de tamaños distintos: algunas Letter, otras A4, otras totalmente fuera de norma. Esta herramienta fuerza todas las páginas a un único tamaño, escalando el contenido para ajustarlo o llenarlo según haga falta.
## Cómo funciona
1. Sube un archivo PDF.
2. Selecciona un **Tamaño de página de destino** en el menú desplegable (A4, Letter, Legal, A3, A5, Tabloid o Custom).
3. Elige una **Orientación**: Auto mantiene la orientación original de cada página, o puedes forzar Portrait o Landscape.
4. Elige un modo de **Escalado del contenido**: Fit (conserva todo el contenido, puede añadir márgenes) o Fill (llena la página, puede recortar los bordes).
5. Opcionalmente, define un **Color de fondo** para los márgenes añadidos.
6. Haz clic en **Ajustar tamaño de página**.
## Opciones
- **Tamaños estándar**: A4, Letter, Legal, A3, A5, Tabloid
- **Dimensiones personalizadas**: introduce ancho y alto en pulgadas o milímetros
- **Orientación**: Automática, Vertical, Horizontal
- **Modo de escalado**: Fit o Fill (Crop)
- **Color de fondo**: cualquier color para el relleno de los márgenes
## Casos de uso
- Normalizar un PDF combinado cuyas páginas vienen de escáneres distintos
- Convertir un documento US Letter a A4 para distribución internacional
- Preparar PDF listos para imprimir que exigen un tamaño de corte uniforme
- Corregir páginas ligeramente fuera de estándar (por ejemplo, 8,49 x 11,02 pulgadas en lugar de 8,5 x 11)
## Consejos
- Usa el modo Fit para garantizar que no se pierda contenido. El modo Fill se ve más limpio, pero puede recortar los bordes.
- Revisa el resultado con la herramienta Dimensiones de página para confirmar que todas las páginas coinciden con el tamaño objetivo.
- El color de fondo predeterminado es el blanco; cambia a un color oscuro si tu documento tiene márgenes oscuros.
## Herramientas relacionadas
- [Dimensiones de página](./page-dimensions): inspecciona los tamaños de página antes y después de corregirlos
- [Comprimir PDF](./compress-pdf): reduce el tamaño del archivo tras la estandarización
- [Recortar PDF](./crop-pdf): recorta las páginas manualmente en lugar de escalarlas automáticamente
docs/es/tools/flatten-pdf.md
+51
View File
@@ -0,0 +1,51 @@
---
title: Aplanar PDF
description: Aplana formularios interactivos y anotaciones en contenido estático. Hace que los campos no sean editables e integra las anotaciones en la página.
---
# Aplanar PDF
Aplanar fusiona los elementos interactivos (campos de formulario, menús desplegables, casillas, anotaciones, resaltados, notas adhesivas) directamente en el contenido de la página. La apariencia visual sigue igual, pero ya nada se puede editar ni extraer. Es el equivalente en PDF a imprimir un formulario rellenado y volver a escanearlo, solo que la calidad se mantiene perfecta.
## Cómo funciona
1. Sube uno o más archivos PDF.
2. Haz clic en **Aplanar PDF**.
3. Un solo archivo se descarga directamente. Varios archivos generan un archivo ZIP.
La herramienta usa pdf-lib para aplanar los campos de formulario (mediante `form.flatten()`) y un aplanador de anotaciones dedicado para integrar las anotaciones en el flujo de la página. Ambas operaciones se realizan en una sola pasada.
## Qué se aplana
- **Campos de formulario**: entradas de texto, casillas, botones de opción, menús desplegables, campos de firma
- **Anotaciones**: comentarios, resaltados, tachado, subrayado, notas adhesivas, sellos, anotaciones de tinta
- **Elementos interactivos**: botones, disparadores de acciones
## Qué no cambia
- El contenido de texto (sigue siendo seleccionable y se puede buscar)
- Imágenes y gráficos
- Diseño y dimensiones de la página
- Marcadores y tabla de contenido
- Hipervínculos (salvo los basados en anotaciones)
## Casos de uso
- Bloquear un formulario completado para que los destinatarios no puedan cambiar las respuestas enviadas
- Preparar un PDF para archivo donde los elementos interactivos no son necesarios
- Corregir problemas de visualización causados por anotaciones que se muestran distinto en cada visor
- Asegurar que un documento firmado no se pueda modificar tras aplicar la firma
- Reducir el tamaño del archivo eliminando las definiciones de campos y los objetos de anotación
## Consejos
- Aplana cuando hayas terminado todas las ediciones. No hay forma de desaplanar un PDF.
- Si necesitas aplanar y además eliminar metadatos, JavaScript y archivos adjuntos, usa la herramienta Sanear PDF: incluye el aplanado como una de sus opciones.
- Algunos PDF indican "no se encontró ningún formulario". Es normal si el documento solo tiene anotaciones y ningún campo de formulario.
## Herramientas relacionadas
- [Sanear PDF](./sanitize-pdf): aplana formularios y además elimina metadatos, scripts y más
- [Rasterizar PDF](./rasterize-pdf): convierte a PDF basado en imágenes para un aplanado máximo
- [Fuente a contorno](./font-to-outline): convierte las fuentes en trazados vectoriales
- [Cifrar PDF](./protect-pdf): bloquea el PDF aplanado con una contraseña
docs/es/tools/font-to-outline.md
+52
View File
@@ -0,0 +1,52 @@
---
title: Fuente a contorno
description: Convierte todas las fuentes de un PDF en contornos vectoriales para un renderizado uniforme en cualquier dispositivo. Elimina los problemas de dependencia de fuentes.
---
# Fuente a contorno
Convertir las fuentes en contornos transforma cada carácter de texto de un glifo basado en fuente en un trazado vectorial. El PDF deja de depender de las fuentes instaladas: se ve igual en cualquier dispositivo, sistema operativo e impresora. Es un paso habitual en los flujos de preimpresión.
## Cómo funciona
1. Sube uno o más archivos PDF.
2. Haz clic en **Convertir en contornos**.
3. Ghostscript convierte todo el texto en trazados vectoriales.
4. Descarga el resultado. Varios archivos generan un archivo ZIP.
No hay ajustes que configurar. La herramienta usa Ghostscript (WebAssembly) para convertir todas las referencias de fuentes en trazados de contorno en una sola pasada.
## Qué cambia
- Los caracteres de texto pasan a ser curvas vectoriales (trazados bezier)
- Ya no es necesario incrustar las fuentes: el PDF es autocontenido a nivel de glifo
- El tamaño del archivo puede aumentar porque los trazados vectoriales suelen ocupar más que las referencias a fuentes
- La apariencia visual se conserva exactamente
## Qué pierdes
- La selección y el copiado de texto
- La capacidad de búsqueda del texto (Ctrl+F deja de funcionar)
- La posibilidad de editar el contenido del texto
- La accesibilidad para lectores de pantalla
## Casos de uso
- Enviar PDF a una imprenta que exige fuentes convertidas a contornos
- Compartir documentos con fuentes personalizadas o con licencia con personas que no las tienen
- Evitar la sustitución de fuentes que cambia el aspecto de tu documento en otros sistemas
- Preparar PDF para flujos de grabado láser o corte CNC que requieren entrada vectorial
- Asegurar que un PDF con muchos logotipos se muestre correctamente en todas las plataformas
## Consejos
- Conserva tu PDF original. Convertir a contornos es irreversible: no puedes volver a convertir los trazados en texto editable.
- Si necesitas que el texto siga siendo buscable, considera usar la herramienta Rasterizar PDF con OCR como paso posterior.
- Los PDF con contornos tienden a ser más grandes. Ejecuta Comprimir PDF después si el tamaño importa.
## Herramientas relacionadas
- [Aplanar PDF](./flatten-pdf): aplana formularios y anotaciones sin tocar las fuentes
- [Rasterizar PDF](./rasterize-pdf): convierte a PDF basado en imágenes en lugar de contornos vectoriales
- [Comprimir PDF](./compress-pdf): reduce el tamaño del archivo tras convertir a contornos
- [PDF a PDF/A](./pdf-to-pdfa): convierte para archivo tras asegurar la independencia de fuentes
docs/es/tools/form-creator.md
+76
View File
@@ -0,0 +1,76 @@
---
title: Crear formulario PDF
description: Crea formularios PDF rellenables con campos de texto, casillas, menús desplegables, botones de opción y más, arrastrando y soltando.
---
# Crear formulario PDF
Diseña formularios PDF rellenables profesionales desde cero o añadiendo campos a un PDF existente. El editor visual te permite arrastrar y soltar elementos de formulario (campos de texto, casillas, menús desplegables, botones de opción, campos de firma y más) directamente sobre las vistas previas de página. Configura las propiedades de los campos, define reglas de visibilidad condicional y exporta un formulario PDF totalmente interactivo.
## Cómo funciona
1. Sube un PDF existente **o** haz clic en **Crear PDF en blanco** para empezar desde cero.
2. Si creas un PDF en blanco, selecciona un tamaño de página (Letter, A4, A5, Legal, Tabloid, A3 o dimensiones personalizadas).
3. Se abre el editor de formularios con una barra de herramientas de tipos de campo y un área de vista previa de la página.
4. Selecciona un tipo de campo en la barra de herramientas y luego haz clic en la página para colocarlo.
5. Arrastra los campos para reposicionarlos. Usa los tiradores para ajustar las dimensiones.
6. Haz clic en un campo para abrir el panel de propiedades, donde puedes definir el nombre del campo, el valor predeterminado, el tamaño de fuente, la alineación y más.
7. Navega entre páginas con los controles de página.
8. Haz clic en **Descargar formulario PDF** para descargar el PDF rellenable terminado.
## Características
- Colocación de campos arrastrando y soltando, con tiradores visuales para redimensionar
- Tipos de campo: entrada de texto, texto multilínea, casilla, menú desplegable, botón de opción, firma, fecha, número y código de barras
- Panel de propiedades para configurar el nombre, la etiqueta, el valor predeterminado, el tamaño de fuente, el color, la alineación y la validación de cada campo
- Acciones de campo y reglas de visibilidad condicional (mostrar u ocultar campos según los valores de otros campos)
- Navegación por páginas para formularios de varias páginas
- Extracción de campos existentes: detecta e importa automáticamente los campos de formulario de los PDF subidos
- Compatible tanto con PDF subidos como con páginas en blanco como lienzo del formulario
- Varios tamaños de página predefinidos, además de dimensiones personalizadas
- Generación de códigos de barras con bwip-js
- Gestión de grupos de botones de opción
## Opciones
**Tamaños de página predefinidos (para PDF en blanco):**
- Letter (8.5" x 11")
- A4 (210mm x 297mm)
- A5 (148mm x 210mm)
- Legal (8.5" x 14")
- Tabloid (11" x 17")
- A3 (297mm x 420mm)
- Custom (indica ancho y alto)
**Propiedades de los campos (varían según el tipo de campo):**
- Nombre, etiqueta y texto de marcador
- Valor predeterminado
- Familia, tamaño y color de la fuente
- Alineación del texto (izquierda, centro, derecha)
- Interruptor de campo obligatorio
- Interruptor de solo lectura
- Longitud máxima de los campos de texto
- Lista de opciones para menús desplegables y botones de opción
- Acciones de visibilidad condicional
## Casos de uso
- Crear formularios de incorporación de empleados con campos de texto para datos personales y casillas para aceptar políticas
- Crear cuestionarios de admisión de clientes con menús desplegables para elegir el servicio
- Diseñar formularios de pedido con campos calculados e identificadores de código de barras
- Crear listas de inspección con botones de opción para valoraciones de aprobado o suspenso
- Crear encuestas con preguntas de seguimiento condicionales que aparecen según las respuestas
## Consejos
- Si subes un PDF existente, la herramienta intentará extraer los campos de formulario que ya contenga, para que puedas editarlos o añadir otros.
- Usa la función de grupo de botones de opción para crear selecciones mutuamente excluyentes. Los campos del mismo grupo comparten un nombre de grupo.
- Prueba tu formulario descargándolo y abriéndolo en [Form Filler](./form-filler) para verificar el comportamiento de los campos.
## Herramientas relacionadas
- [Form Filler](./form-filler)
- [Firmar PDF](./sign-pdf)
- [Editor de PDF](./edit-pdf)
docs/es/tools/form-filler.md
+47
View File
@@ -0,0 +1,47 @@
---
title: Rellenar formularios PDF
description: Rellena formularios PDF, incluidos los formularios XFA, directamente en tu navegador con un visor integrado.
---
# Rellenar formularios PDF
Abre un PDF con campos de formulario y rellénalo directamente en un visor integrado. La herramienta admite tanto los campos AcroForm estándar como los formularios XFA (XML Forms Architecture) heredados. Cuando termines, descarga la versión rellenada con un solo clic.
## Cómo funciona
1. Sube un PDF que contenga campos de formulario.
2. El documento se abre en un visor de PDF integrado que muestra los campos de formulario como entradas interactivas.
3. Haz clic en los campos de texto, casillas, menús desplegables y botones de opción para rellenarlos.
4. Haz clic en **Guardar y descargar formulario rellenado** para obtener el PDF completado.
## Características
- Visor PDF.js integrado con interacción completa con los campos de formulario
- Compatibilidad con los campos AcroForm estándar (entradas de texto, casillas, menús desplegables, botones de opción)
- Compatibilidad con formularios XFA, el formato heredado basado en XML
- Ajuste automático del tamaño del visor según las dimensiones de la página
- Visualización del archivo con su nombre y tamaño
## Opciones
No hay opciones de configuración adicionales. Sube el formulario, rellénalo y descárgalo.
## Casos de uso
- Completar formularios de impuestos, solicitudes de seguros o trámites con la administración
- Rellenar solicitudes de empleo recibidas como archivos PDF adjuntos
- Completar formularios de alta de proveedores o cuestionarios para proveedores
- Dar el visto bueno a listas de cumplimiento normativo con casillas
- Rellenar formularios de admisión médica antes de una cita
## Consejos
- Los formularios XFA son un formato heredado que solo admiten algunos visores de PDF. Si abres un PDF XFA en Chrome o en la mayoría de otras herramientas y ves páginas en blanco, es porque esos visores no admiten XFA. El Form Filler de BentoPDF y Firefox sí gestionan XFA correctamente.
- Para PDF sin campos de formulario, usa primero la herramienta [Crear formulario PDF](./form-creator) para añadir campos y luego rellénalos aquí.
- El visor ajusta su tamaño automáticamente a las dimensiones de página del PDF.
## Herramientas relacionadas
- [Crear formulario PDF](./form-creator)
- [Firmar PDF](./sign-pdf)
- [Editor de PDF](./edit-pdf)
docs/es/tools/header-footer.md
+53
View File
@@ -0,0 +1,53 @@
---
title: Encabezado y pie de página
description: Añade texto personalizable de encabezado y pie de página a las páginas del PDF, con variables dinámicas de número de página.
---
# Encabezado y pie de página
Añade texto en seis posiciones de las páginas de tu PDF: encabezado izquierdo, central y derecho, y pie de página izquierdo, central y derecho. La herramienta admite variables dinámicas para el número de página y el total de páginas, de modo que puedes crear plantillas como "Página 3 de 10" que se actualizan automáticamente en cada página.
## Cómo funciona
1. Sube tu archivo PDF.
2. Aparece el panel de opciones con los controles de formato y seis campos de texto.
3. Escribe el texto que quieras en cualquiera de las posiciones de encabezado o pie de página.
4. Usa los marcadores `{page}` y `{total}` para la numeración dinámica de páginas.
5. Ajusta el tamaño y el color de la fuente y, si quieres, limita el rango de páginas.
6. Haz clic en **Agregar encabezado y pie de página** para procesar y descargar.
## Opciones
- **Rango de páginas**: limita opcionalmente qué páginas llevan encabezado y pie de página. Déjalo vacío para aplicarlo a todas. Formato: "1-3, 5" (rangos separados por comas).
- **Tamaño de fuente**: entre 6 y 24 puntos. El valor predeterminado es 10.
- **Color de fuente**: elige cualquier color con el selector de color.
- **Encabezado izquierda / centro / derecha**: campos de texto para la parte superior de cada página.
- **Pie de página izquierda / centro / derecha**: campos de texto para la parte inferior de cada página.
## Características
- Seis posiciones de texto independientes por página
- Variable dinámica `{page}` que inserta el número de la página actual
- Variable dinámica `{total}` que inserta el total de páginas
- Filtro por rango de páginas para elegir páginas concretas
- Tamaño y color de fuente personalizables
- Fuente Helvetica para un resultado limpio y profesional
## Casos de uso
- Añadir "Página {page} de {total}" en el centro del pie de página de un informe
- Poner el nombre de la empresa en el encabezado izquierdo y la fecha del documento en el derecho
- Añadir avisos de confidencialidad al pie de página de documentos legales
- Estampar números de revisión del documento en rangos de páginas concretos
## Consejos
- Combina `{page}` y `{total}` en un solo campo para formatos como "Página {page} de {total}" o "{page}/{total}".
- Puedes dejar vacíos la mayoría de los campos y rellenar solo las posiciones que necesites. Los campos vacíos simplemente se omiten.
- Para encabezados más complejos con imágenes o logotipos, considera usar la herramienta [Añadir marca de agua](./add-watermark) colocada en la parte superior de la página.
## Herramientas relacionadas
- [Números de página](./page-numbers)
- [Añadir marca de agua](./add-watermark)
- [Numeración Bates](./bates-numbering)
docs/es/tools/heic-to-pdf.md
+46
View File
@@ -0,0 +1,46 @@
---
title: HEIC a PDF
description: Convierte imágenes HEIC y HEIF de iPhone y iPad a PDF directamente en tu navegador.
---
# HEIC a PDF
Convierte imágenes HEIC/HEIF a PDF. HEIC es el formato de foto predeterminado en iPhone y iPad desde iOS 11. Esta herramienta te permite convertir esas fotos en PDF sin instalar software de escritorio ni subir archivos a un servidor.
## Formatos compatibles
| Formato | Extensiones |
| :------ | :---------- |
| HEIC | `.heic` |
| HEIF | `.heif` |
## Cómo funciona
1. Haz clic en el área de carga o arrastra y suelta tus archivos HEIC/HEIF.
2. Revisa la lista de archivos y quita los que no quieras.
3. Haz clic en **Convertir a PDF**. El resultado se descarga como `from_heic.pdf`.
Cada archivo HEIC se decodifica con la biblioteca heic2any, que lo convierte a PNG con una calidad del 92 %. Después, el PNG se incrusta en el PDF con pdf-lib, con cada imagen en su propia página y a resolución completa.
## Opciones
Esta herramienta no ofrece ajustes adicionales. Las imágenes HEIC se convierten a PNG en alta calidad (0.92) antes de incrustarse.
## Casos de uso
- Crear un PDF a partir de fotos de iPhone para adjuntarlo a un parte de seguro o a un informe
- Convertir fotos HEIC de un anuncio inmobiliario en un único documento imprimible
- Convertir capturas de pantalla de iPad (formato HEIF) en un PDF para compartir
- Convertir por lotes las fotos de un viaje para un diario de viaje
## Consejos
- La decodificación de HEIC se realiza por completo en el navegador con WebAssembly. La primera conversión puede tardar un momento mientras se carga el decodificador.
- Si necesitas combinar HEIC con otros formatos de imagen (JPG, PNG, etc.), usa la herramienta [Imágenes a PDF](./image-to-pdf), que admite HEIC junto con todos los demás formatos.
- Los archivos HEIC de iPhone suelen contener datos EXIF, incluidas coordenadas GPS. El PDF resultante no conserva estos metadatos.
## Herramientas relacionadas
- [Imágenes a PDF](./image-to-pdf)
- [JPG a PDF](./jpg-to-pdf)
- [PNG a PDF](./png-to-pdf)
docs/es/tools/image-to-pdf.md
+65
View File
@@ -0,0 +1,65 @@
---
title: Imágenes a PDF
description: Convierte JPG, PNG, BMP, GIF, TIFF, SVG, HEIC, WebP, PSD y más de 10 formatos de imagen en un único archivo PDF.
---
# Imágenes a PDF
El conversor universal de imágenes a PDF. Sube imágenes en prácticamente cualquier formato y combínalas en un único documento PDF. Cada imagen ocupa su propia página, con el tamaño de las dimensiones originales.
## Formatos compatibles
| Formato | Extensiones |
| :-------------- | :------------------------------------- |
| JPEG | `.jpg`, `.jpeg` |
| JPEG 2000 | `.jp2`, `.jpx` |
| PNG | `.png` |
| BMP | `.bmp` |
| GIF | `.gif` |
| TIFF | `.tiff`, `.tif` |
| SVG | `.svg` |
| HEIC/HEIF | `.heic`, `.heif` |
| WebP | `.webp` |
| PSD | `.psd` |
| Portable Anymap | `.pnm`, `.pgm`, `.pbm`, `.ppm`, `.pam` |
| JPEG XR | `.jxr` |
Es la compatibilidad de formatos más amplia de todos los conversores de imágenes de BentoPDF. Si solo necesitas un formato concreto, usa en su lugar una de las herramientas dedicadas.
## Cómo funciona
1. Haz clic en el área de carga o arrastra y suelta tus archivos de imagen. Puedes seleccionar varios a la vez.
2. Revisa la lista de archivos. Quita los que no quieras con el icono de papelera, o haz clic en **Agregar Más Archivos** para incluir más imágenes.
3. Elige un nivel de **Calidad del PDF** en el menú desplegable.
4. Haz clic en **Convertir a PDF**. La herramienta procesa las imágenes con el motor PyMuPDF y descarga el resultado como `images_to_pdf.pdf`.
## Opciones
**Calidad del PDF** controla la compresión que se aplica al incrustar las imágenes en el PDF:
- **Calidad alta**: compresión mínima, mayor tamaño de archivo. Ideal para impresión o archivo.
- **Calidad media** (predeterminado): compresión equilibrada. Buena para la mayoría de los usos.
- **Calidad baja**: compresión agresiva, el menor tamaño de archivo. Adecuada para correo electrónico o para compartir rápido.
Los archivos HEIC y WebP se convierten automáticamente a PNG antes de incrustarse. Esto ocurre de forma transparente y no requiere pasos adicionales.
## Casos de uso
- Combinar en un solo PDF recibos o documentos escaneados con la cámara del móvil
- Crear un portafolio de fotos o un lookbook a partir de imágenes en distintos formatos
- Convertir fotos de iPhone (HEIC) en un PDF para compartir, sin instalar software de escritorio
- Reunir maquetas de diseño a partir de exportaciones PSD y capturas de pantalla en un entregable para el cliente
- Archivar una carpeta de formatos de imagen antiguos (PNM, JXR, JP2) como un único PDF
## Consejos
- El orden de las imágenes en el PDF coincide con el orden de la lista de archivos. Súbelas en la secuencia que quieras.
- Para obtener el menor tamaño de archivo posible, elige Calidad baja. La diferencia visual suele ser insignificante en escaneos con mucho texto.
- Si solo tienes un formato de imagen, los conversores dedicados (JPG a PDF, PNG a PDF, etc.) ofrecen el mismo resultado con una interfaz más sencilla.
## Herramientas relacionadas
- [JPG a PDF](./jpg-to-pdf)
- [PNG a PDF](./png-to-pdf)
- [HEIC a PDF](./heic-to-pdf)
- [WebP a PDF](./webp-to-pdf)
docs/es/tools/index.md
+183
View File
@@ -0,0 +1,183 @@
# Referencia de herramientas
BentoPDF ofrece **más de 130 herramientas** para trabajar con PDF. Todas las herramientas se ejecutan por completo en tu navegador: tus archivos nunca salen de tu dispositivo.
---
## Editar y anotar
Modifica, marca y mejora tus documentos PDF con un completo conjunto de herramientas de edición.
<div class="tool-grid">
- [**Editor de PDF**](./edit-pdf): anota, resalta, censura, comenta, añade formas e imágenes, busca y visualiza PDF.
- [**Editar marcadores**](./bookmark): añade, edita, importa, elimina y extrae marcadores de PDF.
- [**Tabla de contenido**](./table-of-contents): genera una página de tabla de contenido a partir de los marcadores del PDF.
- [**Números de página**](./page-numbers): inserta números de página en tu documento.
- [**Añadir etiquetas de página**](./add-page-labels): aplica etiquetas de página de PDF con números romanos, prefijos e inicios personalizados.
- [**Numeración Bates**](./bates-numbering): añade números Bates secuenciales en uno o varios archivos PDF.
- [**Añadir marca de agua**](./add-watermark): estampa texto o una imagen sobre las páginas de tu PDF.
- [**Encabezado y pie de página**](./header-footer): añade texto en la parte superior e inferior de las páginas.
- [**Invertir colores**](./invert-colors): crea una versión en modo oscuro de tu PDF.
- [**Efecto escáner**](./scanner-effect): haz que tu PDF parezca un documento escaneado.
- [**Ajustar colores**](./adjust-colors): afina el brillo, el contraste, la saturación y más.
- [**Color de fondo**](./background-color): cambia el color de fondo de tu PDF.
- [**Cambiar color del texto**](./text-color): cambia el color del texto de tu PDF.
- [**Firmar PDF**](./sign-pdf): dibuja, escribe o sube tu firma.
- [**Añadir sellos**](./add-stamps): añade sellos de imagen a tu PDF con la barra de herramientas de anotaciones.
- [**Eliminar anotaciones**](./remove-annotations): quita comentarios, resaltados y enlaces.
- [**Recortar PDF**](./crop-pdf): recorta los márgenes de todas las páginas de tu PDF.
- [**Rellenador de formularios PDF**](./form-filler): rellena formularios directamente en el navegador. También admite formularios XFA.
- [**Crear formulario PDF**](./form-creator): crea formularios PDF rellenables con campos de texto arrastrando y soltando.
- [**Eliminar páginas en blanco**](./remove-blank-pages): detecta y elimina automáticamente las páginas en blanco.
</div>
---
## Convertir a PDF
Convierte imágenes, documentos, libros electrónicos y otros formatos de archivo en PDF.
<div class="tool-grid">
- [**Imágenes a PDF**](./image-to-pdf): convierte JPG, PNG, BMP, GIF, TIFF, SVG, HEIC, WebP y más a PDF.
- [**JPG a PDF**](./jpg-to-pdf): crea un PDF a partir de una o más imágenes JPG.
- [**PNG a PDF**](./png-to-pdf): crea un PDF a partir de una o más imágenes PNG.
- [**WebP a PDF**](./webp-to-pdf): crea un PDF a partir de una o más imágenes WebP.
- [**SVG a PDF**](./svg-to-pdf): crea un PDF a partir de una o más imágenes SVG.
- [**BMP a PDF**](./bmp-to-pdf): crea un PDF a partir de una o más imágenes BMP.
- [**HEIC a PDF**](./heic-to-pdf): crea un PDF a partir de una o más imágenes HEIC.
- [**TIFF a PDF**](./tiff-to-pdf): crea un PDF a partir de una o más imágenes TIFF.
- [**Texto a PDF**](./txt-to-pdf): convierte un archivo de texto plano en un PDF.
- [**Markdown a PDF**](./markdown-to-pdf): convierte Markdown a PDF con vista previa en vivo y resaltado de sintaxis.
- [**JSON a PDF**](./json-to-pdf): convierte archivos JSON a formato PDF.
- [**ODT a PDF**](./odt-to-pdf): convierte archivos ODT (OpenDocument Text) a PDF.
- [**CSV a PDF**](./csv-to-pdf): convierte hojas de cálculo CSV a PDF.
- [**RTF a PDF**](./rtf-to-pdf): convierte documentos RTF (Rich Text Format) a PDF.
- [**Word a PDF**](./word-to-pdf): convierte documentos de Word (DOCX, DOC, ODT) a PDF.
- [**Excel a PDF**](./excel-to-pdf): convierte hojas de cálculo de Excel (XLSX, XLS, ODS) a PDF.
- [**PowerPoint a PDF**](./powerpoint-to-pdf): convierte presentaciones de PowerPoint (PPTX, PPT, ODP) a PDF.
- [**XPS a PDF**](./xps-to-pdf): convierte documentos XPS/OXPS a PDF.
- [**MOBI a PDF**](./mobi-to-pdf): convierte libros electrónicos MOBI a PDF.
- [**EPUB a PDF**](./epub-to-pdf): convierte libros electrónicos EPUB a PDF.
- [**FB2 a PDF**](./fb2-to-pdf): convierte libros electrónicos FictionBook (FB2) a PDF.
- [**CBZ a PDF**](./cbz-to-pdf): convierte archivos de cómics (CBZ/CBR) a PDF.
- [**WPD a PDF**](./wpd-to-pdf): convierte documentos de WordPerfect (WPD) a PDF.
- [**WPS a PDF**](./wps-to-pdf): convierte documentos de WPS Office a PDF.
- [**XML a PDF**](./xml-to-pdf): convierte documentos XML a PDF.
- [**ODG a PDF**](./odg-to-pdf): convierte OpenDocument Graphics (ODG) a PDF.
- [**ODS a PDF**](./ods-to-pdf): convierte OpenDocument Spreadsheet (ODS) a PDF.
- [**ODP a PDF**](./odp-to-pdf): convierte OpenDocument Presentation (ODP) a PDF.
- [**PUB a PDF**](./pub-to-pdf): convierte Microsoft Publisher (PUB) a PDF.
- [**VSD a PDF**](./vsd-to-pdf): convierte Microsoft Visio (VSD, VSDX) a PDF.
- [**PSD a PDF**](./psd-to-pdf): convierte archivos de Adobe Photoshop (PSD) a PDF.
- [**Correo electrónico a PDF**](./email-to-pdf): convierte archivos de correo (EML, MSG) a formato PDF.
</div>
---
## Convertir desde PDF
Extrae el contenido de los PDF a imágenes, documentos y formatos de datos.
<div class="tool-grid">
- [**PDF a JPG**](./pdf-to-jpg): convierte cada página del PDF en una imagen JPG.
- [**PDF a PNG**](./pdf-to-png): convierte cada página del PDF en una imagen PNG.
- [**PDF a WebP**](./pdf-to-webp): convierte cada página del PDF en una imagen WebP.
- [**PDF a BMP**](./pdf-to-bmp): convierte cada página del PDF en una imagen BMP.
- [**PDF a TIFF**](./pdf-to-tiff): convierte cada página del PDF en una imagen TIFF.
- [**PDF a CBZ**](./pdf-to-cbz): convierte un PDF en un CBZ (archivo de cómic) para lectores de cómics y Calibre.
- [**PDF a SVG**](./pdf-to-svg): convierte cada página del PDF en un gráfico vectorial escalable.
- [**PDF a CSV**](./pdf-to-csv): extrae tablas de un PDF y las convierte a formato CSV.
- [**PDF a Excel**](./pdf-to-excel): extrae tablas de un PDF y las convierte a Excel (XLSX).
- [**PDF a escala de grises**](./pdf-to-greyscale): convierte todos los colores a blanco y negro.
- [**PDF a JSON**](./pdf-to-json): convierte archivos PDF a formato JSON.
- [**PDF a Word**](./pdf-to-word): convierte archivos PDF en documentos de Word editables.
- [**Extraer imágenes**](./extract-images): extrae todas las imágenes incrustadas de tus archivos PDF.
- [**PDF a Markdown**](./pdf-to-markdown): convierte el texto y las tablas de un PDF a formato Markdown.
- [**Preparar PDF para IA**](./prepare-pdf-for-ai): extrae el contenido del PDF como JSON de LlamaIndex para flujos RAG/LLM.
- [**PDF a texto**](./pdf-to-text): extrae el texto de archivos PDF y guárdalo como texto plano.
- [**Extraer tablas**](./extract-tables): extrae tablas de PDF como CSV, JSON o Markdown.
</div>
---
## Organizar y gestionar
Reorganiza, combina, divide y gestiona las páginas y los archivos de tus PDF.
<div class="tool-grid">
- [**Creador de flujos de trabajo PDF**](./pdf-workflow): crea flujos de procesamiento de PDF personalizados con un editor visual de nodos.
- [**Multiherramienta PDF**](./pdf-multi-tool): editor de PDF completo con gestión de páginas.
- [**OCR PDF**](./ocr-pdf): haz que un PDF se pueda buscar y copiar.
- [**Combinar PDF**](./merge-pdf): une varios PDF en un solo archivo.
- [**Alternar y mezclar páginas**](./alternate-merge): combina PDF alternando las páginas de cada uno.
- [**Intercalar escaneo a doble cara**](./duplex-collate): reordena los bloques de escaneo de anverso y reverso en la secuencia de páginas correcta.
- [**Organizar y duplicar**](./organize-pdf): duplica, reordena y elimina páginas.
- [**Añadir archivos adjuntos**](./add-attachments): incrusta uno o más archivos en tu PDF.
- [**Extraer archivos adjuntos**](./extract-attachments): extrae todos los archivos incrustados de uno o varios PDF como un ZIP.
- [**Editar archivos adjuntos**](./edit-attachments): consulta o elimina los archivos adjuntos de tu PDF.
- [**Capas PDF (OCG)**](./pdf-layers): consulta, activa, añade y elimina capas OCG de tu PDF.
- [**Dividir PDF**](./split-pdf): extrae un rango de páginas a un nuevo PDF.
- [**Dividir páginas**](./divide-pages): divide las páginas horizontal o verticalmente.
- [**Extraer páginas**](./extract-pages): guarda una selección de páginas como archivos nuevos.
- [**Eliminar páginas**](./delete-pages): quita páginas concretas de tu documento.
- [**Añadir página en blanco**](./add-blank-page): inserta una página vacía en cualquier lugar de tu PDF.
- [**Invertir páginas**](./reverse-pages): invierte el orden de todas las páginas de tu documento.
- [**Rotar PDF**](./rotate-pdf): gira las páginas en incrementos de 90 grados.
- [**Rotar con grados personalizados**](./rotate-custom): rota las páginas con cualquier ángulo personalizado.
- [**PDF N-Up**](./n-up-pdf): organiza varias páginas en una sola hoja.
- [**Folleto PDF**](./pdf-booklet): reorganiza las páginas para imprimir folletos a doble cara.
- [**Combinar en una sola página**](./combine-single-page): une todas las páginas en un único desplazamiento continuo.
- [**Ver metadatos**](./view-metadata): inspecciona las propiedades ocultas de tu PDF.
- [**Editar metadatos**](./edit-metadata): cambia el autor, el título y otras propiedades.
- [**PDF a ZIP**](./pdf-to-zip): empaqueta varios archivos PDF en un archivo ZIP.
- [**Comparar PDF**](./compare-pdfs): compara dos PDF lado a lado.
- [**Posterizar PDF**](./posterize-pdf): divide una página grande en varias páginas más pequeñas.
</div>
---
## Optimizar y reparar
Comprime, corrige y optimiza tus PDF para mejorar el rendimiento y la compatibilidad.
<div class="tool-grid">
- [**Comprimir PDF**](./compress-pdf): reduce el tamaño del archivo de tu PDF.
- [**PDF a PDF/A**](./pdf-to-pdfa): convierte un PDF a PDF/A para archivo a largo plazo.
- [**Corregir tamaño de página**](./fix-page-size): unifica todas las páginas en un mismo tamaño.
- [**Linealizar PDF**](./linearize-pdf): optimiza el PDF para verlo rápido en la web.
- [**Dimensiones de página**](./page-dimensions): analiza el tamaño, la orientación y las unidades de las páginas.
- [**Eliminar restricciones**](./remove-restrictions): quita la protección con contraseña y las restricciones de seguridad.
- [**Reparar PDF**](./repair-pdf): recupera datos de archivos PDF corruptos o dañados.
- [**Rasterizar PDF**](./rasterize-pdf): convierte el PDF en un PDF basado en imágenes. Aplana capas y elimina el texto seleccionable.
- [**Enderezar PDF**](./deskew-pdf): endereza automáticamente las páginas escaneadas inclinadas con OpenCV.
- [**Fuente a contorno**](./font-to-outline): convierte todas las fuentes en contornos vectoriales para un renderizado uniforme.
</div>
---
## Proteger PDF
Protege, cifra y controla el acceso a tus documentos PDF.
<div class="tool-grid">
- [**Cifrar PDF**](./protect-pdf): bloquea tu PDF añadiendo una contraseña.
- [**Sanear PDF**](./sanitize-pdf): elimina metadatos, anotaciones, scripts y más.
- [**Descifrar PDF**](./unlock-pdf): desbloquea el PDF quitando la protección con contraseña.
- [**Aplanar PDF**](./flatten-pdf): hace que los campos de formulario y las anotaciones no se puedan editar.
- [**Eliminar metadatos**](./remove-metadata): quita los datos ocultos de tu PDF.
- [**Cambiar permisos**](./change-permissions): establece o cambia los permisos de usuario de un PDF.
- [**Firma digital**](./digital-sign-pdf): añade una firma digital criptográfica con certificados X.509.
- [**Validar firma**](./validate-signature-pdf): verifica las firmas digitales y consulta los detalles del certificado.
</div>
docs/es/tools/invert-colors.md
+42
View File
@@ -0,0 +1,42 @@
---
title: Invertir colores
description: Invierte todos los colores de tu PDF para crear una versión en modo oscuro de cualquier documento.
---
# Invertir colores
Convierte cada color de tu PDF en su inverso. Los fondos blancos pasan a negro, el texto negro pasa a blanco y el resto de los colores cambian a sus valores complementarios. Es la forma más rápida de crear una versión en "modo oscuro" de cualquier PDF.
## Cómo funciona
1. Sube tu archivo PDF.
2. Haz clic en **Invertir colores** para procesarlo.
3. El PDF invertido se descarga automáticamente.
No hay ajustes adicionales. La herramienta renderiza cada página como imagen, invierte el color de todos los píxeles y reensambla el resultado en un nuevo PDF.
## Características
- Inversión de color con un solo clic en todas las páginas
- Procesa todas las páginas del documento
- Mantiene las dimensiones y el diseño originales de las páginas
- Funciona con cualquier PDF, sea cual sea su contenido (texto, imágenes o mixto)
## Casos de uso
- Crear versiones en modo oscuro de libros de texto o manuales para leer cómodamente de noche
- Preparar versiones de alto contraste de documentos por motivos de accesibilidad
- Invertir documentos escaneados que se capturaron con una exposición incorrecta
- Generar versiones en negativo de PDF con muchas imágenes para análisis visual
## Consejos
- Como la herramienta rasteriza las páginas para aplicar el efecto, el resultado está basado en imágenes. El texto ya no se podrá seleccionar ni buscar. Si necesitas texto buscable tras la inversión, pasa el resultado por una herramienta de OCR.
- Para ajustes de color más precisos (brillo, contraste, saturación), usa en su lugar la herramienta [Ajustar colores](./adjust-colors).
- Los PDF grandes con muchas páginas pueden tardar más en procesarse, ya que cada página se renderiza e invierte individualmente.
## Herramientas relacionadas
- [Ajustar colores](./adjust-colors)
- [Color de fondo](./background-color)
- [Efecto escáner](./scanner-effect)
docs/es/tools/jpg-to-pdf.md
+48
View File
@@ -0,0 +1,48 @@
---
title: JPG a PDF
description: Convierte una o más imágenes JPG, JPEG y JPEG 2000 en un único archivo PDF directamente en tu navegador.
---
# JPG a PDF
Convierte imágenes JPG en un PDF limpio. Sube un archivo o varios JPG a la vez: cada imagen se convierte en una página a tamaño completo del documento resultante.
## Formatos compatibles
| Formato | Extensiones |
| :-------- | :-------------- |
| JPEG | `.jpg`, `.jpeg` |
| JPEG 2000 | `.jp2`, `.jpx` |
## Cómo funciona
1. Haz clic en el área de carga o arrastra y suelta tus archivos JPG. Se admite la selección múltiple.
2. Revisa los archivos subidos. Usa el icono de papelera para quitar archivos individuales, o haz clic en **Agregar Más Archivos** para añadir más a la lista.
3. Selecciona un nivel de **Calidad del PDF**.
4. Haz clic en **Convertir a PDF**. La herramienta comprime las imágenes según el ajuste de calidad, las convierte con el motor PyMuPDF y descarga `from_jpgs.pdf`.
## Opciones
**Calidad del PDF** ajusta la compresión que se aplica a cada imagen antes de incrustarla en el PDF:
- **Calidad alta**: conserva el máximo detalle. Úsala para fotografía o impresión.
- **Calidad media** (predeterminado): un buen equilibrio entre nitidez y tamaño de archivo.
- **Calidad baja**: compresión agresiva para obtener el resultado más pequeño.
## Casos de uso
- Convertir documentos escaneados guardados como JPG en un único PDF para entregar
- Empaquetar fotos de productos en un catálogo para clientes
- Convertir imágenes médicas o de satélite en JPEG 2000 en un PDF portátil
- Crear un álbum de fotos imprimible a partir de exportaciones de la cámara
## Consejos
- Los archivos JPEG 2000 (`.jp2`, `.jpx`) son totalmente compatibles, no solo el JPEG estándar. Es útil para imágenes médicas y datos geoespaciales.
- Si tus JPG provienen de la cámara de un móvil, la Calidad media suele producir un archivo entre un 40 y un 60 % más pequeño que la Calidad alta, sin diferencia visible en pantalla.
## Herramientas relacionadas
- [Imágenes a PDF](./image-to-pdf)
- [PNG a PDF](./png-to-pdf)
- [WebP a PDF](./webp-to-pdf)
docs/es/tools/json-to-pdf.md
+53
View File
@@ -0,0 +1,53 @@
---
title: JSON a PDF
description: Reconstruye archivos PDF a partir del formato JSON de BentoPDF. Convierte las exportaciones JSON de vuelta en sus documentos PDF originales.
---
# JSON a PDF
Reconstruye documentos PDF a partir de archivos JSON creados previamente con la herramienta **PDF a JSON** de BentoPDF. Es una herramienta de conversión de ida y vuelta: toma la representación JSON estructurada de un PDF y reconstruye el documento original.
::: warning
Esta herramienta solo acepta archivos JSON generados por el conversor PDF a JSON de BentoPDF. No admite archivos JSON estándar de APIs, bases de datos u otras herramientas.
:::
## Formatos compatibles
| Entrada | Descripción |
| :------ | :----------------------------------------------------------------- |
| `.json` | Archivos JSON exportados con la herramienta PDF a JSON de BentoPDF |
## Cómo funciona
1. Haz clic en el área de carga o arrastra y suelta uno o más archivos JSON.
2. La lista de archivos muestra cada archivo seleccionado con su tamaño.
3. Haz clic en **Convertir a PDF**. La herramienta procesa todos los archivos con un Web Worker y el motor CPDF.
4. El resultado se descarga como `jsons-to-pdf.zip`, con un PDF por cada archivo JSON de entrada.
La conversión se ejecuta en un Web Worker en segundo plano, así que la interfaz sigue respondiendo incluso con archivos grandes.
## Opciones
Esta herramienta no tiene opciones configurables. La estructura del JSON determina por completo el PDF resultante.
## Resultado
Al convertir varios archivos JSON, los resultados se entregan en un archivo ZIP. Cada PDF lleva el nombre de su JSON de origen (por ejemplo, `report.json` pasa a ser `report.pdf`).
## Casos de uso
- Restaurar PDF desde una copia de seguridad o un flujo de archivo basados en JSON
- Pasar un PDF a JSON para inspeccionarlo y volver a convertirlo a PDF
- Reconstruir documentos tras modificar programáticamente la estructura del JSON
- Verificar que una exportación de PDF a JSON capturó todo el contenido del documento, convirtiéndolo de nuevo
## Consejos
- Si necesitas convertir datos JSON arbitrarios (como respuestas de API o archivos de configuración) en un PDF con formato, la herramienta [Texto a PDF](./txt-to-pdf) es más adecuada. Pega el JSON como texto y se mostrará con el formato correcto.
- El motor CPDF WebAssembly debe estar disponible para que esta herramienta funcione. Las instancias autoalojadas necesitan tener configurados los archivos WASM de CPDF.
## Herramientas relacionadas
- [Texto a PDF](./txt-to-pdf)
- [Markdown a PDF](./markdown-to-pdf)
- [CSV a PDF](./csv-to-pdf)
docs/es/tools/linearize-pdf.md
+49
View File
@@ -0,0 +1,49 @@
---
title: Linealizar PDF
description: Optimiza archivos PDF para verlos rápido en la web con carga progresiva. También conocido como optimización "Fast Web View".
---
# Linealizar PDF
La linealización reestructura un PDF para que la primera página pueda mostrarse antes de que se haya descargado todo el archivo. Adobe lo llama "Fast Web View". Si alojas PDF en un sitio web o los sirves desde un portal de documentos, la linealización hace que se abran de forma notablemente más rápida.
## Cómo funciona
1. Sube uno o más archivos PDF.
2. Haz clic en **Linealizar PDF**.
3. Descarga los resultados como un archivo ZIP con todos los archivos linealizados.
No hay ajustes que configurar. La herramienta usa la opción `--linearize` de QPDF, que reorganiza la estructura interna del PDF sin alterar su contenido visual.
## Qué hace la linealización
- Reordena los objetos del PDF para que los datos de la primera página aparezcan al principio del archivo
- Añade un diccionario de linealización y tablas de pistas para que los visores sepan dónde encontrar cada página
- Habilita las solicitudes por rangos de bytes: un navegador puede obtener solo la primera página sin descargar todo el archivo
- Limpia la tabla de referencias cruzadas para un acceso aleatorio eficiente
## Características
- Procesamiento por lotes de varios PDF en una sola operación
- El resultado conserva todo el contenido, las fuentes, las imágenes y los elementos interactivos
- Usa QPDF (WebAssembly) para una linealización fiable y conforme a los estándares
- Los resultados se empaquetan en un ZIP para descargarlos fácilmente
## Casos de uso
- Alojar informes PDF en un sitio web donde los usuarios esperan ver la página al instante
- Incrustar PDF en aplicaciones web con visores en el navegador
- Publicar catálogos o manuales en PDF a los que se accede con conexiones móviles lentas
- Preparar documentos para redes de distribución de contenido (CDN) que admiten el servicio por rangos de bytes
## Consejos
- Linealiza cuando hayas terminado el resto de las ediciones. Cualquier modificación posterior (combinar, añadir páginas) romperá la linealización.
- Combínalo con Comprimir PDF para obtener los PDF más pequeños y de carga más rápida posible.
- La linealización añade un pequeño aumento al tamaño del archivo (normalmente menos del 1 %).
## Herramientas relacionadas
- [Comprimir PDF](./compress-pdf): reduce el tamaño del archivo antes de linealizar
- [Reparar PDF](./repair-pdf): corrige problemas estructurales que impiden la linealización
- [Eliminar metadatos](./remove-metadata): quita los metadatos antes de publicar en línea
docs/es/tools/markdown-to-pdf.md
+59
View File
@@ -0,0 +1,59 @@
---
title: Markdown a PDF
description: Escribe o pega Markdown y expórtalo como un PDF con formato profesional, con vista previa en vivo y resaltado de sintaxis.
---
# Markdown a PDF
Un editor de Markdown completo con vista previa en vivo y exportación a PDF con un clic. Escribe desde cero, sube un archivo `.md` existente o pega contenido del portapapeles. El editor renderiza tu Markdown en tiempo real y exporta un PDF con estilo usando el motor de impresión integrado del navegador.
## Formatos compatibles
| Entrada | Descripción |
| :-------------- | :-------------------------- |
| Archivos `.md` | Súbelos con el botón Upload |
| Entrada directa | Escribe o pega en el editor |
## Cómo funciona
1. Abre la herramienta Markdown a PDF. El editor se carga con vista dividida: el código Markdown a la izquierda y la vista previa renderizada a la derecha.
2. Escribe tu Markdown, pégalo o haz clic en **Cargar** para cargar un archivo `.md`.
3. Alterna entre los temas claro y oscuro con el control deslizante de tema de la barra de herramientas.
4. Haz clic en **Exportar PDF** (o pulsa `Ctrl/Cmd + S`) para generar un PDF mediante el cuadro de impresión del navegador.
## Características
El editor admite un amplio conjunto de funciones de Markdown más allá de lo básico:
- **Markdown estándar**: encabezados, negrita, cursiva, enlaces, imágenes, listas, citas, líneas horizontales
- **Bloques de código** con resaltado de sintaxis para más de 15 lenguajes (JavaScript, TypeScript, Python, Go, Rust, SQL, Java, C#, C++, YAML, Bash y más)
- **Diagramas Mermaid**: los diagramas de flujo, de secuencia, ER y otros tipos de gráficos Mermaid se renderizan directamente en la vista previa
- **Tablas** con la sintaxis de tablas estándar de Markdown
- **Listas de tareas** con casillas
- **Notas al pie**, **subíndices**, **superíndices**
- **Listas de definiciones**, **abreviaturas**
- Compatibilidad con **emoji** (`:smile:` se muestra como el emoji)
- **Resaltados** (`==marked text==`) e **inserciones** (`++inserted text++`)
- **URL con enlace automático**: las URL sin formato se convierten en enlaces en los que se puede hacer clic
- Generación de **tabla de contenido**
- **Enlaces ancla** en los encabezados
## Casos de uso
- Escribir documentación de proyectos y exportar un PDF cuidado para las partes interesadas
- Crear informes técnicos con ejemplos de código y diagramas de arquitectura Mermaid
- Convertir un README de GitHub en un PDF para usarlo sin conexión o imprimirlo
- Redactar una propuesta o una especificación con listas de tareas y tablas
- Generar un material de apoyo con estilo a partir de apuntes de clase escritos en Markdown
## Consejos
- El PDF resultante usa la función de imprimir a PDF del navegador. En Chrome, puedes personalizar los márgenes y la escala en el cuadro de impresión antes de guardar.
- Los diagramas Mermaid se renderizan en la vista previa, pero pueden tardar un momento en inicializarse la primera vez.
- Usa `Ctrl/Cmd + S` como atajo de teclado para exportar sin tener que buscar el botón.
## Herramientas relacionadas
- [Texto a PDF](./txt-to-pdf)
- [Word a PDF](./word-to-pdf)
- [JSON a PDF](./json-to-pdf)
docs/es/tools/merge-pdf.md
+54
View File
@@ -0,0 +1,54 @@
---
title: Fusionar PDF
description: Combina varios archivos PDF en un solo documento, con reordenación por arrastrar y soltar y control a nivel de página.
---
# Fusionar PDF
Combina varios archivos PDF en un solo documento. Puedes unir archivos completos en un orden concreto, o cambiar al Modo página para controlar con precisión cada página de todos los PDF subidos.
## Cómo funciona
1. Sube dos o más archivos PDF haciendo clic en la zona de carga o arrastrándolos.
2. Elige entre **Modo archivo** y **Modo página** con el interruptor de la parte superior.
3. En Modo archivo, arrastra los archivos para reordenarlos y, si quieres, indica rangos de páginas (por ejemplo, `1-3, 5`) para cada archivo. Deja el rango en blanco para incluir todas las páginas.
4. En Modo página, arrastra y suelta las miniaturas de cada página para construir tu secuencia exacta.
5. Haz clic en **Fusionar PDF** para combinarlo todo en un solo archivo. El PDF combinado se descarga automáticamente.
## Características
- Dos modos de combinación: Modo archivo para unir archivos completos rápidamente y Modo página para controlar cada página
- Reordenación por arrastrar y soltar en ambos modos, con animaciones fluidas
- La sintaxis de rangos de páginas (por ejemplo, `1-3, 5, 8-10`) permite elegir páginas sin cambiar a Modo página
- Las miniaturas de página se cargan bajo demanda para que la interfaz siga respondiendo incluso con documentos grandes
- Sin límite en el número de archivos ni en el total de páginas
- Conserva la calidad original del PDF, sin recodificar
## Opciones
| Opción | Descripción |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------- |
| **Modo archivo** | Combina archivos completos en un orden personalizado, con filtros opcionales de rango de páginas por archivo |
| **Modo página** | Cuadrícula visual con todas las páginas de todos los archivos: arrastra las miniaturas para construir tu secuencia exacta |
| **Campo Páginas** | Campo de texto por archivo que acepta rangos como `1-3, 5` para incluir solo páginas concretas |
## Casos de uso
- Combinar PDF de capítulos sueltos en un único libro o informe
- Unir una carta de presentación y un currículum en un solo documento de candidatura
- Reunir páginas concretas de varios documentos de origen en un archivo consolidado
- Reunir recibos o facturas escaneados en un único PDF de archivo
- Crear un material de apoyo para una presentación a partir de diapositivas de varias presentaciones
## Consejos
- Usa Modo página cuando necesites intercalar páginas de distintos archivos en lugar de añadir un archivo detrás de otro.
- Puedes añadir más archivos después de la carga inicial con el botón **Agregar Más Archivos** sin perder tu organización actual.
- Los rangos de páginas empiezan a contar en 1, así que `1` se refiere a la primera página de ese archivo.
## Herramientas relacionadas
- [Dividir PDF](./split-pdf)
- [Organizar y duplicar](./organize-pdf)
- [Alternar y mezclar páginas](./alternate-merge)
- [Eliminar páginas](./delete-pages)
docs/es/tools/mobi-to-pdf.md
+43
View File
@@ -0,0 +1,43 @@
---
title: MOBI a PDF
description: Convierte libros electrónicos MOBI a PDF directamente en tu navegador. Gratis, privado, sin subir archivos.
---
# MOBI a PDF
Convierte libros electrónicos MOBI de Amazon Kindle en documentos PDF. Los archivos MOBI están ligados a dispositivos y aplicaciones Kindle, lo que dificulta leerlos en otro sitio. Convertirlos a PDF te da una versión portátil que puedes abrir en cualquier dispositivo o imprimir.
## Formatos compatibles
| Formato | Extensión | Notas |
| :------ | :-------- | :----------------------------------- |
| MOBI | `.mobi` | Formato de libro Kindle (Mobipocket) |
## Cómo funciona
1. Haz clic en el área de carga o arrastra y suelta uno o más archivos MOBI.
2. Revisa la lista de archivos. Quita los que no quieras con el icono de papelera, o usa **Agregar Más Archivos** para incluir más libros.
3. Haz clic en **Convertir a PDF**. El motor PyMuPDF analiza la estructura del MOBI y renderiza cada página como contenido PDF.
4. Un solo archivo se descarga como PDF. Al convertir varios archivos, obtienes un archivo ZIP llamado `mobi-converted.zip`.
## Opciones
No hacen falta ajustes adicionales. La conversión conserva el contenido de texto, el formato y las imágenes incrustadas del archivo MOBI original.
## Casos de uso
- Leer contenido comprado en Kindle en un lector que no es Kindle y solo admite PDF
- Imprimir capítulos de un libro electrónico para estudiar o anotar sin conexión
- Archivar tu biblioteca personal de libros electrónicos en un formato universal
- Compartir fragmentos con alguien que no tiene la aplicación Kindle instalada
## Consejos
- Los archivos MOBI protegidos con DRM no se pueden convertir. La herramienta solo funciona con archivos MOBI sin DRM.
- Los libros grandes con muchas imágenes incrustadas pueden tardar unos segundos más en procesarse, ya que todo ocurre en el navegador.
## Herramientas relacionadas
- [EPUB a PDF](./epub-to-pdf)
- [FB2 a PDF](./fb2-to-pdf)
- [CBZ a PDF](./cbz-to-pdf)
docs/es/tools/n-up-pdf.md
+54
View File
@@ -0,0 +1,54 @@
---
title: N-Up PDF
description: Organiza varias páginas de un PDF en una sola hoja con una cuadrícula, para imprimir de forma compacta.
---
# N-Up PDF
Coloca varias páginas en una sola hoja con una disposición en cuadrícula. Así se reduce el número de páginas impresas al ajustar 2, 4, 6, 8, 9 o 16 páginas por hoja. La herramienta se encarga del escalado, el posicionamiento y la configuración opcional del tamaño de página.
## Cómo funciona
1. Sube un archivo PDF.
2. Selecciona el número de páginas por hoja (el valor "N"): 2, 4, 6, 8, 9 o 16.
3. Elige el tamaño de página de salida (A4 por defecto) y la orientación.
4. Opcionalmente, configura el espaciado, el color del borde y el color de fondo.
5. Haz clic en el botón de procesar. La herramienta escala cada página y las distribuye en hojas nuevas.
## Características
- Disposiciones en cuadrícula: 2, 4, 6, 8, 9 y 16 páginas por hoja
- Tamaño de página de salida y orientación configurables
- Espaciado opcional entre las páginas
- Ajustes de color de fondo y de borde
- Mantiene la proporción de las páginas originales al escalarlas para que quepan
## Opciones
| Opción | Descripción |
| ------------------------------ | ----------------------------------------------------------------------------------- |
| **Páginas por hoja** | Número de páginas originales que caben en cada página de salida (2, 4, 6, 8, 9, 16) |
| **Tamaño de página de salida** | Tamaño de la hoja de salida (A4, Letter, Legal, etc.) |
| **Orientación** | Portrait o Landscape para la hoja de salida |
| **Espaciado** | Separación en puntos entre las páginas |
| **Color de fondo** | Color de relleno del fondo de la hoja de salida |
| **Color del borde** | Color de los bordes alrededor de cada página |
## Casos de uso
- Imprimir material de apoyo con 4 diapositivas por página para ahorrar papel
- Crear hojas de estudio con varias páginas de referencia en una sola hoja
- Producir archivos de documentos compactos para su archivo
- Generar hojas de miniaturas con una vista general de un documento largo
## Consejos
- La orientación horizontal suele funcionar mejor para las disposiciones de 2 páginas, mientras que la vertical suele ser la mejor para 4 o más.
- Aumentar el espaciado mejora la legibilidad, pero reduce el área disponible para cada página.
- Para la operación inversa (dividir una página en varias), consulta [Posterizar PDF](./posterize-pdf).
## Herramientas relacionadas
- [Posterizar PDF](./posterize-pdf)
- [Folleto PDF](./pdf-booklet)
- [Combinar en una sola página](./combine-single-page)
docs/es/tools/ocr-pdf.md
+54
View File
@@ -0,0 +1,54 @@
---
title: OCR PDF
description: Haz que los PDF escaneados se puedan buscar y copiar con Tesseract OCR, con compatibilidad con varios idiomas y filtrado de caracteres.
---
# OCR PDF
Convierte documentos escaneados en PDF en los que se puede buscar y copiar. La herramienta usa Tesseract OCR para reconocer el texto de las imágenes y superpone una capa de texto invisible sobre las páginas originales, conservando su apariencia visual y haciendo que el contenido sea totalmente buscable.
## Cómo funciona
1. Sube un PDF escaneado o basado en imágenes.
2. Selecciona uno o más idiomas presentes en el documento en la lista de idiomas con búsqueda.
3. Opcionalmente, ajusta la configuración avanzada (resolución, binarización, lista blanca).
4. Haz clic en **Iniciar OCR** y sigue el progreso en la barra de progreso en tiempo real.
5. Al terminar, revisa el texto extraído y descarga el PDF con búsqueda o un archivo `.txt` de texto plano.
## Características
- OCR en varios idiomas con un selector de idiomas con búsqueda
- La capa de texto invisible conserva la apariencia original del documento
- Barra de progreso y registro en tiempo real durante el procesamiento
- Descarga los resultados como PDF con búsqueda o como archivo de texto plano
- Copia el texto extraído directamente al portapapeles
- Tres niveles de resolución para equilibrar velocidad y precisión
## Opciones
| Ajuste | Valores | Predeterminado | Finalidad |
| ------------------------------------------- | ------------------------------------------------------------------------------------------------------- | -------------- | ---------------------------------------------------------------------------------------------- |
| **Resolución** | Estándar (192 DPI), Alta (288 DPI), Ultra (384 DPI) | Alta | Una mayor resolución mejora la precisión con texto pequeño, pero tarda más |
| **Binarizar imagen** | Activado / Desactivado | Desactivado | Mejora el contraste de escaneos limpios al convertirlos a blanco y negro |
| **Preajuste de lista blanca de caracteres** | Ninguno, Alfanumérico, Números + Moneda, Solo letras, Solo números, Factura, Formularios, Personalizado | Ninguno | Restringe los caracteres reconocidos para mejorar la precisión en tipos de documento concretos |
| **Lista blanca de caracteres** | Texto libre | Vacío | Conjunto de caracteres manual cuando el preajuste es Personalizado |
## Casos de uso
- Hacer que los contratos y facturas escaneados sean buscables para poder usar Ctrl+F en ellos
- Extraer texto de documentos fotografiados o de registros en papel antiguos
- Procesar recibos con el preajuste Invoice para capturar con precisión importes y fechas
- Crear PDF accesibles a partir de escaneos que solo contienen imágenes, para cumplir requisitos normativos
- Extraer por lotes el contenido de texto de libros o manuales escaneados
## Consejos
- Selecciona varios idiomas si tu documento tiene contenido en idiomas mezclados (por ejemplo, encabezados en inglés con texto principal en japonés).
- Usa la opción de binarizar en documentos con texto desvaído o de bajo contraste: puede mejorar mucho la precisión del reconocimiento.
- Los preajustes de lista blanca Invoice y Forms reducen drásticamente los falsos positivos en documentos estructurados al ignorar formas de caracteres irrelevantes.
## Herramientas relacionadas
- [Extraer tablas](./extract-tables)
- [Combinar PDF](./merge-pdf)
- [Comprimir PDF](./compress-pdf)
docs/es/tools/odg-to-pdf.md
+43
View File
@@ -0,0 +1,43 @@
---
title: ODG a PDF
description: Convierte archivos de LibreOffice Draw (ODG) a PDF en tu navegador. Gratis, sin subir nada, totalmente privado.
---
# ODG a PDF
Convierte archivos OpenDocument Graphics en PDF. ODG es el formato nativo de LibreOffice Draw y se usa para diagramas, diagramas de flujo e ilustraciones vectoriales. Convertirlos a PDF facilita compartir, imprimir e incrustar estos dibujos en otros documentos.
## Formatos compatibles
| Formato | Extensión | Notas |
| :-------------------- | :-------- | :--------------------------------------------- |
| OpenDocument Graphics | `.odg` | Archivos de LibreOffice Draw / OpenOffice Draw |
## Cómo funciona
1. Haz clic en el área de carga o arrastra y suelta tus archivos ODG. Puedes añadir varios a la vez.
2. Revisa la lista de archivos. Quita entradas individuales con el icono de papelera, o haz clic en **Agregar Más Archivos** para añadir más dibujos.
3. Haz clic en **Convertir a PDF**. Un motor basado en LibreOffice se carga en el navegador y convierte cada archivo ODG, conservando los gráficos vectoriales, las formas y el texto.
4. Un solo archivo se descarga directamente como PDF. Varios archivos generan un archivo ZIP llamado `odg-to-pdf.zip`.
## Opciones
No hacen falta ajustes adicionales. La conversión conserva las dimensiones de página originales, las formas, los conectores y los cuadros de texto del ODG de origen.
## Casos de uso
- Compartir diagramas de LibreOffice Draw con clientes que no tienen LibreOffice instalado
- Imprimir diagramas de flujo y diagramas de red creados en Draw
- Incluir ilustraciones ODG en un informe o presentación como PDF incrustados
- Archivar dibujos técnicos en un formato que seguirá siendo legible durante décadas
## Consejos
- Los elementos vectoriales siguen siendo vectores en el PDF resultante, así que el resultado se escala sin pérdida a cualquier tamaño de impresión.
- El motor de LibreOffice tarda un momento en inicializarse la primera vez. Las conversiones posteriores dentro de la misma sesión son más rápidas.
## Herramientas relacionadas
- [ODS a PDF](./ods-to-pdf)
- [ODP a PDF](./odp-to-pdf)
- [VSD a PDF](./vsd-to-pdf)
docs/es/tools/odp-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: ODP a PDF
description: Convierte presentaciones de LibreOffice Impress (ODP) a PDF en tu navegador. Gratis, privado, sin subir nada.
---
# ODP a PDF
Convierte archivos OpenDocument Presentation en PDF. ODP es el formato nativo de LibreOffice Impress y una exportación estándar de Google Slides. Convertir las presentaciones a PDF permite que cualquiera las vea sin software de presentaciones, y las diapositivas se imprimen con limpieza.
## Formatos compatibles
| Formato | Extensión | Notas |
| :------------------------ | :-------- | :------------------------------------------------- |
| OpenDocument Presentation | `.odp` | LibreOffice Impress / exportación de Google Slides |
## Cómo funciona
1. Haz clic en el área de carga o arrastra y suelta tus archivos ODP. Puedes seleccionar varias presentaciones a la vez.
2. Revisa la lista de archivos. Quita entradas con el icono de papelera, o usa **Agregar Más Archivos** para incluir más presentaciones.
3. Haz clic en **Convertir a PDF**. El motor basado en LibreOffice procesa cada presentación y genera un PDF en el que cada diapositiva es una página.
4. Un solo archivo se descarga como PDF. Varios archivos se entregan en un archivo ZIP llamado `odp-to-pdf.zip`.
## Opciones
No hay ajustes que configurar. Cada diapositiva se renderiza con sus dimensiones originales, conservando el texto, las imágenes, las formas y los fondos.
## Casos de uso
- Distribuir una presentación al público como PDF de material de apoyo
- Compartir exportaciones de Google Slides con personas que prefieren PDF a ODP
- Archivar charlas de congresos y clases en un formato de solo lectura
- Imprimir presentaciones para talleres presenciales
## Consejos
- Las transiciones y animaciones de las diapositivas son funciones puramente visuales que no pasan al PDF, pero todo el contenido estático se renderiza correctamente.
- Las notas del orador no se incluyen en el PDF. Si necesitas las notas, expórtalas por separado desde tu software de presentaciones.
- Como las demás herramientas basadas en LibreOffice, el motor se carga la primera vez que se usa y queda en caché durante la sesión.
## Herramientas relacionadas
- [ODG a PDF](./odg-to-pdf)
- [ODS a PDF](./ods-to-pdf)
- [PUB a PDF](./pub-to-pdf)
docs/es/tools/ods-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: ODS a PDF
description: Convierte hojas de cálculo de LibreOffice Calc (ODS) a PDF en tu navegador. Gratis, privado, sin registro.
---
# ODS a PDF
Convierte archivos OpenDocument Spreadsheet a PDF. ODS es el formato nativo de LibreOffice Calc y una exportación habitual de Google Sheets. Esta herramienta convierte los datos, el formato y los gráficos de tu hoja de cálculo en un PDF paginado que puedes imprimir o compartir.
## Formatos compatibles
| Formato | Extensión | Notas |
| :----------------------- | :-------- | :---------------------------------------------- |
| OpenDocument Spreadsheet | `.ods` | Exportación de LibreOffice Calc / Google Sheets |
## Cómo funciona
1. Haz clic en el área de carga o arrastra y suelta tus archivos ODS. Se admiten varios archivos.
2. Revisa la lista de archivos. Usa el icono de la papelera para quitar archivos, o haz clic en **Agregar más archivos** para ampliar el lote.
3. Haz clic en **Convertir a PDF**. El motor basado en LibreOffice se carga en el navegador y convierte cada hoja de cálculo en páginas PDF.
4. Una sola hoja de cálculo se descarga como PDF. Varios archivos se empaquetan en `ods-to-pdf.zip`.
## Opciones
No se requiere ninguna configuración. El convertidor aplica al PDF el diseño de impresión, el formato de celdas y los anchos de columna existentes de la hoja de cálculo.
## Casos de uso
- Compartir un presupuesto o informe de LibreOffice Calc con alguien que solo acepta PDF
- Imprimir una exportación de Google Sheets que se descargó como ODS
- Archivar registros financieros en un formato no editable
- Enviar formularios u hojas de horas en ODS como documentos de diseño fijo
## Consejos
- Si tu hoja de cálculo tiene varias hojas, todas se incluyen en el PDF.
- Las hojas de cálculo muy anchas pueden extenderse horizontalmente en varias páginas PDF. Si el diseño importa, ajusta los anchos de columna en el archivo original antes de convertir.
- El motor de LibreOffice se inicializa en el primer uso. Las conversiones siguientes en la misma sesión son más rápidas.
## Herramientas relacionadas
- [ODG a PDF](./odg-to-pdf)
- [ODP a PDF](./odp-to-pdf)
- [XML a PDF](./xml-to-pdf)
docs/es/tools/odt-to-pdf.md
+51
View File
@@ -0,0 +1,51 @@
---
title: ODT a PDF
description: Convierte archivos OpenDocument Text (ODT) a PDF en tu navegador con un motor basado en LibreOffice.
---
# ODT a PDF
Convierte archivos OpenDocument Text a PDF. ODT es el formato nativo de LibreOffice Writer, Apache OpenOffice y otros procesadores de texto de código abierto. Esta herramienta usa un motor de LibreOffice en el navegador para lograr conversiones precisas que conservan el formato, las tablas, las imágenes y los estilos.
## Formatos compatibles
| Formato | Extensiones |
| :---------------- | :---------- |
| OpenDocument Text | `.odt` |
## Cómo funciona
1. Haz clic en el área de carga o arrastra y suelta uno o más archivos ODT.
2. Revisa la lista de archivos. Agrega más archivos o quita los que no quieras.
3. Haz clic en **Convertir a PDF**. El motor de LibreOffice se inicializa (un indicador de progreso muestra el estado de carga) y luego se convierte cada archivo.
4. Un solo archivo se descarga directamente como PDF. Varios archivos se empaquetan en `odt-converted.zip`.
## Opciones
Esta herramienta no tiene configuración adicional. La conversión conserva el formato del documento original lo más fielmente posible.
## Salida
| Cantidad de entrada | Salida |
| :------------------ | :------------------------------------------------------------ |
| 1 archivo | Descarga de un solo PDF (p. ej., `document.pdf`) |
| 2 o más archivos | Archivo ZIP (`odt-converted.zip`) con un PDF por cada archivo |
## Casos de uso
- Convertir documentos de LibreOffice Writer a PDF para compartirlos con usuarios de Microsoft Office
- Generar PDF listos para imprimir a partir de trabajos académicos escritos en formato OpenDocument
- Convertir por lotes una carpeta de plantillas ODT en PDF para distribuirlos
- Generar PDF a partir de archivos ODT creados por sistemas automáticos de generación de documentos
## Consejos
- El motor de LibreOffice se carga en el primer uso y queda en caché para las siguientes conversiones. La primera carga tarda unos segundos; después, las conversiones son rápidas.
- Los documentos complejos con objetos OLE incrustados o fuentes poco comunes pueden verse un poco distintos que en LibreOffice de escritorio. Prueba con una muestra antes de convertir por lotes.
- Para documentos de Word (`.doc`, `.docx`), usa en su lugar la herramienta [Word a PDF](./word-to-pdf), que también usa el motor de LibreOffice pero acepta directamente los formatos de Microsoft.
## Herramientas relacionadas
- [Word a PDF](./word-to-pdf)
- [RTF a PDF](./rtf-to-pdf)
- [Texto a PDF](./txt-to-pdf)
docs/es/tools/organize-pdf.md
+45
View File
@@ -0,0 +1,45 @@
---
title: Duplicar y Organizar
description: Reordena, duplica y elimina páginas de un PDF con miniaturas de arrastrar y soltar y un orden de páginas personalizado.
---
# Duplicar y Organizar
Reorganiza, duplica y elimina páginas de un PDF con una interfaz visual de arrastrar y soltar. Cada página aparece como una miniatura que puedes mover, clonar o eliminar antes de guardar el resultado como un archivo nuevo.
## Cómo funciona
1. Sube un único archivo PDF.
2. La herramienta muestra una cuadrícula de miniaturas con todas las páginas.
3. Arrastra las miniaturas para reordenar las páginas, haz clic en el botón verde de duplicar para clonar una página o en el botón rojo de eliminar para quitarla.
4. También puedes escribir un orden de páginas personalizado en el campo de texto (p. ej., `3, 1, 2, 4`) y hacer clic en **Aplicar** para reorganizar todas las páginas de una vez.
5. Haz clic en el botón de procesar para crear y descargar el PDF reorganizado.
## Características
- Reordenación de páginas con arrastrar y soltar y transiciones animadas
- Botones de duplicar y eliminar en cada página
- Campo de orden de páginas personalizado para una reorganización precisa
- Etiquetas con el número de página que se actualizan automáticamente tras cada cambio
- Impide eliminar la última página restante
## Casos de uso
- Mover una página mal colocada a su posición correcta en un informe
- Duplicar una página de formulario para tener varias copias en blanco en un solo archivo
- Quitar páginas de borrador o de relleno antes de distribuir un documento
- Invertir o mezclar el orden de las páginas para preparar la impresión
- Crear una secuencia de páginas personalizada sin volver a fusionar archivos separados
## Consejos
- El campo de orden de páginas personalizado espera números de página originales separados por comas. Debe incluir cada página exactamente una vez, sin omisiones ni duplicados.
- Después de duplicar una página, ambas copias hacen referencia al mismo índice de página original. Reordenar cualquiera de las copias funciona de forma independiente.
- Para operaciones masivas con varios archivos o flujos de trabajo más avanzados, considera usar en su lugar la [Multiherramienta PDF](./pdf-multi-tool).
## Herramientas relacionadas
- [Fusionar PDF](./merge-pdf)
- [Eliminar Páginas](./delete-pages)
- [Multiherramienta PDF](./pdf-multi-tool)
- [Invertir Páginas](./reverse-pages)
docs/es/tools/page-dimensions.md
+53
View File
@@ -0,0 +1,53 @@
---
title: Dimensiones de página
description: Analiza tamaños, orientaciones, proporciones y rotación de las páginas de un PDF. Detecta documentos con tamaños mixtos y exporta los datos a CSV.
---
# Dimensiones de página
Una herramienta de diagnóstico que lee cada página de tu PDF y muestra sus dimensiones exactas, orientación, nombre de tamaño estándar, proporción, área y rotación. Es útil para detectar páginas de distintos tamaños antes de imprimir o para documentar las propiedades de un PDF que recibiste.
## Cómo funciona
1. Sube un archivo PDF. El análisis empieza automáticamente, sin botón que pulsar.
2. Un panel de resumen muestra el total de páginas, la cantidad de tamaños de página distintos y si el documento tiene tamaños mixtos.
3. Explora la tabla completa de resultados con los detalles de cada página.
4. Cambia las unidades de visualización entre puntos, pulgadas, milímetros o píxeles.
5. Haz clic en **Exportar a CSV** para guardar los datos.
## Campos mostrados
| Columna | Descripción |
| --------------- | ------------------------------------------------------- |
| N.º de página | Número de página secuencial |
| Dimensiones | Ancho x Alto en la unidad seleccionada |
| Tamaño estándar | Nombre coincidente (A4, Letter, etc.) o "Personalizado" |
| Orientación | Vertical u horizontal |
| Proporción | Relación ancho/alto como número decimal |
| Área | Área de la página en la unidad seleccionada al cuadrado |
| Rotación | Rotación de la página en grados |
## Características
- Detección automática de tamaños de papel estándar (A3, A4, A5, Letter, Legal, Tabloid y más)
- Aviso de documento con tamaños mixtos, con el desglose de qué tamaños aparecen y cuántas páginas usa cada uno
- Conversión de unidades entre puntos, pulgadas, milímetros y píxeles (a 96 PPI)
- Exportación a CSV para usar en hojas de cálculo o sistemas de documentación
## Casos de uso
- Verificar que todas las páginas son A4 antes de enviar un documento a una imprenta
- Diagnosticar por qué un PDF fusionado se imprime con márgenes inesperados en ciertas páginas
- Documentar el diseño de páginas de un archivo PDF grande para registros de metadatos
- Identificar páginas rotadas que necesitan corrección
## Consejos
- Si el resumen muestra "Tamaños mixtos", usa la herramienta Fijar Tamaño de Página para estandarizar antes de imprimir.
- El campo de rotación ayuda a identificar páginas que se ven correctamente pero tienen un atributo de rotación distinto de cero, lo que puede causar problemas en algunos flujos de trabajo.
## Herramientas relacionadas
- [Fijar Tamaño de Página](./fix-page-size): estandariza las páginas tras identificar tamaños mixtos
- [Comprimir PDF](./compress-pdf): optimiza el PDF después de corregir los problemas de página
- [Rotar PDF](./rotate-pdf): corrige las páginas rotadas
docs/es/tools/page-numbers.md
+48
View File
@@ -0,0 +1,48 @@
---
title: Números de página
description: Agrega números de página personalizables en cualquier posición de las páginas de tu PDF, con fuente, tamaño y color configurables.
---
# Números de página
Agrega números de página visibles a todas las páginas de tu PDF. Tú eliges la posición, el formato, el tamaño de fuente y el color, y la herramienta se encarga del resto.
## Cómo funciona
1. Sube tu archivo PDF.
2. Configura los ajustes de numeración en el panel de opciones que aparece.
3. Haz clic en **Agregar números de página** para procesar.
4. El PDF numerado se descarga automáticamente.
## Opciones
- **Posición**: elige dónde aparecen los números de página: abajo al centro, abajo a la izquierda, abajo a la derecha, arriba al centro, arriba a la izquierda o arriba a la derecha.
- **Formato**: elige entre numeración simple (1, 2, 3...) o el formato "página X de Y" (1 / 5, 2 / 5...).
- **Tamaño de fuente**: define el tamaño del texto del número de página. Por defecto es 12.
- **Color**: elige cualquier color para el texto del número de página con el selector de color.
## Características
- Seis opciones de posición que cubren todas las esquinas y las posiciones centrales
- Dos formatos de numeración: secuencial simple o "página X de Y"
- Tamaño de fuente personalizable de 6 a 72 puntos
- Selector de color completo para el color del texto
- Manejo automático de márgenes que mantiene los números dentro de zonas seguras sin importar el tamaño de la página
## Casos de uso
- Preparar documentos para imprimir que necesitan referencias de página visibles
- Agregar números de página a un PDF fusionado creado a partir de varios archivos de origen
- Numerar los folletos de una presentación antes de distribuirlos
- Agregar numeración secuencial a documentos legales o contratos
## Consejos
- El formato "página X de Y" es útil para documentos en los que los lectores necesitan saber la extensión total, como propuestas o informes.
- Si necesitas distintos estilos de numeración para diferentes secciones (como números romanos para las páginas preliminares), usa en su lugar la herramienta [Agregar etiquetas de página](./add-page-labels).
## Herramientas relacionadas
- [Agregar etiquetas de página](./add-page-labels)
- [Numeración Bates](./bates-numbering)
- [Encabezado y Pie de Página](./header-footer)
docs/es/tools/pdf-booklet.md
+43
View File
@@ -0,0 +1,43 @@
---
title: Folleto PDF
description: Reorganiza las páginas de un PDF en orden de folleto (grapado al caballete) para doblarlo y engraparlo como folleto físico.
---
# Folleto PDF
Reorganiza las páginas de un PDF en el orden de imposición de folleto. Al imprimirlo a doble cara y doblarlo por la mitad, las páginas quedan en la secuencia de lectura correcta. Es el diseño que se usa en folletos grapados al caballete y zines.
## Cómo funciona
1. Sube un archivo PDF.
2. Configura los ajustes del folleto: tamaño y orientación de la página de salida.
3. Haz clic en **Generar vista previa** para ver cómo se organizarán las páginas en cada hoja.
4. Revisa la vista previa, que muestra cada hoja física con las páginas asignadas al anverso y al reverso.
5. Haz clic en **Descargar** para guardar el PDF con la imposición de folleto.
## Características
- Reordenación automática de páginas para encuadernación grapada al caballete
- Tamaño de página de salida configurable
- Vista previa visual del diseño del folleto antes de descargar
- Maneja cantidades impares de páginas insertando páginas en blanco donde hace falta
- Escala las páginas de origen para ajustarlas al tamaño de hoja del folleto
## Casos de uso
- Crear folletos o zines imprimibles a partir de un PDF normal
- Preparar programas de conferencias o guías de eventos para imprimirlos en casa o en la oficina
- Hacer tarjetas de felicitación plegadas o catálogos pequeños
- Producir cuadernillos o colecciones de poesía para encuadernar a mano
## Consejos
- Lo ideal es que la cantidad de páginas de tu PDF de origen sea múltiplo de 4 para un folleto limpio. Si no lo es, se agregan páginas en blanco automáticamente para completar la última hoja.
- Imprime el resultado a doble cara con la opción "voltear por el borde corto" de tu impresora, luego dobla todas las hojas juntas y engrápalas en el lomo.
- Si solo quieres colocar varias páginas en una hoja sin el orden de folleto, usa en su lugar [N-Up PDF](./n-up-pdf).
## Herramientas relacionadas
- [N-Up PDF](./n-up-pdf)
- [Rotar PDF](./rotate-pdf)
- [Agregar Página en Blanco](./add-blank-page)
docs/es/tools/pdf-layers.md
+46
View File
@@ -0,0 +1,46 @@
---
title: Capas PDF (OCG)
description: Visualiza, activa o desactiva, agrega y elimina capas de Optional Content Group (OCG) en un documento PDF.
---
# Capas PDF (OCG)
Gestiona los Optional Content Groups (OCG), conocidos habitualmente como "capas", dentro de un PDF. Puedes activar o desactivar la visibilidad de las capas, agregar capas nuevas (incluidas capas hijas anidadas), eliminar capas y guardar el PDF modificado.
## Cómo funciona
1. Sube un archivo PDF.
2. Haz clic en el botón de procesar para cargar el documento con el motor PyMuPDF.
3. La herramienta muestra todas las capas existentes con su estado de visibilidad, su estado de bloqueo y su jerarquía de anidación.
4. Marca o desmarca las casillas para mostrar u ocultar capas. Las capas bloqueadas no se pueden cambiar.
5. Agrega capas nuevas de nivel superior escribiendo un nombre y haciendo clic en el botón de agregar, o agrega capas hijas bajo una capa padre existente.
6. Elimina las capas que ya no necesites.
7. Haz clic en **Guardar** para descargar el PDF modificado con los cambios de capas aplicados.
## Características
- Muestra la jerarquía de capas con la sangría adecuada para las capas anidadas
- Activa o desactiva la visibilidad de las capas
- El indicador de capa bloqueada evita cambios accidentales
- Agrega capas de nivel superior o capas hijas con nombres personalizados
- Elimina capas individuales
- Guarda todos los cambios en un archivo PDF nuevo
## Casos de uso
- Activar o desactivar la visibilidad de las capas de anotaciones en planos de arquitectura o ingeniería
- Agregar nuevas capas de anotación a un documento de diseño con varias capas
- Eliminar capas obsoletas de una plantilla antes de distribuirla
- Inspeccionar qué capas existen en un PDF complejo recibido de terceros
## Consejos
- Si el PDF no tiene capas, la herramienta muestra un estado vacío con una invitación a agregar una. No todos los PDF usan capas OCG: son más comunes en exportaciones de CAD y archivos de diseño.
- Las capas hijas aparecen con sangría bajo su capa padre. Puedes anidar capas a cualquier profundidad.
- Las capas bloqueadas se muestran con un icono de candado y sus casillas están desactivadas. Estos bloqueos los establece el creador del PDF.
## Herramientas relacionadas
- [Ver Metadatos](./view-metadata)
- [Editar Metadatos](./edit-metadata)
- [Duplicar y Organizar](./organize-pdf)
docs/es/tools/pdf-multi-tool.md
+52
View File
@@ -0,0 +1,52 @@
---
title: Multiherramienta PDF
description: Un gestor de páginas todo en uno para fusionar, dividir, rotar, duplicar, eliminar y reordenar páginas de PDF.
---
# Multiherramienta PDF
Un espacio de trabajo unificado para cualquier operación a nivel de página en PDF. Sube uno o más PDF y trabaja con todas sus páginas en una única cuadrícula visual. Rota, reordena, duplica, elimina, inserta nuevos PDF, agrega páginas en blanco y divide el resultado, todo sin salir de la herramienta.
## Cómo funciona
1. Haz clic en **Subir PDFs** o arrastra archivos al área de carga. Se admiten varios archivos.
2. Todas las páginas de cada archivo subido aparecen en una cuadrícula desplazable con miniaturas.
3. Usa la barra de herramientas o los botones de acción de cada página para manipular las páginas.
4. Selecciona páginas con la casilla de cada tarjeta y luego aplica operaciones masivas.
5. Marca puntos de división con el icono de tijeras para dividir la salida en archivos separados.
6. Haz clic en **Exportar PDF** para descargar el resultado final. Si hay marcadores de división, la salida es un ZIP con varios PDF.
## Características
- **Fusionar**: sube varios PDF y se combinan automáticamente en un solo espacio de trabajo
- **Reordenar**: arrastra y suelta las tarjetas de página para cambiar la secuencia
- **Rotar**: rotación por página o masiva en incrementos de 90 grados (izquierda o derecha)
- **Duplicar**: clona cualquier página con un clic
- **Eliminar**: quita páginas individuales o elimina en bloque las seleccionadas
- **Insertar PDF**: agrega un nuevo PDF después de cualquier página concreta
- **Agregar página en blanco**: añade una página A4 en blanco al final
- **Dividir**: coloca marcadores de división entre páginas y luego exporta un ZIP de PDF separados
- **Seleccionar todo / Deseleccionar todo**: selección rápida para operaciones masivas
- **Deshacer / Rehacer**: historial completo de deshacer y rehacer para cada operación
- **Descargar selección**: exporta solo las páginas seleccionadas como un PDF independiente
- Repara automáticamente los PDF dañados antes de cargarlos
## Casos de uso
- Crear un documento personalizado con páginas de varios PDF de origen
- Limpiar un documento escaneado eliminando páginas en blanco, rotando escaneos de lado y reordenando secciones
- Dividir un PDF grande en los límites de los capítulos con marcadores de división visuales
- Edición rápida a nivel de página sin necesidad de un editor de PDF completo
## Consejos
- El sistema de deshacer y rehacer registra cada operación. Úsalo con libertad: no puedes perder tu trabajo por accidente.
- Los marcadores de división aparecen como líneas azules discontinuas entre páginas. Colócalos visualmente donde quieras dividir el documento y luego exporta para obtener un ZIP.
- Para tareas sencillas de fusión o división, las herramientas dedicadas [Fusionar PDF](./merge-pdf) o [Dividir PDF](./split-pdf) pueden ser más rápidas. La Multiherramienta destaca cuando necesitas varias operaciones en una sola sesión.
## Herramientas relacionadas
- [Fusionar PDF](./merge-pdf)
- [Dividir PDF](./split-pdf)
- [Duplicar y Organizar](./organize-pdf)
- [Rotar PDF](./rotate-pdf)
docs/es/tools/pdf-to-bmp.md
+40
View File
@@ -0,0 +1,40 @@
---
title: PDF a BMP
description: Convierte páginas de PDF a imágenes BMP sin comprimir. Útil para sistemas heredados y flujos de impresión que requieren mapas de bits.
---
# PDF a BMP
Convierte cada página de un PDF en una imagen BMP (mapa de bits). BMP es un formato sin comprimir, por lo que el resultado es exacto píxel a píxel y sin pérdida de calidad, pero los archivos son grandes.
## Cómo funciona
1. Sube un PDF haciendo clic en la zona de carga o arrastrando un archivo hasta ella.
2. Haz clic en **Convertir** para procesar el archivo.
3. Un único archivo `.bmp` o un archivo ZIP se descarga automáticamente.
## Opciones
Esta herramienta no tiene opciones configurables. Las páginas se renderizan a una escala fija de 2x, lo que produce imágenes con aproximadamente el doble de las dimensiones nativas de la página del PDF.
## Formato de salida
- **Una página**: `filename.bmp`
- **Varias páginas**: `filename_bmps.zip` con `page_1.bmp`, `page_2.bmp`, etc.
## Casos de uso
- Enviar páginas de PDF a sistemas o equipos heredados que solo aceptan BMP.
- Preparar imágenes sin comprimir para flujos de impresión específicos.
- Usar la salida en mapa de bits como entrada de herramientas de procesamiento de imágenes que requieren datos de píxeles sin procesar.
## Consejos
- Los archivos BMP son muy grandes porque almacenan los píxeles sin comprimir. Para la mayoría de los usos, [PDF a PNG](./pdf-to-png) ofrece calidad sin pérdida con archivos mucho más pequeños.
- Si tu sistema de destino acepta PNG o TIFF, prefiere esos formatos para ahorrar espacio en disco.
## Herramientas relacionadas
- [PDF a PNG](./pdf-to-png)
- [PDF a TIFF](./pdf-to-tiff)
- [PDF a JPG](./pdf-to-jpg)
docs/es/tools/pdf-to-cbz.md
+77
View File
@@ -0,0 +1,77 @@
---
title: PDF a CBZ
description: Convierte un PDF en un archivo CBZ (Comic Book Archive) para lectores de cómics como Komga, Kavita, CDisplayEx y Calibre.
---
# PDF a CBZ
Convierte un PDF en un archivo CBZ (Comic Book ZIP), el formato estándar de cómics y manga digitales. Cada página del PDF se convierte en una imagen dentro del archivo. La herramienta genera metadatos en tres formatos para lograr la máxima compatibilidad: ComicInfo.xml, metadata.opf y ComicBookInfo JSON.
## Cómo funciona
1. Sube un PDF haciendo clic en la zona de carga o arrastrando un archivo hasta ella.
2. Elige el formato de imagen, la calidad, la escala y los metadatos opcionales.
3. Haz clic en **Convertir** para generar el archivo CBZ.
4. El archivo `.cbz` se descarga automáticamente.
## Opciones
| Opción | Valores | Predeterminado | Descripción |
| ----------------- | --------------- | -------------- | ------------------------------------------------------------------------------------------------------- |
| Formato de imagen | JPEG, PNG, WebP | JPEG | JPEG para cómics a color, PNG para manga en blanco y negro sin pérdida, WebP para la mejor compresión. |
| Calidad | 50–100% | 85% | Controla la compresión de JPEG/WebP. Se oculta con PNG (siempre sin pérdida). |
| Escala | 1.0x–4.0x | 2.0x | Una escala mayor produce imágenes más nítidas para pantallas de alta resolución. |
| Escala de grises | Sí/No | No | Convierte las páginas a escala de grises. Reduce el tamaño del archivo con contenido en blanco y negro. |
| Modo manga | Sí/No | No | Establece en los metadatos la dirección de lectura de derecha a izquierda. |
| Incluir metadatos | Sí/No | Sí | Incrusta ComicInfo.xml, metadata.opf y ComicBookInfo JSON. |
## Campos de metadatos
Cuando los metadatos están activados, puedes rellenar:
- **Título**: se detecta automáticamente a partir del nombre del archivo PDF.
- **Serie**: el nombre de la serie (p. ej., "Naruto").
- **Número (#)**: número del ejemplar dentro de la serie.
- **Volumen (Vol.)**: número de volumen.
- **Autor(es)**: nombre del guionista o creador.
- **Editorial**: empresa editora.
- **Etiquetas / Género**: etiquetas separadas por comas (p. ej., "Acción, Aventura").
- **Año de publicación**: año de publicación (1900–2100).
- **Valoración**: valoración de la comunidad de 0 a 5.
## Compatibilidad de metadatos
La herramienta escribe los metadatos en tres formatos para que cualquier lector pueda encontrarlos:
| Formato | Ubicación | Compatible con |
| ------------------ | --------------------------- | ------------------------------------------- |
| ComicInfo.xml | Archivo dentro del ZIP | Komga, Kavita, CDisplayEx, Mylar, ComicRack |
| metadata.opf | Archivo dentro del ZIP | Calibre |
| ComicBookInfo JSON | Campo de comentario del ZIP | Calibre (alternativa) |
## Formato de salida
- `filename.cbz`: un archivo ZIP con las imágenes de página numeradas y los archivos de metadatos.
Las imágenes de página se nombran con números rellenados con ceros (`01.jpg`, `02.jpg`, etc.) para que los lectores las muestren en el orden correcto.
## Casos de uso
- Convertir PDF de manga o cómics para usarlos con lectores de cómics.
- Crear una biblioteca de cómics digital en Komga, Kavita o Calibre.
- Convertir cómics escaneados a un formato apto para lectores.
- Compartir cómics en un formato que conserva la dirección de lectura y los metadatos.
## Consejos
- Usa **JPEG** para cómics a color y **PNG** para manga en blanco y negro: PNG comprime muy bien el contenido en blanco y negro.
- Activa **Escala de grises** en el manga para reducir de forma notable el tamaño del archivo.
- Rellena los campos **Serie** y **Número** para que los gestores de biblioteca (Komga, Calibre) organicen tu colección automáticamente.
- **WebP** ofrece la mejor compresión, pero algunos lectores de cómics antiguos pueden no admitirlo.
## Herramientas relacionadas
- [PDF a JPG](./pdf-to-jpg)
- [PDF a PNG](./pdf-to-png)
- [PDF a TIFF](./pdf-to-tiff)
- [Extraer imágenes](./extract-images)
docs/es/tools/pdf-to-csv.md
+44
View File
@@ -0,0 +1,44 @@
---
title: PDF a CSV
description: Extrae tablas de documentos PDF y expórtalas como un único archivo CSV. Admite PDF de varias páginas con detección automática de tablas.
---
# PDF a CSV
Extrae tablas de un PDF y las exporta como un archivo CSV. La herramienta analiza cada página en busca de datos tabulares con el motor de detección de tablas de PyMuPDF y escribe todas las filas encontradas en una única salida separada por comas.
## Cómo funciona
1. Sube un PDF haciendo clic en la zona de carga o arrastrando un archivo hasta ella.
2. Haz clic en **Convertir** para iniciar la extracción de tablas.
3. La herramienta analiza cada página e identifica las tablas automáticamente.
4. Se descarga un archivo `.csv` con todos los datos de las tablas extraídas.
Las tablas de páginas distintas se separan con filas en blanco en la salida. Las celdas que contienen comas, comillas o saltos de línea se escapan correctamente según RFC 4180.
## Opciones
Esta herramienta no tiene opciones configurables. Todas las tablas encontradas en el documento se extraen y se combinan en un único CSV.
## Formato de salida
- Un único archivo `filename.csv` con todas las tablas detectadas.
## Casos de uso
- Pasar datos financieros de extractos bancarios o facturas en PDF a una hoja de cálculo.
- Extraer tablas de precios de presupuestos de proveedores para compararlas.
- Convertir datos tabulares de investigaciones en PDF a un formato adecuado para herramientas de análisis.
- Migrar datos de informes PDF antiguos a bases de datos.
## Consejos
- Si no se encuentran tablas, la herramienta muestra el mensaje "No se encontraron tablas". Normalmente significa que el PDF usa un diseño de texto que parece tabular pero no está estructurado como una tabla real.
- Para tener más control sobre cada tabla, usa [Extraer Tablas de PDF](./extract-tables), que permite elegir entre salida en CSV, JSON y Markdown.
- Si necesitas los datos en formato Excel con hojas separadas por tabla, usa [PDF a Excel](./pdf-to-excel).
## Herramientas relacionadas
- [PDF a Excel](./pdf-to-excel)
- [Extraer Tablas de PDF](./extract-tables)
- [PDF a Texto](./pdf-to-text)
docs/es/tools/pdf-to-excel.md
+44
View File
@@ -0,0 +1,44 @@
---
title: PDF a Excel
description: Extrae tablas de documentos PDF a una hoja de cálculo de Excel. Cada tabla se guarda en su propia hoja con referencia a la página.
---
# PDF a Excel
Extrae tablas de un PDF y las guarda como una hoja de cálculo de Excel (`.xlsx`). Cada tabla detectada se coloca en su propia hoja, etiquetada con su número de tabla y la página de origen. Funciona con PyMuPDF para la detección de tablas y la biblioteca SheetJS para generar el archivo de Excel.
## Cómo funciona
1. Sube un PDF haciendo clic en la zona de carga o arrastrando un archivo hasta ella.
2. Haz clic en **Convertir** para iniciar la extracción de tablas.
3. La herramienta analiza cada página en busca de tablas y luego crea un libro de Excel.
4. Se descarga un archivo `.xlsx` con una hoja por tabla.
## Opciones
Esta herramienta no tiene opciones configurables. Todas las tablas detectadas se extraen automáticamente.
## Formato de salida
- Un único archivo `filename.xlsx`.
- **Una tabla**: una sola hoja llamada "Table".
- **Varias tablas**: hojas llamadas "Table 1 (Page 3)", "Table 2 (Page 5)", etc. Los nombres de hoja se truncan a 31 caracteres (el límite de Excel).
## Casos de uso
- Convertir informes financieros en PDF a hojas de cálculo editables para seguir analizándolos.
- Extraer tablas de inventario o pedidos de PDF de proveedores.
- Pasar datos estructurados de formularios o catálogos en PDF a Excel para ordenarlos y filtrarlos.
- Archivar datos tabulares de PDF en un formato con el que puedan trabajar compañeros sin perfil técnico.
## Consejos
- Si la herramienta indica "No se encontraron tablas", es probable que el PDF use un texto de flujo libre en lugar de tablas estructuradas. Prueba [PDF a Texto](./pdf-to-text) para obtener el contenido sin procesar.
- Para un formato plano más simple, usa [PDF a CSV](./pdf-to-csv). Para descargas por tabla en varios formatos, usa [Extraer Tablas de PDF](./extract-tables).
- Revisa los nombres de las hojas para saber de qué página procede cada tabla.
## Herramientas relacionadas
- [PDF a CSV](./pdf-to-csv)
- [Extraer Tablas de PDF](./extract-tables)
- [PDF a Texto](./pdf-to-text)
docs/es/tools/pdf-to-greyscale.md
+42
View File
@@ -0,0 +1,42 @@
---
title: PDF a escala de grises
description: Convierte un PDF a color en una versión en escala de grises (blanco y negro). Genera un PDF nuevo sin color en ninguna página.
---
# PDF a escala de grises
Convierte un PDF a color en una versión en escala de grises. Cada página se renderiza, se desatura y se vuelve a incrustar como imagen JPEG en un PDF nuevo. El resultado conserva las dimensiones originales de la página.
## Cómo funciona
1. Sube un PDF haciendo clic en la zona de carga o arrastrando un archivo hasta ella.
2. Haz clic en **Convertir** para procesar el archivo.
3. Se descarga un nuevo `greyscale.pdf` con todas las páginas convertidas a blanco y negro.
Internamente, cada página se renderiza a escala 2x, los datos de píxeles pasan por un filtro de escala de grises y luego se recodifican como JPEG con calidad del 90% y se colocan en un documento PDF nuevo.
## Opciones
Esta herramienta no tiene opciones configurables. La conversión a escala de grises usa una fórmula de luminancia estándar y la calidad JPEG está fijada en el 90%.
## Formato de salida
- Un único archivo `greyscale.pdf` con todas las páginas como imágenes JPEG en escala de grises.
## Casos de uso
- Preparar documentos para imprimir en blanco y negro y ahorrar en tinta de color.
- Cumplir requisitos de presentación de trámites legales o gubernamentales que exigen escala de grises.
- Reducir el tamaño de PDF con mucho color (las imágenes JPEG en escala de grises pesan menos que las de color).
- Crear un estilo visual coherente en documentos con páginas a color y en blanco y negro.
## Consejos
- Como cada página se rasteriza y se vuelve a incrustar como JPEG, el resultado está basado en imágenes. El texto del PDF original ya no se podrá seleccionar ni buscar. Si después necesitas texto con búsqueda, pasa el resultado por la herramienta OCR.
- Para tener más control sobre los ajustes de color (brillo, contraste, saturación), mira la herramienta Ajustar colores o el nodo de escala de grises del [Constructor de flujos de trabajo PDF](./pdf-workflow).
## Herramientas relacionadas
- [PDF a JPG](./pdf-to-jpg)
- [PDF a PNG](./pdf-to-png)
- [Constructor de flujos de trabajo PDF](./pdf-workflow)
docs/es/tools/pdf-to-jpg.md
+46
View File
@@ -0,0 +1,46 @@
---
title: PDF a JPG
description: Convierte páginas de PDF a imágenes JPG con calidad ajustable. Los PDF de una página se descargan directamente; los de varias páginas se exportan como ZIP.
---
# PDF a JPG
Convierte cada página de un PDF en una imagen JPG. Los documentos de una sola página se descargan como un archivo `.jpg` independiente. Los PDF de varias páginas generan un archivo ZIP con un JPG por página.
## Cómo funciona
1. Sube un PDF haciendo clic en la zona de carga o arrastrando un archivo hasta ella. La herramienta muestra el nombre del archivo, su tamaño y el número de páginas.
2. Ajusta el control deslizante de **Calidad** para controlar la compresión del JPG.
3. Haz clic en **Convertir** para iniciar el procesamiento.
4. El resultado se descarga automáticamente: un único JPG para PDF de una página o un archivo ZIP para documentos de varias páginas.
## Opciones
- **Calidad**: un control deslizante de 0% a 100% (por defecto 90%). Los valores altos producen imágenes más nítidas y archivos más grandes. Los valores bajos comprimen de forma más agresiva.
Las páginas se renderizan internamente a escala 2x, así que la resolución de salida es el doble de las dimensiones de la página del PDF. Una página estándar tamaño carta produce una imagen de aproximadamente 1.224 x 1.584 píxeles.
## Formato de salida
- **Una página**: `filename.jpg`
- **Varias páginas**: `filename_jpgs.zip` con `page_1.jpg`, `page_2.jpg`, etc.
## Casos de uso
- Generar miniaturas de vista previa para un sistema de gestión documental.
- Compartir una página de un informe en un chat o correo que no admite PDF.
- Crear recursos de imagen a partir de diagramas o ilustraciones en PDF.
- Archivar documentos escaneados como imágenes individuales.
## Consejos
- Para una salida sin pérdida, usa [PDF a PNG](./pdf-to-png).
- Un ajuste de calidad de 80-90% logra un buen equilibrio entre tamaño de archivo y fidelidad visual.
- Si necesitas un formato específico por página, considera el [Constructor de flujos de trabajo PDF](./pdf-workflow), que tiene un nodo de salida de PDF a imágenes.
## Herramientas relacionadas
- [PDF a PNG](./pdf-to-png)
- [PDF a WebP](./pdf-to-webp)
- [PDF a BMP](./pdf-to-bmp)
- [PDF a TIFF](./pdf-to-tiff)
docs/es/tools/pdf-to-json.md
+45
View File
@@ -0,0 +1,45 @@
---
title: PDF a JSON
description: Convierte archivos PDF a formato JSON estructurado con CPDF. Exporta la estructura interna del PDF como datos JSON legibles por máquina.
---
# PDF a JSON
Convierte uno o más archivos PDF a formato JSON. La herramienta usa CPDF (Coherent PDF) para serializar la estructura interna de cada PDF en una representación JSON legible por máquina. El resultado siempre se entrega como un archivo ZIP.
## Cómo funciona
1. Selecciona uno o más archivos PDF con el selector de archivos.
2. Haz clic en **Convertir** para iniciar el procesamiento. La conversión se ejecuta en un web worker en segundo plano.
3. Se descarga un archivo ZIP con un archivo JSON por cada PDF de entrada.
La barra de estado muestra el progreso de las etapas de conversión y de creación del ZIP.
## Opciones
Esta herramienta no tiene opciones configurables. Cada PDF se convierte a su representación JSON completa.
## Formato de salida
- Un archivo `pdfs-to-json.zip` con `filename.json` por cada PDF de entrada.
La salida JSON representa la estructura interna de objetos del PDF, incluidos árboles de páginas, referencias de fuentes, metadatos y flujos de contenido.
## Casos de uso
- Inspeccionar la estructura interna de un PDF para depuración o validación.
- Extraer metadatos estructurados y propiedades de página mediante programación.
- Alimentar flujos de procesamiento personalizados con datos de la estructura del PDF.
- Auditar documentos PDF para verificar su cumplimiento analizando sus árboles de objetos.
## Consejos
- Esta herramienta devuelve la estructura de objetos del PDF sin procesar, no el texto extraído. Si necesitas el texto de las páginas en formato JSON, usa en su lugar [Preparar PDF para IA](./prepare-pdf-for-ai).
- Para extraer texto sin formato, [PDF a Texto](./pdf-to-text) es más directo.
- Los PDF grandes con estructuras complejas producen archivos JSON muy grandes.
## Herramientas relacionadas
- [PDF a Texto](./pdf-to-text)
- [Preparar PDF para IA](./prepare-pdf-for-ai)
- [Extraer Tablas de PDF](./extract-tables)
docs/es/tools/pdf-to-markdown.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF a Markdown
description: Convierte documentos PDF a formato Markdown con extracción opcional de imágenes. Admite la conversión por lotes de varios archivos.
---
# PDF a Markdown
Convierte archivos PDF a formato Markdown (`.md`) conservando encabezados, párrafos, listas y el formato básico. Opcionalmente extrae e incluye las imágenes incrustadas. Admite conversión individual y por lotes. Funciona con PyMuPDF.
## Cómo funciona
1. Sube uno o más PDF haciendo clic en la zona de carga o arrastrando archivos hasta ella.
2. Opcionalmente, activa **Incluir imágenes** para incrustar las imágenes extraídas en la salida Markdown.
3. Haz clic en **Convertir** para iniciar el procesamiento.
4. Un solo archivo se descarga como `filename.md`. Varios archivos generan un `markdown-files.zip`.
## Opciones
- **Incluir imágenes**: si está marcada, las imágenes incrustadas del PDF se extraen y se referencian en la salida Markdown. Si no está marcada, solo se convierte el contenido de texto.
## Formato de salida
- **Un archivo**: `filename.md`
- **Varios archivos**: `markdown-files.zip` con un `.md` por cada PDF de entrada.
## Casos de uso
- Convertir documentación en PDF a Markdown para un generador de sitios estáticos como VitePress, Hugo o Jekyll.
- Convertir artículos de investigación en PDF a Markdown editable para aplicaciones de notas como Obsidian.
- Migrar bases de conocimiento antiguas en PDF a un formato de texto compatible con Git.
- Extraer contenido estructurado de ebooks en PDF para darles otro formato.
## Consejos
- La opción Incluir imágenes es útil cuando el PDF contiene diagramas o figuras esenciales para el contenido. Desactívala en documentos con mucho texto para mantener limpia la salida.
- Los diseños complejos con barras laterales, notas al pie o texto en varias columnas pueden producir un Markdown imperfecto. Revisa y ajusta el resultado según haga falta.
- Para texto sin procesar y sin ningún formato, usa en su lugar [PDF a Texto](./pdf-to-text).
## Herramientas relacionadas
- [PDF a Texto](./pdf-to-text)
- [PDF a Word](./pdf-to-word)
- [Preparar PDF para IA](./prepare-pdf-for-ai)
docs/es/tools/pdf-to-pdfa.md
+50
View File
@@ -0,0 +1,50 @@
---
title: PDF a PDF/A
description: Convierte PDF estándar al formato PDF/A para archivado a largo plazo. Admite los niveles de conformidad PDF/A-1b, PDF/A-2b y PDF/A-3b.
---
# PDF a PDF/A
PDF/A es un subconjunto de PDF normalizado por ISO y pensado para la conservación digital a largo plazo. Esta herramienta convierte tus PDF estándar en documentos conformes con PDF/A usando Ghostscript, que se ejecuta directamente en tu navegador.
## Cómo funciona
1. Sube uno o más archivos PDF.
2. Selecciona una **versión de PDF/A** en el menú desplegable.
3. Opcionalmente, activa **Aplanar PDF antes** para archivos complejos que fallan en la conversión normal.
4. Haz clic en **Convertir a PDF/A**. Varios archivos generan un archivo ZIP.
## Versiones de PDF/A
| Versión | Restricciones | Ideal para |
| ------------ | -------------------------------------------------- | ------------------------------------------------------ |
| **PDF/A-1b** | La más estricta. Sin transparencias ni capas. | Máxima compatibilidad con sistemas de archivo antiguos |
| **PDF/A-2b** | Permite transparencias y JPEG2000. | Archivado de uso general (recomendada) |
| **PDF/A-3b** | Permite adjuntos incrustados de cualquier formato. | Archivar documentos con archivos de datos de origen |
PDF/A-2b está seleccionada por defecto y sirve para la gran mayoría de las necesidades de archivado.
## Opción de aplanado previo
Algunos PDF contienen características que impiden una conversión limpia a PDF/A: codificaciones de fuente poco comunes, pilas de transparencia complejas o estructuras internas dañadas. Activar **Aplanar PDF antes** rasteriza el PDF a 300 DPI antes de la conversión, lo que garantiza el cumplimiento a costa de que el texto deje de ser seleccionable. Úsala como alternativa cuando la conversión estándar produzca errores.
El aplanado previo requiere el motor PyMuPDF WASM.
## Casos de uso
- Cumplir requisitos de archivo gubernamentales o legales (muchas jurisdicciones exigen PDF/A en los escritos judiciales)
- Enviar documentos a repositorios institucionales o bibliotecas digitales
- Conservar registros empresariales cuando el software original puede no existir dentro de diez años
- Preparar facturas para estándares de facturación electrónica que exigen PDF/A-3b con adjuntos XML
## Consejos
- Prueba primero la conversión sin aplanado previo. Actívalo solo si obtienes un error.
- PDF/A incrusta todas las fuentes, por lo que los archivos de salida suelen ser más grandes que los originales.
- Valida el resultado con un validador de PDF/A específico si tu flujo de trabajo exige un cumplimiento estricto.
## Herramientas relacionadas
- [Comprimir PDF](./compress-pdf): reduce el tamaño del archivo tras la conversión
- [Aplanar PDF](./flatten-pdf): aplana los formularios antes de convertir a PDF/A
- [Eliminar Metadatos](./remove-metadata): quita los metadatos antes de archivar
docs/es/tools/pdf-to-png.md
+42
View File
@@ -0,0 +1,42 @@
---
title: PDF a PNG
description: Convierte páginas de PDF a imágenes PNG sin pérdida con escala ajustable. Ideal para capturas de alta calidad y fondos transparentes.
---
# PDF a PNG
Convierte cada página de un PDF en una imagen PNG. PNG usa compresión sin pérdida, por lo que el resultado conserva todos los detalles de la página original. Los PDF de una página se descargan como un archivo `.png`; los de varias páginas generan un ZIP.
## Cómo funciona
1. Sube un PDF haciendo clic en la zona de carga o arrastrando un archivo hasta ella.
2. Ajusta el control deslizante de **Escala** para controlar la resolución de salida.
3. Haz clic en **Convertir** para iniciar el procesamiento.
4. Un único PNG o un archivo ZIP se descarga automáticamente.
## Opciones
- **Escala**: va de 1.0x a 3.0x (por defecto 2.0x). A 2.0x, una página estándar tamaño carta se renderiza a unos 1.224 x 1.584 píxeles. Los valores de escala más altos producen imágenes más grandes y nítidas a costa del tamaño del archivo y del tiempo de procesamiento.
## Formato de salida
- **Una página**: `filename.png`
- **Varias páginas**: `filename_pngs.zip` con `page_1.png`, `page_2.png`, etc.
## Casos de uso
- Capturar páginas de PDF con alta fidelidad para presentaciones.
- Extraer gráficos o diagramas que necesitan bordes nítidos y sin artefactos de compresión.
- Preparar recursos para diseño web a partir de maquetas en PDF.
- Crear imágenes de página sin pérdida para el preprocesamiento de OCR.
## Consejos
- Los archivos PNG son bastante más grandes que los JPG. Si el tamaño del archivo importa más que la calidad perfecta, usa [PDF a JPG](./pdf-to-jpg) o [PDF a WebP](./pdf-to-webp).
- A escala 1.0x, la salida coincide con la resolución nativa del PDF. Sube a 3.0x para exportaciones con calidad de impresión.
## Herramientas relacionadas
- [PDF a JPG](./pdf-to-jpg)
- [PDF a WebP](./pdf-to-webp)
- [PDF a SVG](./pdf-to-svg)
docs/es/tools/pdf-to-svg.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF a SVG
description: Convierte páginas de PDF a gráficos vectoriales SVG escalables. Conserva texto y formas como trazados vectoriales para un escalado infinito.
---
# PDF a SVG
Convierte cada página de un PDF en un archivo SVG (Scalable Vector Graphics). A diferencia de los formatos rasterizados, SVG conserva los trazados vectoriales, el texto y las formas, por lo que el resultado se escala a cualquier tamaño sin pixelarse. Funciona con PyMuPDF.
## Cómo funciona
1. Sube uno o más PDF haciendo clic en la zona de carga o arrastrando archivos hasta ella. Puedes agregar varios archivos y gestionarlos individualmente.
2. Haz clic en **Convertir** para procesar todos los archivos subidos.
3. Las conversiones de un solo archivo con una sola página se descargan como un `.svg` independiente. El resto se descarga como archivo ZIP.
## Opciones
Esta herramienta no tiene opciones configurables. Cada página se convierte a SVG con la exportación vectorial nativa de PyMuPDF.
## Formato de salida
- **Un archivo, una página**: `filename.svg`
- **Un archivo, varias páginas**: `filename_svg.zip` con `page_1.svg`, `page_2.svg`, etc.
- **Varios archivos**: `pdf_to_svg.zip` con los archivos organizados por el nombre del documento de origen.
## Casos de uso
- Extraer diagramas vectoriales, gráficos o ilustraciones de informes en PDF para usarlos en páginas web.
- Editar el contenido de las páginas de un PDF en un editor vectorial como Inkscape o Illustrator.
- Incrustar vistas previas de página escalables en aplicaciones web adaptables.
- Extraer logotipos o gráficos de folletos en PDF conservando los bordes nítidos.
## Consejos
- SVG funciona mejor con PDF que contienen contenido vectorial. Los documentos escaneados o los PDF con muchas imágenes producirán archivos SVG grandes con datos rasterizados incrustados.
- Para una salida rasterizada de PDF con muchas imágenes, usa en su lugar [PDF a PNG](./pdf-to-png) o [PDF a JPG](./pdf-to-jpg).
- Esta herramienta admite la conversión por lotes: sube varios PDF a la vez para convertirlos todos en una sola ejecución.
## Herramientas relacionadas
- [PDF a PNG](./pdf-to-png)
- [PDF a JPG](./pdf-to-jpg)
- [PDF a Markdown](./pdf-to-markdown)
docs/es/tools/pdf-to-text.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF a texto
description: Extrae el texto sin formato de archivos PDF. Admite la extracción por lotes de varios PDF con salida en archivos TXT.
---
# PDF a texto
Extrae todo el contenido de texto de archivos PDF y lo guarda como archivos `.txt` de texto sin formato. Admite el procesamiento por lotes: sube varios PDF y extrae el texto de cada uno en una sola operación. Funciona con PyMuPDF.
## Cómo funciona
1. Sube uno o más PDF haciendo clic en la zona de carga o arrastrando archivos hasta ella. Gestiona tu lista de archivos con los botones Agregar más y Borrar.
2. Haz clic en **Extraer** para iniciar el procesamiento.
3. Un solo archivo se descarga como `filename.txt`. Varios archivos generan un archivo `pdf-to-text.zip`.
## Opciones
Esta herramienta no tiene opciones configurables. Todo el texto se extrae de cada página en orden de lectura.
## Formato de salida
- **Un archivo**: `filename.txt`
- **Varios archivos**: `pdf-to-text.zip` con un `.txt` por cada PDF de entrada.
## Casos de uso
- Extraer el texto principal de informes en PDF para indexarlo en búsquedas de texto completo.
- Convertir ebooks o artículos en PDF a texto sin formato para leerlos en dispositivos de tinta electrónica.
- Sacar texto de contratos o documentos legales para analizar palabras clave.
- Quitar el formato de los PDF para obtener texto limpio para scripts de procesamiento de datos.
- Preparar un corpus de texto a partir de archivos PDF para procesamiento de lenguaje natural.
## Consejos
- Los PDF escaneados (solo imagen) producirán archivos de texto vacíos porque no hay una capa de texto que extraer. Pasa primero los documentos escaneados por OCR.
- La salida conserva el orden de lectura según lo interpreta PyMuPDF, que por lo general sigue de izquierda a derecha y de arriba abajo. Los diseños de varias columnas pueden producir texto entremezclado.
- Para una salida estructurada con encabezados y formato, prueba [PDF a Markdown](./pdf-to-markdown). Para JSON estructurado listo para IA, usa [Preparar PDF para IA](./prepare-pdf-for-ai).
## Herramientas relacionadas
- [PDF a Markdown](./pdf-to-markdown)
- [Preparar PDF para IA](./prepare-pdf-for-ai)
- [PDF a Word](./pdf-to-word)
docs/es/tools/pdf-to-tiff.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF a TIFF
description: Convierte páginas de PDF a imágenes TIFF, muy usadas en impresión, fax y archivado. Recurre a PNG si falla la codificación.
---
# PDF a TIFF
Convierte cada página de un PDF en una imagen TIFF. TIFF es el formato estándar para producción de impresión, sistemas de fax y archivado de documentos. La herramienta usa compresión PackBits para codificar el TIFF y recurre a PNG si una página no se puede codificar.
## Cómo funciona
1. Sube un PDF haciendo clic en la zona de carga o arrastrando un archivo hasta ella.
2. Haz clic en **Convertir** para procesar el archivo.
3. Un único archivo TIFF o un archivo ZIP se descarga automáticamente.
## Opciones
Esta herramienta no tiene opciones configurables. Las páginas se renderizan a una escala fija de 2x.
## Formato de salida
- **Una página**: `filename.tiff`
- **Varias páginas**: `filename_tiffs.zip` con `page_1.tiff`, `page_2.tiff`, etc.
Si la codificación TIFF falla en una página concreta (por problemas de compresión), esa página se guarda como archivo `.png`. En ese caso, el ZIP contendrá una mezcla de archivos TIFF y PNG.
## Casos de uso
- Enviar documentos a organismos públicos o sistemas legales que exigen el formato TIFF.
- Preparar páginas para transmitirlas por fax mediante servicios de fax digital.
- Archivar documentos escaneados en un formato sin pérdida ampliamente compatible.
- Alimentar sistemas empresariales de gestión documental con las páginas.
## Consejos
- Los archivos TIFF son grandes. Si solo necesitas calidad sin pérdida para web o pantalla, [PDF a PNG](./pdf-to-png) es una mejor opción.
- Revisa el contenido del ZIP si algunas páginas necesitaron la alternativa PNG: quizá quieras convertirlas por separado.
## Herramientas relacionadas
- [PDF a PNG](./pdf-to-png)
- [PDF a BMP](./pdf-to-bmp)
- [PDF a JPG](./pdf-to-jpg)
docs/es/tools/pdf-to-webp.md
+43
View File
@@ -0,0 +1,43 @@
---
title: PDF a WebP
description: Convierte páginas de PDF a imágenes WebP con calidad ajustable. Archivos más pequeños que JPG con una calidad visual comparable.
---
# PDF a WebP
Convierte cada página de un PDF en una imagen WebP. WebP suele producir archivos entre un 25 y un 35% más pequeños que JPG con la misma calidad percibida, lo que lo convierte en una gran opción para la web.
## Cómo funciona
1. Sube un PDF haciendo clic en la zona de carga o arrastrando un archivo hasta ella.
2. Ajusta el control deslizante de **Calidad**.
3. Haz clic en **Convertir** para procesar el archivo.
4. Un único archivo `.webp` o un archivo ZIP se descarga automáticamente.
## Opciones
- **Calidad**: un control deslizante de 0% a 100% (por defecto 85%). Controla el nivel de compresión con pérdida. Los valores más altos conservan más detalle.
Las páginas se renderizan internamente a escala 2x, lo que produce imágenes con aproximadamente el doble de las dimensiones nativas del PDF.
## Formato de salida
- **Una página**: `filename.webp`
- **Varias páginas**: `filename_webps.zip` con `page_1.webp`, `page_2.webp`, etc.
## Casos de uso
- Preparar vistas previas de páginas para sitios web donde el ancho de banda importa.
- Generar versiones de imagen ligeras de volantes o folletos para redes sociales.
- Convertir por lotes documentos de varias páginas en un conjunto de imágenes optimizado para la web.
## Consejos
- WebP es compatible con todos los navegadores modernos. Para compatibilidad con sistemas antiguos, recurre a [PDF a JPG](./pdf-to-jpg).
- Una calidad de 80-85% suele ser indistinguible del original en pantalla y mantiene los archivos pequeños.
## Herramientas relacionadas
- [PDF a JPG](./pdf-to-jpg)
- [PDF a PNG](./pdf-to-png)
- [PDF a BMP](./pdf-to-bmp)
docs/es/tools/pdf-to-word.md
+42
View File
@@ -0,0 +1,42 @@
---
title: PDF a Word
description: Convierte archivos PDF a documentos de Word (DOCX) editables. Admite la conversión por lotes de varios PDF a la vez.
---
# PDF a Word
Convierte archivos PDF a documentos de Word (`.docx`) editables. La herramienta usa PyMuPDF para reconstruir el contenido del documento, conservando el texto, el formato básico y el diseño. Admite conversión individual y por lotes.
## Cómo funciona
1. Sube uno o más PDF haciendo clic en la zona de carga o arrastrando archivos hasta ella. Puedes agregar más archivos o quitar archivos concretos de la lista.
2. Haz clic en **Convertir** para iniciar el procesamiento.
3. Un solo archivo se descarga como `filename.docx`. Varios archivos se empaquetan en `converted-documents.zip`.
## Opciones
Esta herramienta no tiene opciones configurables. Cada PDF se convierte a DOCX con el motor de conversión integrado de PyMuPDF.
## Formato de salida
- **Un archivo**: `filename.docx`
- **Varios archivos**: `converted-documents.zip` con un `.docx` por cada PDF de entrada.
## Casos de uso
- Editar el texto de un PDF que recibiste y necesitas modificar.
- Convertir informes PDF archivados a un formato que los compañeros puedan editar en Microsoft Word o Google Docs.
- Pasar contenido de contratos o propuestas en PDF a Word para revisarlos con control de cambios.
- Migrar documentación antigua en PDF a un formato editable.
## Consejos
- Los diseños complejos con texto en varias columnas, formularios incrustados o muchos gráficos pueden no convertirse a la perfección. Revisa el resultado y ajusta el formato en tu procesador de texto.
- Los PDF escaneados (solo imagen) producirán archivos DOCX vacíos o casi vacíos. Pásalos primero por OCR para agregar una capa de texto.
- El modo por lotes es eficiente para convertir carpetas enteras de PDF: súbelos todos a la vez.
## Herramientas relacionadas
- [PDF a Texto](./pdf-to-text)
- [PDF a Markdown](./pdf-to-markdown)
- [Constructor de flujos de trabajo PDF](./pdf-workflow)
docs/es/tools/pdf-to-zip.md
+41
View File
@@ -0,0 +1,41 @@
---
title: PDFs a ZIP
description: Empaqueta varios archivos PDF en un único archivo ZIP para compartirlos y guardarlos fácilmente.
---
# PDFs a ZIP
Agrupa varios archivos PDF en un único archivo ZIP. Es una herramienta de empaquetado sencilla: no convierte, comprime ni modifica los PDF.
## Cómo funciona
1. Sube varios archivos PDF con la zona de carga.
2. Revisa la lista de archivos. Quita los que no quieras incluir.
3. Haz clic en el botón de procesar.
4. Un archivo ZIP con todos los PDF subidos se descarga de inmediato.
## Características
- Acepta cualquier cantidad de archivos PDF
- Permite quitar archivos individuales antes de crear el archivo comprimido
- Conserva los nombres de archivo originales dentro del ZIP
- No modifica el contenido de los PDF: los archivos se empaquetan tal cual
- Muestra el nombre y el tamaño de cada PDF subido
## Casos de uso
- Agrupar un conjunto de facturas o recibos para adjuntarlos a un correo
- Empaquetar entregables de un proyecto (varios informes en PDF) para su entrega
- Crear una única descarga para una colección de formularios o plantillas
- Archivar un lote de documentos en un solo archivo comprimido
## Consejos
- El archivo ZIP usa los nombres de archivo originales de los PDF. Si tienes archivos con el mismo nombre, renómbralos antes de subirlos para evitar conflictos.
- Esta herramienta no comprime los PDF en sí. Para reducir el tamaño, pásalos primero por Comprimir PDF y luego empaquétalos con esta herramienta.
## Herramientas relacionadas
- [Fusionar PDF](./merge-pdf)
- [Dividir PDF](./split-pdf)
- [Comprimir PDF](./compress-pdf)
docs/es/tools/pdf-workflow.md
+95
View File
@@ -0,0 +1,95 @@
---
title: Constructor de flujos de trabajo PDF
description: Crea flujos de procesamiento de PDF personalizados de forma visual conectando nodos en un lienzo. Encadena operaciones como fusionar, comprimir, agregar marca de agua y exportar.
---
# Constructor de flujos de trabajo PDF
El Constructor de flujos de trabajo te permite encadenar varias operaciones de PDF en un único flujo automatizado. En lugar de ejecutar las herramientas una por una, conectas un grafo visual de nodos (entrada, procesamiento, salida) y ejecutas todo con un clic. Tus archivos nunca salen del navegador.
## Cómo funciona
La interfaz se divide en tres paneles: una **caja de herramientas de nodos** a la izquierda, el **lienzo** en el centro y un **panel de ajustes** a la derecha que aparece al seleccionar un nodo.
1. **Agrega nodos** haciendo clic en ellos en la barra lateral izquierda, o arrástralos directamente al lienzo. Usa la barra de búsqueda de la parte superior de la caja de herramientas para filtrar por nombre.
2. **Conecta nodos** arrastrando desde un conector de salida (parte inferior de un nodo) hasta un conector de entrada (parte superior de otro). Las conexiones fluyen de arriba hacia abajo.
3. **Configura los ajustes** haciendo clic en un nodo para abrir su panel de ajustes a la derecha. Cada tipo de nodo tiene sus propias opciones (rangos de páginas, controles de calidad, contraseñas, etc.).
4. **Ejecuta el flujo de trabajo** haciendo clic en el botón **Ejecutar** de la barra de herramientas. El motor ejecuta los nodos en orden topológico, procesando cada uno en secuencia. Una barra de estado en la parte inferior muestra el progreso.
5. **Descarga los resultados**: el nodo final de Descarga guarda el PDF resultante (o un ZIP si se generan varios archivos).
## Categorías de nodos
Los nodos se organizan en seis categorías, cada una con un color distinto en el lienzo:
- **Entrada** (azul): Entrada PDF, Entrada de imagen, Word/Excel/PowerPoint a PDF y más de 15 convertidores de otros formatos que alimentan el flujo con archivos.
- **Editar y anotar** (índigo): Recortar, Escala de grises, Invertir colores, Marca de agua, Números de página, Encabezado y pie de página, Efecto escáner, Ajustar colores, Color de fondo, Eliminar páginas en blanco, Eliminar anotaciones.
- **Organizar y gestionar** (violeta): Fusionar, Dividir, Extraer páginas, Rotar, Eliminar páginas, Invertir, Agregar página en blanco, Dividir páginas, N-Up, Fijar tamaño de página, Combinar en una sola página, Folleto, Posterizar, Editar metadatos, Tabla de contenidos, OCR.
- **Optimizar y reparar** (ámbar): Comprimir, Rasterizar, Linealizar, Enderezar, PDF a PDF/A, Fuente a contorno, Reparar.
- **Proteger PDF** (rosa): Cifrar, Descifrar, Sanear, Aplanar, Firma digital, Censurar.
- **Salida** (verde azulado): Descargar (detecta automáticamente si es un único PDF o un ZIP), PDF a imágenes, PDF a texto, PDF a DOCX, PDF a XLSX, PDF a CSV, PDF a SVG, PDF a Markdown, Extraer imágenes.
## Guardar y cargar flujos de trabajo
La barra de herramientas ofrece cuatro opciones de persistencia:
- **Guardar**: almacena el flujo actual como una plantilla con nombre en el almacenamiento local de tu navegador. Puedes guardar varias plantillas.
- **Cargar**: abre una ventana con todas las plantillas guardadas. Haz clic en Cargar para restaurar una o elimina las plantillas que ya no necesites.
- **Exportar**: descarga el flujo de trabajo como un archivo `.json` para compartirlo o hacer una copia de seguridad.
- **Importar**: carga un archivo de flujo de trabajo `.json` desde el disco y restaura todos los nodos, posiciones y conexiones.
Las plantillas persisten entre sesiones en el almacenamiento local. Los archivos JSON exportados son portables entre navegadores y equipos.
## Modelo de ejecución
El motor construye un grafo de dependencias a partir de tus conexiones y ejecuta los nodos en orden topológico. Si algún nodo falla, la ejecución se detiene y el nodo con el error se marca en rojo. Algunas reglas que conviene recordar:
- Todo flujo de trabajo necesita al menos un nodo de **Entrada** y uno de **Salida**.
- El motor detecta dependencias circulares y bloquea la ejecución con un error.
- El nodo **Cifrar** debe ser el último paso de procesamiento antes del nodo de salida. Colocarlo antes activará una advertencia de validación, porque los nodos posteriores no pueden operar con datos cifrados.
- Los PDF protegidos con contraseña piden la contraseña durante la ejecución.
- Se admiten entradas de varios PDF: el nodo Fusionar puede combinarlos, o los nodos de procesamiento por lotes procesarán cada PDF de forma individual.
## Tipos de conectores
Las conexiones usan conectores tipados para evitar cableados no válidos:
- **PDF** (índigo): un único documento PDF.
- **MultiPDF** (ámbar): varios documentos PDF agrupados.
- **Image** (verde): un blob de imagen.
## Opciones
Cada nodo tiene su propia configuración accesible desde el panel de ajustes de la derecha. Algunos patrones comunes:
- **Rangos de páginas** en los nodos Dividir, Extraer páginas y Eliminar páginas
- **Controles de calidad** en los nodos de salida de conversión a imagen
- **Campos de contraseña** en los nodos Cifrar y Descifrar
- **Entradas de texto** para Marca de agua, Encabezado y pie de página y Editar metadatos
- **Ángulos de rotación** en el nodo Rotar
- **Nivel de compresión** en el nodo Comprimir
- **Selección de idioma de OCR** en el nodo OCR
## Casos de uso
- **Flujo de procesamiento de facturas**: Entrada PDF -> OCR -> Extraer tablas -> Descargar como CSV.
- **Estandarización de informes**: Word a PDF -> Fijar tamaño de página -> Agregar números de página -> Marca de agua -> Comprimir -> Descargar.
- **Preparación para archivado**: Entrada PDF -> Reparar -> Aplanar -> Sanear -> PDF a PDF/A -> Descargar.
- **Extracción de imágenes por lotes**: Entrada PDF (varios archivos) -> Extraer imágenes -> Descargar ZIP.
- **Folletos listos para imprimir**: Entrada PDF -> Folleto -> Recortar -> Comprimir -> Descargar.
- **Distribución segura**: Entrada PDF -> Censurar -> Eliminar anotaciones -> Cifrar -> Descargar.
## Consejos
- Usa **Supr** o **Retroceso** para eliminar del lienzo el nodo seleccionado.
- Haz clic en el botón **X** de la barra de estado de un nodo para eliminarlo directamente.
- Desplaza el lienzo haciendo clic y arrastrando en un espacio vacío. El cursor cambia a un icono de mano mientras te desplazas.
- En el móvil, usa el botón **+** de la barra de herramientas para mostrar u ocultar la caja de herramientas de nodos.
- Si tu flujo de trabajo produce varios archivos de salida, el nodo Descargar los agrupa automáticamente en un ZIP.
- Empieza con algo sencillo: crea y prueba un flujo de dos nodos antes de añadir complejidad.
## Herramientas relacionadas
- [PDF a Texto](./pdf-to-text)
- [PDF a Excel](./pdf-to-excel)
- [Extraer imágenes](./extract-images)
- [PDF a Markdown](./pdf-to-markdown)
docs/es/tools/png-to-pdf.md
+49
View File
@@ -0,0 +1,49 @@
---
title: PNG a PDF
description: Convierte una o más imágenes PNG en un documento PDF con calidad ajustable, todo en tu navegador.
---
# PNG a PDF
Convierte imágenes PNG a PDF conservando su resolución completa. Cada PNG se convierte en su propia página, con el tamaño de las dimensiones de la imagen original. La transparencia se gestiona automáticamente.
## Formatos compatibles
| Formato | Extensiones |
| :------ | :---------- |
| PNG | `.png` |
## Cómo funciona
1. Haz clic en el área de carga o arrastra y suelta archivos PNG. Puedes seleccionar varios a la vez.
2. Gestiona la lista de archivos: quita los que no quieras o agrega más.
3. Elige un nivel de **Calidad del PDF** en el menú desplegable.
4. Haz clic en **Convertir a PDF**. El resultado se descarga como `from_jpgs.pdf`.
La herramienta usa pdf-lib para incrustar cada imagen directamente. Si un PNG no se puede incrustar de forma nativa (p. ej., por un perfil de color poco común), recurre a volver a renderizarlo en un canvas como JPEG.
## Opciones
**Calidad del PDF** controla la compresión que se aplica antes de incrustar:
- **Alta calidad**: compresión mínima, el tamaño de archivo más grande.
- **Calidad media** (por defecto): buen equilibrio entre tamaño y nitidez.
- **Baja calidad**: compresión máxima, la salida más pequeña.
## Casos de uso
- Convertir capturas de pantalla en un PDF de varias páginas para informes de errores o documentación
- Empaquetar exportaciones de diseños de interfaz en un solo archivo para su revisión
- Convertir exportaciones de diagramas (draw.io, Excalidraw) en un PDF para compartir
- Reunir un conjunto de imágenes de gráficos en un informe
## Consejos
- Los archivos PNG con transparencia reciben un fondo blanco en el PDF. Si necesitas otro fondo, edita las imágenes de antemano.
- Para capturas de pantalla y diagramas con bordes nítidos y texto, la calidad Alta evita los artefactos de compresión JPEG. Media o Baja pueden convertir internamente a JPEG.
## Herramientas relacionadas
- [Imágenes a PDF](./image-to-pdf)
- [JPG a PDF](./jpg-to-pdf)
- [SVG a PDF](./svg-to-pdf)
docs/es/tools/posterize-pdf.md
+53
View File
@@ -0,0 +1,53 @@
---
title: Posterizar PDF
description: Divide las páginas de un PDF en una cuadrícula de páginas más pequeñas para imprimir en gran formato repartido en varias hojas.
---
# Posterizar PDF
Divide cada página de un PDF en una cuadrícula de subpáginas más pequeñas. Es la herramienta para imprimir una sola página repartida en varias hojas de papel, que luego unes para crear un póster o una pancarta grande.
## Cómo funciona
1. Sube un archivo PDF.
2. Define el número de **filas** y **columnas** de la cuadrícula (por ejemplo, 2 filas x 2 columnas divide cada página en 4 subpáginas).
3. Opcionalmente, indica un rango de páginas para limitar cuáles se posterizan.
4. El lienzo de vista previa muestra una cuadrícula superpuesta sobre la página actual para que visualices los cortes.
5. Navega entre páginas para comprobar la cuadrícula en distintas páginas.
6. Haz clic en el botón de procesar. Cada celda de la cuadrícula se convierte en su propia página del PDF resultante.
## Características
- Número de filas y columnas configurable para cuadrículas flexibles
- Vista previa en vivo con la cuadrícula superpuesta que muestra exactamente dónde se dividirán las páginas
- Filtro de rango de páginas para posterizar solo páginas concretas
- Navegación página por página en la vista previa
- Instantáneas de páginas en caché para navegar rápido por la vista previa
- Las líneas rojas discontinuas de la cuadrícula marcan claramente los límites de corte
## Opciones
| Opción | Descripción |
| -------------------- | -------------------------------------------------- |
| **Filas** | Número de divisiones horizontales (por defecto: 1) |
| **Columnas** | Número de divisiones verticales (por defecto: 1) |
| **Rango de páginas** | Qué páginas posterizar (vacío = todas las páginas) |
## Casos de uso
- Imprimir un PDF del tamaño de un póster en hojas A4 o Carta estándar para montarlo en una pared
- Crear pancartas grandes a partir de un diseño PDF de una sola página
- Dividir planos técnicos de gran tamaño en teselas imprimibles
- Hacer impresiones de gran formato sin acceso a una impresora de formato ancho
## Consejos
- Una cuadrícula de 2x2 convierte una página en 4 páginas. Una de 3x3 convierte una página en 9. Planifica la cuadrícula según el tamaño que quieras para el resultado montado.
- La cuadrícula de la vista previa te ayuda a comprobar que el contenido importante no caiga sobre una línea de corte. Ajusta filas/columnas si hace falta.
- Para la operación inversa (colocar varias páginas en una sola hoja), usa [N-Up PDF](./n-up-pdf).
## Herramientas relacionadas
- [N-Up PDF](./n-up-pdf)
- [Dividir páginas](./divide-pages)
- [Dividir PDF](./split-pdf)
docs/es/tools/powerpoint-to-pdf.md
+55
View File
@@ -0,0 +1,55 @@
---
title: PowerPoint a PDF
description: Convierte presentaciones de PowerPoint (PPT, PPTX) y archivos ODP a PDF conservando el formato de las diapositivas.
---
# PowerPoint a PDF
Convierte archivos de presentación a PDF. Cada diapositiva se convierte en una página del documento resultante, con texto, imágenes, formas y transiciones renderizados mediante un motor LibreOffice que funciona en el navegador. Admite formatos de PowerPoint modernos y antiguos, además del formato OpenDocument Presentation.
## Formatos compatibles
| Formato | Extensiones |
| :------------------------ | :---------- |
| PowerPoint (moderno) | `.pptx` |
| PowerPoint (antiguo) | `.ppt` |
| OpenDocument Presentation | `.odp` |
## Cómo funciona
1. Haz clic en el área de carga o arrastra y suelta tus archivos de presentación.
2. Revisa la lista de archivos. Añade más o quita los que no necesites.
3. Haz clic en **Convertir a PDF**. El motor LibreOffice se carga la primera vez que lo usas y luego convierte cada archivo.
4. Un solo archivo se descarga directamente como PDF. Varios archivos se empaquetan en `powerpoint-converted.zip`.
## Opciones
Esta herramienta no tiene ajustes adicionales. Las diapositivas se renderizan con sus dimensiones originales.
## Resultado
| Número de archivos | Resultado |
| :----------------- | :------------------------------------------------------------------- |
| 1 archivo | Descarga de un único PDF (nombre original con extensión `.pdf`) |
| 2 o más | Archivo ZIP (`powerpoint-converted.zip`) con un PDF por cada archivo |
## Casos de uso
- Convertir una presentación a PDF antes de compartirla con un público que quizá no tenga PowerPoint
- Crear una versión imprimible de un conjunto de diapositivas para una conferencia o un taller
- Archivar presentaciones en un formato que se ve igual en todos los dispositivos
- Convertir por lotes una biblioteca de presentaciones ODP de LibreOffice Impress a PDF
- Generar una versión PDF de una presentación comercial para enviar por correo
## Consejos
- Las animaciones y transiciones de las diapositivas no se representan en el PDF. Cada diapositiva se captura como una página estática.
- Los vídeos incrustados no aparecerán en el resultado. Sustitúyelos por una captura de pantalla o una imagen de marcador si lo necesitas.
- Las notas del orador no se incluyen en la exportación a PDF predeterminada. Si necesitas las notas, exporta primero desde la vista nativa "Imprimir notas" de PowerPoint.
- El motor LibreOffice se guarda en caché tras la primera carga, así que convertir una segunda presentación en la misma sesión es mucho más rápido.
## Herramientas relacionadas
- [Word a PDF](./word-to-pdf)
- [Excel a PDF](./excel-to-pdf)
- [Imágenes a PDF](./image-to-pdf)
docs/es/tools/prepare-pdf-for-ai.md
+47
View File
@@ -0,0 +1,47 @@
---
title: Preparar PDF para IA
description: Extrae el contenido de un PDF en JSON estructurado y optimizado para LLM y flujos de IA como LlamaIndex. Admite procesamiento por lotes.
---
# Preparar PDF para IA
Extrae el contenido de archivos PDF y lo estructura como JSON optimizado para que lo ingieran modelos de lenguaje de gran tamaño (LLM) y frameworks de IA como LlamaIndex. El contenido de cada página se extrae y se organiza en un formato estructurado listo para flujos RAG, chatbots o sistemas de búsqueda semántica.
## Cómo funciona
1. Sube uno o más PDF haciendo clic en la zona de carga o arrastrando archivos hasta ella.
2. Haz clic en **Extraer** para iniciar el procesamiento.
3. Un solo archivo se descarga como `filename_llm.json`. Varios archivos generan un archivo `pdf-for-ai.zip`.
La herramienta usa la integración de PyMuPDF con LlamaIndex para extraer el contenido por página con metadatos, y produce un resultado que se puede cargar directamente en frameworks de IA.
## Opciones
Esta herramienta no tiene opciones configurables. Todas las páginas se extraen con el texto completo y los metadatos.
## Formato de salida
- **Un solo archivo**: `filename_llm.json`
- **Varios archivos**: `pdf-for-ai.zip` con un `_llm.json` por cada PDF de entrada.
El JSON resultante sigue el esquema de documentos de LlamaIndex, con el texto de cada página y campos de metadatos.
## Casos de uso
- Preparar documentos PDF para flujos de generación aumentada por recuperación (RAG).
- Crear una base de conocimiento consultable a partir de archivos PDF para un chatbot de IA.
- Alimentar informes en PDF a flujos de análisis basados en LLM.
- Preprocesar artículos científicos para sistemas de búsqueda semántica y de preguntas y respuestas.
- Crear datos de entrenamiento estructurados a partir de colecciones de documentos PDF.
## Consejos
- Para extraer texto sin formato específico para IA, usa [PDF a texto](./pdf-to-text).
- Para obtener Markdown que conserve los encabezados y la estructura, usa [PDF a Markdown](./pdf-to-markdown).
- Los PDF escaneados producirán un resultado vacío o mínimo. Pásalos antes por OCR para añadir una capa de texto antes de extraer.
## Herramientas relacionadas
- [PDF a texto](./pdf-to-text)
- [PDF a Markdown](./pdf-to-markdown)
- [PDF a JSON](./pdf-to-json)
docs/es/tools/protect-pdf.md
+64
View File
@@ -0,0 +1,64 @@
---
title: Proteger PDF
description: Protege archivos PDF con contraseña mediante cifrado AES de 256 bits. Define contraseñas de usuario y de propietario con restricciones de uso configurables.
---
# Proteger PDF
Bloquea tu PDF con una contraseña para que solo las personas autorizadas puedan abrirlo. BentoPDF usa cifrado AES de 256 bits, el mismo estándar que utilizan bancos y agencias gubernamentales, aplicado por completo en tu navegador mediante QPDF.
## Cómo funciona
1. Sube un archivo PDF.
2. Introduce una **contraseña de usuario** (obligatoria). Es la contraseña que se necesitará para abrir el archivo.
3. Opcionalmente, introduce una **contraseña de propietario**. Si la defines, el PDF obtiene restricciones de uso que impiden imprimir, editar, copiar y anotar.
4. Haz clic en **Cifrar PDF**.
5. Descarga el archivo cifrado.
## Tipos de contraseña
### Contraseña de usuario (obligatoria)
La contraseña de usuario es la que escriben los destinatarios para abrir el PDF. Sin ella, el documento es completamente inaccesible. Todo PDF cifrado debe tener una.
### Contraseña de propietario (opcional)
La contraseña de propietario controla lo que un usuario autorizado puede hacer después de abrir el archivo. Cuando defines una contraseña de propietario distinta, BentoPDF aplica automáticamente el conjunto de restricciones más estricto:
- Modificación desactivada
- Extracción/copia desactivada
- Impresión desactivada
- Anotación desactivada
- Rellenado de formularios desactivado
- Ensamblaje del documento desactivado
Si dejas en blanco la contraseña de propietario, el PDF se cifra (sigue necesitando la contraseña de usuario para abrirse), pero no tiene restricciones de uso una vez abierto.
## Detalles del cifrado
- **Algoritmo**: AES-256 (Advanced Encryption Standard de 256 bits)
- **Longitud de clave**: 256 bits
- **Estándar**: cifrado PDF 2.0 (implementación de QPDF)
Con la tecnología actual, romper AES-256 por fuerza bruta es computacionalmente inviable. La seguridad de tu PDF cifrado depende por completo de la fortaleza de tu contraseña.
## Casos de uso
- Proteger informes financieros confidenciales antes de enviarlos por correo
- Asegurar documentos legales compartidos con la parte contraria
- Añadir una contraseña a historiales médicos o información de identificación personal
- Distribuir contenido de pago (libros electrónicos, informes) con control de acceso
- Cumplir políticas de protección de datos que exigen cifrado en reposo
## Consejos
- Usa una contraseña fuerte y única. Lo ideal es una frase de 12 o más caracteres con mayúsculas, minúsculas, números y símbolos.
- Comparte la contraseña por un canal distinto (teléfono, mensaje de texto), nunca en el mismo correo que el PDF.
- Si solo necesitas restringir acciones (sin imprimir, sin copiar) sin exigir contraseña para abrirlo, usa en su lugar la herramienta Cambiar permisos.
## Herramientas relacionadas
- [Descifrar PDF](./unlock-pdf): quita el cifrado cuando conoces la contraseña
- [Cambiar permisos](./change-permissions): modifica restricciones de uso concretas
- [Eliminar restricciones](./remove-restrictions): elimina toda la seguridad de un PDF
- [Sanear PDF](./sanitize-pdf): elimina contenido oculto antes de cifrar
docs/es/tools/psd-to-pdf.md
+44
View File
@@ -0,0 +1,44 @@
---
title: PSD a PDF
description: Convierte archivos de Photoshop (PSD) a PDF en tu navegador. Gratis, privado y sin necesidad de software de Adobe.
---
# PSD a PDF
Convierte archivos PSD de Adobe Photoshop en documentos PDF. PSD es el formato nativo de Photoshop y abrirlo normalmente exige un software caro de Adobe. Esta herramienta renderiza la composición aplanada de tu archivo PSD como una página PDF a resolución completa.
## Formatos compatibles
| Formato | Extensión | Notas |
| :-------------- | :-------- | :------------------------------------- |
| Adobe Photoshop | `.psd` | Renderiza la imagen compuesta aplanada |
## Cómo funciona
1. Haz clic en el área de carga o arrastra y suelta tus archivos PSD. Se admiten varios archivos.
2. Revisa la lista de archivos. Quita los que no quieras con el icono de la papelera, o usa **Añadir más archivos** para incluir otros.
3. Haz clic en **Convertir a PDF**. El motor PyMuPDF lee el archivo PSD e incrusta la imagen compuesta en una página PDF a la resolución original.
4. Un solo PSD genera un PDF. Si subes varios archivos PSD, se combinan en un único PDF de varias páginas llamado `psd_to_pdf.pdf`, y cada PSD pasa a ser una página.
## Opciones
No se necesita ningún ajuste. El conversor usa los datos de imagen aplanada del archivo PSD.
## Casos de uso
- Previsualizar diseños de Photoshop sin abrir Photoshop
- Enviar pruebas de diseño a clientes que no tienen Adobe Creative Suite
- Imprimir obras de alta resolución a partir de archivos PSD
- Crear un portafolio en PDF a partir de varios archivos de diseño PSD: cada uno pasa a ser una página de un único documento
## Consejos
- La conversión renderiza la vista compuesta (aplanada) del PSD. Las capas individuales, las capas de ajuste y los efectos de capa no se conservan como elementos separados en el PDF.
- Varios archivos PSD se combinan en un único PDF de varias páginas en lugar de PDF individuales. Es útil para crear portafolios o lookbooks.
- Los archivos PSD de muy alta resolución (archivos de impresión a 300+ DPI) producirán PDF grandes. La herramienta conserva la resolución completa.
## Herramientas relacionadas
- [Imágenes a PDF](./image-to-pdf)
- [PNG a PDF](./png-to-pdf)
- [VSD a PDF](./vsd-to-pdf)
Loaded 100 of 3344 files, more files were not shown because too many files have changed in this diff. Show more