---
title: "PeakCut en Docker: Recortador de Vídeo IA Autoalojado"
description: "Despliega PeakCut con Docker Compose para cortar vídeos largos y directos en clips 9:16 con subtítulos usando transcripción local y tu propia API IA."
date: 2026-11-20
categories: ["ai"]
tags: ["self-hosted","docker","video"]
---

Si publicas tutoriales en YouTube, podcasts o directos en Twitch y Kick, ya conoces el peaje mensual de los recortadores SaaS. Servicios como OpusClip o Vizard cobran suscripción mensual, limitan minutos procesados, añaden marcas de agua en los planes básicos y te obligan a subir gigabytes de vídeo sin editar a su nube antes de saber si algún clip sirve.

[PeakCut](https://github.com/haziqahmedqasmi/PeakCut) (licencia MIT, más de 1.400 estrellas en su primera semana en noviembre de 2026) plantea otro camino: ejecuta el pipeline de recorte en tu ordenador o servidor Linux, transcribe el audio localmente con `sherpa-onnx` (Parakeet) y envía únicamente el texto transcrito a tu propia clave de IA (Gemini, OpenAI, Claude, Groq, OpenRouter, xAI u Ollama local) para elegir los mejores momentos y redactar ganchos.

Así funciona por dentro, cómo desplegarlo en local o con Docker Compose, cuánto cuesta realmente por hora de vídeo y dónde sigue por detrás de un SaaS comercial.

## Cómo funciona PeakCut por dentro

PeakCut combina un backend Python en FastAPI con páginas HTML/CSS/JS simples (sin paso de build pesado), `ffmpeg` y `yt-dlp`. Al pegar un enlace de YouTube, Twitch o Kick (o subir un MP4):

1. **El audio no sale de tu máquina.** La transcripción corre en local mediante `sherpa-onnx` y el modelo Parakeet (~480 MB descargados una vez al primer arranque), o aprovecha la transcripción nativa de YouTube con `PEAKCUT_YT_TRANSCRIPT=1`.
2. **Solo viaja texto hacia el LLM.** Un modelo rápido analiza la transcripción (según la documentación, una hora de vídeo consume unas cuatro peticiones) y devuelve marcas de tiempo, ganchos y títulos en JSON. Sin clave de IA, PeakCut sigue cortando por picos de volumen.
3. **`ffmpeg` renderiza clips verticales 9:16** con subtítulos palabra por palabra en tres estilos integrados. En directos graba en un búfer rotativo y recorta momentos clave mientras el stream sigue activo usando volumen, chat y transcripción.
4. **Control de carga integrado.** Cada segundo revisa CPU, RAM libre y espacio en disco (`PEAKCUT_BUSY_CPU=82`, `PEAKCUT_MIN_FREE_RAM_GB=1.5`) y encola tareas por usuario para no saturar un VPS compartido.

## PeakCut autoalojado frente a recortadores SaaS

| Aspecto | PeakCut (autoalojado) | SaaS comercial (OpusClip, Vizard, etc.) |
|---|---|---|
| Coste del software | **Gratis (MIT)** | ~$15–$40+/mes según minutos |
| Coste por hora de vídeo | Céntimos en tokens de texto (o $0 con Ollama) | Incluido hasta el tope mensual |
| Privacidad del vídeo bruto | En tu disco; ASR local con `sherpa-onnx` | Subido a la nube del proveedor |
| Recorte en directo | Búfer rotativo + volumen/chat/transcripción | Poco común o solo en planes caros |
| Plantillas y B-roll | 3 estilos limpios de subtítulos; sin B-roll de stock | Decenas de plantillas animadas y reencuadre IA |
| Publicación automática | YouTube, Instagram y TikTok (con tus propias apps OAuth) | OAuth en un clic gestionado por el SaaS |
| Hardware necesario | Portátil moderno o VPS de 2–4 vCPU (GPU opcional para ASR) | Ninguno (navegador) |

La decisión es sencilla. Si buscas plantillas llamativas, B-roll automático y cero configuración OAuth para TikTok o Instagram, un SaaS de pago sigue ofreciendo más acabado visual. Si acumulas horas de directos técnicos, charlas o sesiones de código y solo quieres clips verticales limpios sin límites mensuales, PeakCut compensa desde el primer mes. (Si en cambio generas vídeos desde código en lugar de cortar grabaciones, mira mi [reseña de HyperFrames Studio](/es/resena-hyperframes-studio/) o el [editor de intros en Python](/es/editor-intros-video-python/).)

## Instalar PeakCut: portátil local vs servidor Docker

### Docker Compose (VPS / Homelab)

PeakCut trae un `docker-compose.yml` oficial con tres servicios: `postgres:16-alpine`, la app FastAPI en `127.0.0.1:8765` y Caddy opcional (`COMPOSE_PROFILES=own-https`) para HTTPS automático.

Clona el repositorio y prepara `.env`:

```bash
git clone https://github.com/haziqahmedqasmi/PeakCut.git ~/peakcut
cd ~/peakcut
cp .env.example .env
```

Edita `.env` con tu dominio, contraseña de Postgres, proveedor IA y límites de recursos si compartes el VPS:

```env
PEAKCUT_DOMAIN=peakcut.example.com
POSTGRES_PASSWORD=cambia-por-una-contrasena-larga

# Tu propia clave IA (o déjalo vacío y configúralo en Settings -> AI)
PEAKCUT_AI_PROVIDER=gemini
PEAKCUT_AI_MODELS=gemini-2.5-flash
PEAKCUT_AI_KEY=tu-clave-api

# Obligatorio en cualquier servidor accesible para que nadie gaste tu clave IA
PEAKCUT_ACCOUNTS=1

# Descomenta si PeakCut gestiona los puertos 80/443 (omítelo detrás de Traefik/Nginx)
COMPOSE_PROFILES=own-https

# Límites para servidor compartido
PEAKCUT_MEM_LIMIT=4g
PEAKCUT_CPUS=2
PEAKCUT_CPU_SHARES=512
PEAKCUT_OOM_SCORE_ADJ=900
PEAKCUT_DB_MEM_LIMIT=256m
```

Construye y arranca:

```bash
docker compose up -d --build
```

Registra tu cuenta desde el navegador y date permisos de administrador desde la CLI (PeakCut no permite ascender cuentas desde la web):

```bash
docker compose exec app python -m studio.admin grant tu@ejemplo.com
```

Si ya usas [Traefik](/es/traefik-proxy-docker/) en ese host, omite `COMPOSE_PROFILES=own-https` y combina el override incluido (`COMPOSE_FILE=docker-compose.yml:deploy/docker-compose.traefik.yml`).

### Local en Mac / Linux / Windows

En tu ordenador no necesitas Postgres ni cuentas: SQLite guarda todo en `./data` y entras directo al panel. Instala antes Python 3.10+ y `ffmpeg` (`brew install ffmpeg`, `sudo apt install ffmpeg` o `winget install Gyan.FFmpeg`).

```bash
git clone https://github.com/haziqahmedqasmi/PeakCut.git ~/peakcut
cd ~/peakcut
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python -m studio.server
```

En Windows clónalo en una ruta corta como `C:\peakcut` para no chocar con el límite de 260 caracteres al cargar el modelo de voz.

Al primer inicio descarga una sola vez el modelo Parakeet (~480 MB). Abre `http://127.0.0.1:8765`, entra en **Settings -> AI**, elige proveedor (u `ollama` para trabajar 100% sin nube), pulsa **Save and test** y pega tu primer vídeo.

## Elegir modelo IA (o trabajar 100% local con Ollama)

No hace falta un modelo de razonamiento caro para detectar buenos fragmentos en una transcripción. Basta un modelo rápido capaz de devolver JSON limpio:

- **Opción API más barata:** Gemini Flash (`PEAKCUT_AI_PROVIDER=gemini`) o Groq (`llama-3.3-70b-versatile`). Una hora de vídeo ronda las cuatro peticiones y cuesta una fracción de céntimo. Puedes separar varios modelos por comas en `PEAKCUT_AI_MODELS` para tener respaldo automático.
- **100% local sin factura:** configura `PEAKCUT_AI_PROVIDER=ollama` apuntando a un modelo local en tu [instalación de Ollama en Docker](/es/ollama-docker-instalacion/). Revisa la página **AI usage** dentro de PeakCut para comprobar que el modelo elegido devuelve JSON sin reintentos excesivos.
- **Transcripción en otra máquina con GPU:** en CPU `sherpa-onnx` sobra para vídeos puntuales; si procesas VODs largos a diario, puedes delegar la transcripción a un nodo NVIDIA con `deploy/gpu/docker-compose.yml`, `PEAKCUT_ASR_URL` y `PEAKCUT_ASR_TOKEN`.

**No expongas PeakCut sin PEAKCUT_ACCOUNTS=1**

En local las cuentas vienen apagadas por comodidad. En cualquier servidor público mantén `PEAKCUT_ACCOUNTS=1` (activo por defecto en el Compose oficial) y guarda las claves con `PEAKCUT_AI_KEY_FILE=/secrets/ai.txt` o [secretos de Docker Compose](/es/secretos-docker-compose/). Si no, cualquiera que encuentre tu subdominio podrá quemar tu crédito API y llenar el disco.

## Qué revisar antes de montarlo en un VPS pequeño

- Los VODs llenan el disco rápido. PeakCut vigila el espacio libre y pausa nuevas tareas antes de saturarlo; monta /data en un volumen amplio y fija PEAKCUT_MAX_USER_GB si compartes la instancia.

- Límite de subidas en Cloudflare. Si pasas el tráfico por el proxy naranja de Cloudflare, mantén PEAKCUT_UPLOAD_PART_MB=40 (por debajo del límite de 100 MB por petición) y activa PEAKCUT_CLIENT_IP_HEADER=CF-Connecting-IP.

- La publicación automática pide configurar OAuth una vez. Generar y descargar MP4 lleva cinco minutos; publicar directo a YouTube Shorts, Instagram o TikTok exige crear tus apps OAuth siguiendo DEPLOY.md.

- Actualizaciones simples. PeakCut avisa cuando hay nuevos commits en GitHub (desactívalo con PEAKCUT_UPDATE_CHECK=0 si no quieres llamadas salientes) y se actualiza con git pull &amp;&amp; docker compose up -d --build sin tocar .env ni tus clips.

## Conclusión

PeakCut es una de las herramientas IA autoalojadas más limpias que han salido recientemente: licencia MIT, control real de CPU/RAM, transcripción en tu propia máquina y sin cuentas obligatorias en la nube. Empieza con la ejecución local en Python sobre un vídeo de 30 minutos con Gemini Flash u Ollama, valida si la calidad de los cortes cumple tu estándar y solo después monta el stack Docker + Postgres en un VPS.

## Preguntas frecuentes

**¿Necesita PeakCut una GPU para funcionar?**

No. La transcripción corre en CPU con `sherpa-onnx` (Parakeet) y el renderizado usa `ffmpeg` normal. Una GPU es totalmente opcional para acelerar lotes grandes mediante `PEAKCUT_ASR_URL`.

**¿Funciona PeakCut sin ninguna clave de IA?**

Sí. Sin clave configurada recorta clips únicamente por picos de volumen de audio, aunque sin títulos ni selección semántica de momentos. También puedes conectarlo a Ollama en local con coste cero.

**¿Por qué Docker Compose usa PostgreSQL mientras la instalación local usa SQLite?**

En un equipo personal, SQLite dentro de `./data` deja todo en un solo proceso Python. En un servidor multiusuario con subidas simultáneas y grabaciones en directo, PostgreSQL evita bloqueos de escritura.

**¿Cuánto cuesta en tokens recortar una hora de vídeo?**

Como el audio se transcribe localmente, solo pagas tokens de texto por la transcripción. PeakCut analiza una hora de vídeo en unas cuatro peticiones, lo que cuesta menos de un céntimo en Gemini Flash o Groq, o $0 con Ollama.