Forem: Mario

Mi flujo ultra rápido para limpiar audios (WhatsApp, reuniones, vídeos) solo con el navegador

Mario — Thu, 05 Feb 2026 12:14:49 +0000

Grabamos audio en todas partes: WhatsApp, reuniones de trabajo, clases online, Loom, vídeos de YouTube, notas de voz del móvil…

El problema viene después:

formatos raros (.opus, .amr, .m4a), fragmentos sobrantes, archivos gigantes que no puedes enviar por correo o subir a tu web.

En este post te cuento el flujo real que uso ahora para “limpiar” audios rápidos sin abrir un DAW ni instalar nada extra:

convertir a MP3 cualquier cosa que me llegue
recortar lo que no sirve
mezclar trozos sueltos
comprimir para que pese poco
(opcional) sacar texto de las notas de voz

Todo lo hago desde una sola web:

Convertir Audio a MP3 – un pequeño “swiss army knife” de edición de audio en el navegador.

No es un post patrocinado 😅, simplemente es la herramienta que me monté para resolver justo estos problemas y ahora la uso a diario.

1. El kit mínimo para sobrevivir al caos de audios

Si trabajas con audio sin ser técnico de sonido, normalmente no necesitas 200 pistas ni 80 plugins.

Casi siempre basta con estas 4 cosas:

Convertir formato
- De .opus, .ogg, .amr, .m4a, etc. a un MP3 normalito.
Recortar
- Quitar silencios del principio, errores o partes que no quieres enviar.
Comprimir
- Pasar de un archivo de 20–30 MB a algo razonable para compartir.
Mezclar
- Unir varias notas de voz en un único MP3 (por ejemplo preguntas de alumnos).

Con eso ya puedes:

preparar intros/outros de podcast simples,
mandar audios más profesionales a clientes,
dejar grabaciones de reuniones listas para subir a Notion, Confluence o donde sea.

2. De nota de voz de WhatsApp a MP3 limpio (flujo completo)

Vamos a verlo con un ejemplo realista: alguien te manda una nota de voz en WhatsApp con feedback sobre un proyecto, y quieres:

guardarla como MP3 “normal”,
recortar un par de “espera, ¿se escucha?”,
comprimirla para subirla a tu documentación interna.

Paso 1: convertir cualquier cosa a MP3

Entro en la home de

👉 Convertir Audio a MP3

y arrastro el archivo que he descargado de WhatsApp.

La gracia es que no tengo que preocuparme del formato:

.opus de WhatsApp
.m4a del iPhone
.ogg de Telegram
audio extraído de un vídeo…

El backend se encarga con FFmpeg y lo deja en MP3 con el bitrate que elija (128k casi siempre).

💡 Para devs: internamente es una API en FastAPI que llama a FFmpeg con algo muy parecido a:
ffmpeg -i input.opus -vn -c:a libmp3lame -b:a 128k output.mp3
Pero si no quieres tocar consola, subes el archivo y listo.

Paso 2: recortar el ruido de “antes” y “después”

Una vez tengo el MP3, paso al recortador:

Subo el MP3 convertido.
Marco visualmente el inicio y el final que me interesan.
Descargo solo ese fragmento.

Esto me ahorra muchísimo tiempo comparado con abrir un editor grande solo para cortar 5 segundos al principio y 10 al final.

Paso 3: comprimir sin matar la calidad

Si el archivo pesa demasiado (por ejemplo, grabaciones largas de reuniones), uso el compresor:

bajo el bitrate a 96k o 64k,
mantengo el sample rate típico (44.1k),
escucho un preview rápido y descargo.

Para voz suele ser más que suficiente y el tamaño cae bastante.

3. Cuando tienes 10 notas de voz: mezclarlas y olvidarte

Otro caso habitual: varias notas de voz cortas que quieres unir en un solo archivo para:

escuchar de una tirada,
enviar a alguien,
guardarlas como “preguntas de usuarios” o feedback.

En el mezclador:

Subo todos los MP3/OGG/OPUS que quiero juntar.
Los ordeno (arrastrar y soltar).
Exporto un único MP3 con todas las piezas.

No hay crossfade ni efectos locos: es mezcla simple y rápida, que es lo que suele hacer falta para uso “de oficina”.

4. Extra: transcribir audios a texto para documentación

Último paso opcional de mi flujo: sacar el texto.

Cuando el audio es una reunión o feedback largo, me viene genial tener también texto para buscar (Ctrl+F en Notion, Confluence, Google Docs…).

Uso la herramienta de transcripción:

Subo el MP3 recortado y comprimido.
Elijo modelo (tiny/base suele ir bien para español).
Espero unos segundos y copio el texto.

Luego pego el resultado en:

issues de GitHub,
documentación,
o un resumen manual que envío al equipo.

5. ¿Por qué hacerlo en web y no con una app de escritorio?

Como dev podría hacerlo todo con FFmpeg en local. De hecho muchas veces sigo usando scripts. Pero tener un panel web con todo junto me da varias ventajas:

Funciona igual en cualquier equipo (Windows, Mac, Linux, Chromebook…).
No tengo que explicar a gente no técnica cómo instalar FFmpeg.
Puedo compartir la misma URL con clientes o compañeros.
Puedo usarlo desde el móvil cuando me mandan algo fuera de horario de “escritorio”.

Y, sobre todo, puedo tener un único flujo que me sé de memoria:

Subir → convertir → recortar → comprimir → (opcional: transcribir)

6. Ideas si quieres montarte algo parecido como dev

Si te apetece cacharrear y crear tus propias herramientas internas, algunas ideas técnicas:

Backend
- FastAPI o tu framework favorito en Python.
- FFmpeg para todo lo multimedia (audio y vídeo).
Frontend
- Cualquier stack web que te guste: HTMX, React, Vue…
- Para la vista de recorte, un <audio> HTML5 + un timeline simple genera mucho valor sin necesidad de un DAW completo.
UX
- Drag & drop para subir archivos.
- Progreso visible mientras convierte.
- Limpieza de temporales en servidor para no acumular GB de audio.

Aunque no quieras abrirlo al público, solo con tener algo así en tu intranet o para tu equipo de producto puedes ahorrar horas de trabajo tonto con audios.

7. Resumen

Mi flujo actual para domar audios feos de WhatsApp, reuniones y vídeos es:

Subo cualquier formato a 👉 Convertir Audio a MP3
Convierto a MP3 normal.
Recorto lo que sobra.
Comprimo si pesa demasiado.
Si es algo importante, lo transcribo a texto para documentarlo.

No sustituye a un estudio de sonido, pero para el 99% de tareas diarias me basta.

Si también vives rodeado de notas de voz y audios improvisados, quizá este tipo de flujo te ahorre tanto tiempo como a mí. Y si eres dev, igual te da ideas para montar tus propias utilidades internas encima de FFmpeg.

¿Tienes algún truco o herramienta similar para trabajar con audio sin complicarte? Me encantará leerlo en los comentarios 👇

Construyendo un extractor de audio (YouTube MP3) con FastAPI, yt-dlp y ffmpeg

Mario — Thu, 08 Jan 2026 23:05:26 +0000

Extraer el audio de un vídeo para escucharlo como podcast o repasar una clase es un caso de uso muy típico. El problema viene cuando quieres hacerlo:

Sin instalar nada raro en el ordenador
Desde el móvil

En este post cuento cómo está montado por dentro el extractor de audio que usamos en
👉 convertiraudioamp3.com
y en la herramienta de
👉 vídeo a MP3

No explico el código entero, pero sí las ideas clave: FastAPI, yt-dlp, ffmpeg, reCAPTCHA y algunos trucos para que funcione razonablemente bien con YouTube (incluidos Shorts).

Flujo general: de URL a MP3 descargable

El flujo del endpoint “URL → MP3” es algo así:

El usuario envía un POST con:
source_url: enlace de YouTube (u otra plataforma compatible)
calidad_mp3: 192k, 128k o 64k
recaptcha_token: para evitar abuso/robots
Validamos el reCAPTCHA y la URL.
Usamos yt-dlp para inspeccionar los formatos disponibles y elegir el mejor stream de audio.
Descargamos solo el audio (o un stream progresivo de vídeo+audio si no queda otra).
Pasamos ese archivo a ffmpeg para convertirlo a MP3 con el bitrate solicitado.
Devolvemos un JSON con:
download_url para un endpoint de descarga tipo /descargar/{filename}
Limpiamos archivos temporales.

A nivel de usuario, todo eso es un formulario muy simple en
👉 convertiraudioamp3.com/convertir_video_a_mp3

Capa HTTP: FastAPI + reCAPTCHA

La parte web es un endpoint clásico de FastAPI con formulario:

@router.post("/convertir_video_a_mp3")
async def convertir_enlace_a_mp3(
    request: Request,
    source_url: str = Form(...),
    calidad_mp3: str = Form("128k"),
):
    # 1) Log de request (request_id, IP, path, etc.)
    # 2) Verificar reCAPTCHA con el token del formulario
    # 3) Validar/normalizar la URL
    # 4) Lanzar la lógica de descarga + conversión
    ...

Cosas a destacar:

reCAPTCHA: la verificación se hace antes de gastar CPU/red con yt-dlp.
Normalización de URL: usamos una función normalize_youtube_url(...) que:
fuerza https://
limpia parámetros prescindibles en URLs de YouTube
request id (rid): cada petición lleva un UUID en logs, lo que ayuda muchísimo a depurar problemas con vídeos concretos.

yt-dlp: elegir bien el stream de audio

yt-dlp da mucha información de formatos. En lugar de usar un simple "format": "bestaudio/best", nos interesaba:

Evitar formatos sin URL directa (storyboards, miniaturas, etc.)
Preferir audio-only (ej. m4a/140) si está disponible
Ignorar formatos pseudo-vacíos
Tener un fallback progresivo (vídeo+audio) para casos raros

La idea de la función de selección de formato es algo así (pseudocódigo simplificado):

def pick_best_audio_format(info_dict):
    fmts = info_dict.get("formats") or []

    def is_valid_audio(f):
        return (
            f.get("vcodec") == "none"
            and (f.get("acodec") or "").lower() not in {"", "none"}
            and has_url(f)
            and not is_storyboard(f)
        )

    audio_only = [f for f in fmts if is_valid_audio(f)]

    # Preferimos m4a / id 140 si existe (muy típico en YouTube)
    m4a = [f for f in audio_only if f.get("ext") == "m4a" or f.get("format_id") == "140"]
    if m4a:
        return best_by_abr(m4a)

    # Luego cualquier audio-only razonable
    if audio_only:
        return best_by_abr(audio_only)

    # Fallback: stream progresivo vídeo+audio (extraeremos audio con ffmpeg)
    progressive = [f for f in fmts if is_progressive_with_audio(f)]
    if progressive:
        return best_by_abr_or_tbr(progressive)

    # Último recurso
    return "bestaudio/best"

En la implementación real se añaden filtros extra:

has_url(f): revisa url, manifest_url o fragment_base_url.
is_storyboard(f): descarta formatos con format_id tipo sb* o extensiones mhtml, imágenes, etc.

Todo esto reduce bastante los casos de “no hay formatos válidos” y ahorra ancho de banda.

Jugar con player_client: Android, iOS y Web

Un detalle interesante de yt-dlp es el argumento:
"extractor_args": {"youtube": {"player_client": [player_client]}}

YouTube no se comporta igual si finges ser:

un cliente Android
un cliente iOS
el reproductor web

En la práctica, para cierto contenido (y sobre todo Shorts) algunos clientes funcionan mejor que otros. El endpoint hace algo como:

clients = ["android", "ios", "web"]
downloaded = False

for client in clients:
    try:
        opts = ytdlp_opts_base(client)
        info = extract_info_only(opts, source_url)
        fmt = pick_best_audio_format(info)
        download_with_format(opts, source_url, fmt)
        downloaded = True
        break
    except Exception as e:
        log_error(e, client)
        continue

# Fallback sin player_client (a veces da formatos que los otros bloquean)
if not downloaded:
    opts = ytdlp_opts_base("web")
    opts.pop("extractor_args", None)  # sin client
    ...

En ytdlp_opts_base(...) también se ajustan cosas como:

User-Agent y Accept-Language
force_ipv4
retries, fragment_retries, socket_timeout
cookiefile si existe (para sortear algunas restricciones)

Conversión a MP3 con ffmpeg

Una vez descargado el archivo (audio o vídeo+audio), lo pasamos por ffmpeg:

cmd = [
    FFMPEG_BIN, "-y",
    "-i", str(downloaded_path),
    "-vn",                    # sin vídeo
    "-c:a", "libmp3lame",
    "-b:a", calidad_mp3,      # "192k", "128k" o "64k"
    "-ar", "44100",
    "-ac", "2",
    str(final_mp3),
]
safe_run_ffmpeg(cmd)```
{% endraw %}


Algunos detalles:

- safe_run_ffmpeg es un wrapper que limita tiempo de ejecución y captura errores.
- Usamos siempre 44100 Hz y 2 canales por compatibilidad, aunque para voz pura se podría optimizar a mono.
- Guardamos tamaño final en MB y bitrate para poder hacer estadísticas agregadas (sin datos personales).

## Descarga por streaming y limpieza

El endpoint de descarga es un GET /descargar/{filename} que envía el archivo como StreamingResponse en chunks, algo como:
{% raw %}


```python
def iterfile(path: Path, chunk_size: int = 1024 * 1024):
    with path.open("rb") as f:
        while chunk := f.read(chunk_size):
            yield chunk

return StreamingResponse(
    iterfile(file_path),
    media_type="audio/mpeg",
    headers={
        "Content-Disposition": f'attachment; filename="{filename}"',
        "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0, private",
    },
)

Y, muy importante:

El archivo descargado original se borra en un finally.
Los MP3 generados viven en disco, pero hay un proceso de limpieza que va eliminando todo de forma automática cada 24 h.

Ese mismo patrón lo usamos no solo para la parte de YouTube, sino para el resto de herramientas en la web, incluído el conversor de audio general:
👉 https://convertiraudioamp3.com/

Seguridad, límites y aspectos legales

Al ser un servicio público, hay varios puntos a cuidar:

reCAPTCHA en la ruta de URL → MP3 para frenar abuso automatizado.
Validación estricta de URLs (http(s):// y normalización) para no dejar que esto se convierta en un proxy abierto.
Logs mínimos pero útiles: request_id, IP, user-agent, bitrate, tamaño; nada de contenido privado.
Privacidad: archivos temporales y finales se eliminan de forma periódica.
Derechos de autor: el formulario y los textos dejan claro que la opción de enlace (YouTube u otros) es solo para contenido propio o con permiso.

Si solo quieres trastear con el flujo técnico, puedes ignorar la parte de YouTube y probar con vídeo local en la misma herramienta de
👉 vídeo a MP3

subiendo un MP4/MOV/MKV desde tu disco.

Cómo hemos adaptado nuestro recortador de audio para funcionar bien en móvil

Mario — Fri, 05 Dec 2025 17:29:14 +0000

Durante meses, la herramienta principal de recortar audio a MP3 en convertiraudioamp3.com estaba pensada sobre todo para escritorio: vista de ondas, selección visual, teclado, ratón… En móvil funcionaba, pero la experiencia no era tan sencilla como quería, especialmente para algo tan cotidiano como recortar una nota de voz de WhatsApp.

En este artículo cuento cómo he adaptado el recortador para funcionar mejor en móvil creando un “modo simple”, apoyándonos en la arquitectura de jobs que ya usaba para el recortador avanzado y el mezclador de audio online.

Arquitectura: jobs asíncronos con FastAPI + FFmpeg

Tanto el recortador como el mezclador comparten la misma base:

Backend en FastAPI

Procesado de audio con FFmpeg

Un sistema de jobs que:

crea un “trabajo” con un job_id
procesa el audio en segundo plano
expone un endpoint de estado para ver el progreso
expone un endpoint de descarga cuando está listo

La función central que usamos en ambos casos es algo como:

def create_mix_job_from_files_and_spec(
    files: List[UploadFile],
    data: dict,
) -> tuple[str, Dict[str, Any]]:
    calidad = str(data.get("calidad_mp3", "128k"))
    items = data.get("items", [])
    if not isinstance(items, list) or not items:
        raise ValueError("items vacío")

# Guardar subidas en disco
    uploaded_paths: List[str] = []
    for f in files:
        unique = uuid.uuid4().hex
        safe_name = f.filename or "audio"
        dst = UPLOAD_DIR / f"{unique}_{safe_name}"
        with dst.open("wb") as buf:
            shutil.copyfileobj(f.file, buf)
        uploaded_paths.append(str(dst))

# Asegurar src_idx coherente
    for i, it in enumerate(items):
        if "src_idx" not in it:
            it["src_idx"] = i if i < len(uploaded_paths) else (len(uploaded_paths) - 1)

    job_id = uuid.uuid4().hex
    job = {
        "id": job_id,
        "status": "queued",
        "progress": 0.0,
        "step": "queued",
        "error": None,
        "bitrate": calidad,
        "items": items,
        "uploaded_paths": uploaded_paths,
        "result_path": None,
        "created_at": datetime.utcnow().isoformat(),
    }

    JOBS[job_id] = job
    _write_status_file(job)       # Persistimos estado en disco
    EXECUTOR.submit(_run_mix_job, job)  # Lanzamos FFmpeg en background

    return job_id, job

La clave es el campo items: una lista de segmentos a procesar (inicio, fin, crossfade, etc.). Para recortar un solo audio, simplemente mandamos un solo item con inicio y fin.

Modo simple de recorte: centrado en el móvil

La página principal de recorte tiene vista de ondas, JS, interacción más avanzada… Para móvil queríamos algo ultra directo:

Subes un archivo de audio (WhatsApp, M4A, OGG, WAV, MP3…)
Escribes segundo de inicio y de fin
El servidor recorta y te devuelve un MP3

En FastAPI definimos un modo simple separado:
@router.get( "/recortar-audio-mp3/simple", name="recortar_audio_mp3_simple", tags=["seo"], ) def recortar_audio_mp3_simple(request: Request): """ Versión simple: 1 archivo + inicio/fin + calidad. Canonical → /recortar-audio-mp3. """ ctx = build_ctx_simple_es(request, with_recaptcha=True) resp = render_es(request, "recortar-audio-mp3-simple.html", ctx) return _no_cache(resp)

El build_ctx_simple_es se encarga de montar el contexto para la plantilla (valores por defecto, hreflang, etc.) y _no_cache añade cabeceras para evitar caches “rebeldes” (ahora lo vemos).

En el POST hacemos:

Validar que fin > inicio
Verificar reCAPTCHA
Construir el spec_data con un solo item
Crear el job con create_mix_job_from_files_and_spec
Redirigir a la página de estado

@router.post(
    "/recortar-audio-mp3/simple",
    name="recortar_audio_mp3_simple_post",
)
async def recortar_audio_mp3_simple_post(
    request: Request,
    file: UploadFile = File(...),
    inicio: float = Form(...),
    fin: float = Form(...),
    calidad_mp3: str = Form("128k"),
    recaptcha_token: str = Form(""),
):
    if fin <= inicio:
        # devolver error de validación al formulario
        ...

    ok = await verificar_recaptcha(recaptcha_token, request.client.host)
    if not ok:
        # mostrar error de reCAPTCHA al usuario
        ...

    spec_data = {
        "calidad_mp3": calidad_mp3,
        "items": [
            {
                "nombre": file.filename or "audio",
                "inicio": float(inicio),
                "fin": float(fin),
                "crossfade_s": 0.0,   # sin crossfade; es un simple recorte
            }
        ],
    }

    job_id, _job = create_mix_job_from_files_and_spec([file], spec_data)
    url = request.url_for("recortar_audio_mp3_simple_status", job_id=job_id)
    return RedirectResponse(url=url, status_code=303)

Pantalla de estado: caches, móvil y progreso real

En escritorio todo parecía ir bien: la página de estado iba actualizando progreso y al final mostraba el botón de descarga.

En móvil (sobre todo en algunos navegadores), nos encontramos con dos problemas:

Caché agresiva: al recargar, el navegador mostraba siempre el mismo HTML (por ejemplo, “20 % — Normalizando”), aunque el job ya hubiera terminado.
Porcentaje calculado en cliente: el progreso estimado se basaba en un step textual ("normalize 1/3", "trim 2/5", etc.), lo que hacía más fácil que se quedara “atascado” visualmente si intermedia algo se cacheaba.

Solución 1: desactivar caché de forma explícita

En la capa Python, envolvemos la respuesta con un helper _no_cache que añade cabeceras:

def _no_cache(resp: Response) -> Response: resp.headers["Cache-Control"] = "no-store, no-cache, must-revalidate, max-age=0, private" resp.headers["Pragma"] = "no-cache" resp.headers["Expires"] = "0" return resp
Y lo usamos siempre en las vistas de estado:
resp = render_es(request, "recortar-audio-mp3-simple-status.html", ctx) return _no_cache(resp)
En la plantilla también añadimos meta robots para no indexar las URLs de job:

{% block meta_extra %}
  <meta name="robots" content="noindex,nofollow">
  {% if auto_refresh %}
    <meta http-equiv="refresh" content="15">
  {% endif %}
{% endblock %}

Fíjate en que el refresh no lleva url=..., solo el número de segundos; así evitamos que el navegador “combine” cosas raras con la caché previa.

Solución 2: usar el progress del backend

El endpoint de estado (/mezclar-audio/status/{job_id}) ya devolvía un campo numérico progress (0–100). En lugar de recomputar el porcentaje en función de step, usamos directamente lo que diga el backend:

status = js.get("status", "unknown")
step = js.get("step") or ""
error_msg = js.get("error") or None

raw_progress = js.get("progress", 0.0)
try:
    pct = float(raw_progress or 0.0)
except (TypeError, ValueError):
    pct = 0.0
pct = max(0.0, min(100.0, pct))

if status == "done":
    pct = 100.0

Para el texto “bonito” seguimos usando el step

_p, label = step_to_pct_label_es(step)

En la plantilla, el progreso se pinta con algo muy simple:

<div class="w-full bg-gray-200 rounded-full h-3 overflow-hidden">
  <div class="bg-indigo-600 h-3"
       style="width: {{ (pct or 5.0)|round(0) }}%;"></div>
</div>

Con esto, el porcentaje ya no se queda “congelado” en móvil: cada petición GET devuelve un HTML fresco con el valor real de progress que va escribiendo el worker mientras FFmpeg avanza.

Mezclar varios audios en el móvil (también sin apps)

Además del recortador, he preparado un

mezclador simple de audios pensado para móvil

, también 100 % online, sin registros, y sin instalar aplicaciones.

En vez de trabajar con formas de onda avanzadas, este modo simple te deja:

Elegir varios audios a la vez (notas de voz de WhatsApp, MP3, M4A, OGG, WAV…).
Definir un crossfade global en segundos (por ejemplo, 2 s entre cada pista).
Elegir la calidad MP3 de salida.
Lanzar el proceso y recibir un solo MP3 mezclado, listo para compartir.

A nivel técnico, por debajo uso exactamente el mismo sistema de jobs asíncronos con FFmpeg que en el recortador:

Cada archivo se normaliza y se convierte a un formato interno homogéneo (WAV 44.1 kHz, 16-bit).
Generamos una lista de items con inicio, fin y crossfade_s para cada pista.
El backend concatena los clips y aplica acrossfade entre uno y otro cuando procede, exportando el resultado en MP3 con el bitrate elegido.

Eso nos permite mantener el mezclador:

Ligero en el navegador móvil (el trabajo pesado va al servidor).
Robusto ante audios largos (lo mismo: todo se hace por job, no en el hilo principal).
Cohesivo con el resto de la plataforma (misma API de mezcla/recorte, mismo sistema de progreso).

👉 Para el usuario final el flujo es:
subir varios audios → elegir segs de crossfade y calidad → ver la página de progreso → descargar el MP3 final.

Recortar audios a MP3 en el móvil — Preguntas frecuentes ❓

¿Puedo recortar notas de voz de WhatsApp sin instalar aplicaciones?

Sí. Solo tienes que:

Abrir el navegador de tu móvil (Chrome, Safari, etc.).

Guardar la nota de voz de WhatsApp como archivo de audio.

Subirla al recortador simple.

Indicar segundos de inicio y fin, y descargar el MP3 recortado.

Todo se hace online, sin instalar apps adicionales.

¿Funciona tanto en Android como en iPhone?

Sí. El recortador y el mezclador funcionan en cualquier dispositivo con un navegador moderno:

Android (Chrome, Firefox, etc.).
iPhone (Safari, Chrome).

Solo necesitas conexión a Internet y capacidad para seleccionar el archivo de audio desde el móvil.

¿Es gratis recortar audio a MP3?

Sí, el uso de la herramienta es gratis. No pedimos registro y no hay planes de pago ocultos para recortar o mezclar audios. Solo subes tu archivo, eliges el recorte y descargas tu MP3.

¿Puedo usarlo también para mezclar varios audios en el móvil?

Sí. Además del recortador, tienes un modo simple de mezcla de audios pensado para móvil:

Eliges varios archivos en el selector.

Configuras un crossfade en segundos (por ejemplo, 2 s entre pistas).

Descargas un único MP3 mezclado.

Es ideal para juntar varias notas de voz o clips cortos sin tener que instalar un editor de audio complejo.

¿Qué formatos de entrada soporta el recortador móvil?

Los formatos más habituales de audio en móvil, entre ellos:

OPUS (muy común en WhatsApp),

AMR, OGG, M4A,

WAV y MP3.

Independientemente del formato de entrada, la salida es siempre MP3, para máxima compatibilidad con reproductores, coches, apps de mensajería y redes sociales.

¿Qué calidad MP3 debería elegir para el recorte?

Depende del uso:

Para voz / notas de WhatsApp:
64k o 96k suelen ser suficientes y generan archivos muy ligeros.

Para música o mezclas:
128k–192k ofrecen buena calidad; 256k–320k son opciones “máxima calidad”.

En el modo simple dejamos 128k como valor por defecto porque equilibra calidad y peso del archivo.

🎧 Cómo hice un recortador de audio MP3 online con FastAPI + FFmpeg

Mario — Sun, 05 Oct 2025 23:04:04 +0000

Hace poco añadí a mi convertidor de audio MP3 online — convertiraudioamp3.com una nueva herramienta:
➡️ Recortar audios largos y descargarlos en MP3, directamente online.

Detrás hay un trabajo interesante con FastAPI, FFmpeg, un poco de JavaScript moderno y un enfoque muy ligero pero escalable.

El objetivo

Ofrecer algo más que convertir audios de WhatsApp:

Permitir recortar audios largos (voz o música).
Que funcione con formatos comunes: .opus, .ogg, .amr, .m4a, .mp3, .wav…
Procesar el audio en el servidor (seguro, compatible, rápido).
Mantener una experiencia fluida, sin recargar la página.

La arquitectura

🖥️ Backend

FastAPI gestiona tres endpoints:

/recortar-audio/create → crea el trabajo y lanza FFmpeg.
/recortar-audio/status/{id} → devuelve el progreso.
/recortar-audio/download/{id} → permite descargar el MP3 final.
El trabajo se ejecuta en un hilo separado usando subprocess.Popen con FFmpeg, leyendo su salida (-progress pipe:1) para actualizar el porcentaje en tiempo real.
Se utiliza reCAPTCHA v3 en cada solicitud para evitar abusos automáticos, y se registra cada conversión en un log CSV para analítica.

🚀 Lanzar FFmpeg y seguir el progreso

Una de las claves fue capturar la salida de FFmpeg en tiempo real para mostrar progreso al usuario:

def _run_ffmpeg_trim_with_progress(src, dst, start, end, bitrate, job): dur = max(0.01, end - start) cmd = [ "ffmpeg", "-hide_banner", "-y", "-ss", str(start), "-i", src, "-t", str(dur), "-vn", "-acodec", "libmp3lame", "-b:a", bitrate, "-ar", "44100", "-ac", "2", "-progress", "pipe:1", dst ] proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, text=True) job["status"] = "running" for line in proc.stdout: if line.startswith("out_time_ms="): out_s = int(line.split("=")[1]) / 1_000_000 job["progress"] = round((out_s / dur) * 100, 1)

Cada línea con out_time_ms nos dice cuántos microsegundos lleva procesados FFmpeg.
Con eso, actualizamos el progreso en memoria y lo consultamos por API.

⚡ API asíncrona con FastAPI

@router.post("/recortar-audio/create") async def recortar_audio_create(request: Request, file: UploadFile = File(...), inicio: float = Form(...), fin: float = Form(...)): src = UPLOAD_DIR / f"{uuid.uuid4().hex}.mp3" with src.open("wb") as buf: shutil.copyfileobj(file.file, buf) job_id = uuid.uuid4().hex job = {"status": "queued", "progress": 0} JOBS[job_id] = job threading.Thread(target=_run_ffmpeg_trim_with_progress, args=(str(src), f"{src.stem}_trim.mp3", inicio, fin, "128k", job), daemon=True).start() return {"job_id": job_id, "poll_url": f"/recortar-audio/status/{job_id}"}

Con FastAPI y un hilo simple conseguimos asincronía real sin dependencias pesadas.
Ideal para cargas ligeras y VPS pequeños.

💡 Frontend

Creamos un formulario accesible y responsive, con inputs para:

Subir el archivo de audio.
Definir los segundos de inicio y fin.
Seleccionar la calidad MP3 (64k–320k).

El formulario se comunica por AJAX, usando un script JS que:

Envía los datos a /recortar-audio/create.
Lanza un polling para seguir el progreso.
Muestra una barra de carga hasta que el audio está listo.
Finalmente, ofrece un enlace de descarga directa al MP3.

Todo se integra en el bundle generado con esbuild, para mantener el rendimiento óptimo y evitar problemas de caché.

Despliegue y rendimiento

El backend corre tras un proxy Nginx, con:

proxy_set_header X-Forwarded-Proto $scheme;

para que FastAPI detecte correctamente el https:// en las URLs de descarga.

El procesamiento con FFmpeg en servidor es sorprendentemente rápido incluso en VPS modestos. Para audios largos, se recomienda:

Limitar tamaño/duración (por ejemplo, 200 MB o 60 min).
Limpiar los temporales a diario.
Registrar conversiones con fecha, IP y duración para análisis.

Resultado final: un recortador de audio MP3 online, ligero y privado

Después de montar el endpoint y el formulario, obtuvimos una herramienta funcional que permite subir un audio, elegir los segundos de inicio y fin, y obtener el MP3 recortado en segundos.
Todo ocurre en el servidor con FFmpeg y FastAPI, sin depender de servicios externos.

👉 Puedes probar la versión online aquí:
Recortar audio MP3 online — convertiraudioamp3.com

Convertir YouTube a MP3 online con FastAPI, yt-dlp y FFmpeg

Mario — Tue, 09 Sep 2025 08:36:45 +0000

Convertir YouTube a MP3 online con FastAPI, yt-dlp y FFmpeg

Muchos servicios ofrecen convertir YouTube a MP3 online, pero pocos muestran qué hay detrás técnicamente.

En este artículo quiero compartir cómo monté mi aplicación, que tiene una arquitectura un poco inusual pero muy funcional:

Backend en Python con FastAPI y servidor Uvicorn.
Todo desplegado en un hosting compartido con cPanel, no en un VPS dedicado.
Expuesto a Internet mediante Apache actuando como proxy inverso hacia el proceso Uvicorn.
Vistas renderizadas con Jinja2 para SEO (cada ruta devuelve HTML optimizado).

El resultado es una aplicación ligera, escalable y, lo más importante, con un flujo robusto para convertir videos de YouTube a MP3 online.

🎬 Descargando el video de YouTube con `yt-dlp`

El primer paso es obtener el contenido de YouTube. Para esto uso yt-dlp, un fork moderno de youtube-dl que soporta los cambios constantes en la plataforma.

Ejemplo básico en Python:

import subprocess
from pathlib import Path

def descargar_video(url: str, destino: Path):
    command = [
        "yt-dlp",
        "-f", "bestaudio/best",  # mejor calidad disponible
        "-o", str(destino),      # archivo de salida
        url
    ]
    subprocess.run(command, check=True)

Esto genera un archivo de audio en formato original (puede ser webm o m4a, según lo que sirva YouTube).

Paso 2. Convertir el audio a MP3 con ffmpeg

Luego paso ese archivo a MP3 con ffmpeg.
Aquí está el comando en Python usando subprocess:

import subprocess
from pathlib import Path

def convertir_a_mp3(input_file: Path, bitrate="128k") -> Path:
    output_file = input_file.with_suffix(".mp3")
    command = [
        "ffmpeg",
        "-y",                # sobrescribir
        "-i", str(input_file),
        "-vn",               # sin vídeo
        "-c:a", "libmp3lame",
        "-b:a", bitrate,     # 64k, 128k, 192k
        str(output_file)
    ]
    subprocess.run(command, check=True)
    return output_file

🔹 Endpoint en FastAPI

Integrando todo en un endpoint de FastAPI:

from fastapi import FastAPI, Form, HTTPException
from pathlib import Path
import uuid

app = FastAPI()

@app.post("/convertir-youtube")
async def convertir_youtube(url: str = Form(...), calidad: str = Form("128k")):
    try:
        unique_id = uuid.uuid4().hex
        temp_file = Path(f"/tmp/{unique_id}.webm")

        # 1. Descargar audio
        descargar_audio(url, str(temp_file))

        # 2. Convertir a MP3
        mp3_file = convertir_a_mp3(temp_file, bitrate=calidad)

        return {
            "status": "ok",
            "download_url": f"/descargas/{mp3_file.name}"
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Error en conversión: {e}")

🔹 Script de arranque con Uvicorn en cPanel

Sí, todo esto corre en cPanel (donde normalmente no esperas nada más que PHP).
Para arrancar mi servidor tengo un pequeño start.sh:

PROJECT_DIR="/home/usuario/public_html"
VENV="$PROJECT_DIR/venv/bin/activate"
PID_FILE="$PROJECT_DIR/uvicorn.pid"

cd "$PROJECT_DIR" || exit 1
source "$VENV"

nohup uvicorn app.main:app \
  --host 127.0.0.1 \
  --port 8000 \
  --proxy-headers \
  --forwarded-allow-ips="127.0.0.1" \
  > uvicorn.log 2>&1 &
echo $! > "$PID_FILE"

🔹 Resultado final

Con esta arquitectura logré montar un servicio que:

Funciona en un hosting cPanel con Apache como proxy.
Permite a cualquier usuario pegar un enlace de YouTube y obtener su MP3.
Usa herramientas open-source (yt-dlp + FFmpeg) para manejar todo el proceso.
Está pensado para ser ligero, rápido y seguro.

👉 Puedes probarlo en mi proyecto:

Convertir YouTube a MP3 online

✅ Conclusión:

Aunque la infraestructura pueda parecer poco común (FastAPI en cPanel con Apache), es totalmente viable y demuestra que Python + FastAPI se puede adaptar incluso a entornos tradicionales.
Y si necesitas un conversor de YouTube a MP3, no olvides que lo tienes gratis y online 😉.

Cómo convertir audios de WhatsApp, Opus y AAC a MP3 fácilmente (guía práctica)

Mario — Thu, 04 Sep 2025 11:03:16 +0000

Hoy en día recibimos muchísimos audios desde WhatsApp, Telegram o apps de grabadora de voz.

El problema es que la mayoría vienen en formatos como .opus, .aac o .amr, que no siempre se pueden reproducir en todos los dispositivos.

En este post te mostraré:

👉 Por qué ocurre este problema.
👉 Cómo puedes convertirlos con ffmpeg desde tu propio código.
👉 Y una solución mucho más rápida si no quieres complicarte: convertiraudioamp3.com.

📌 ¿Por qué los audios de WhatsApp no abren en PC?

WhatsApp guarda sus notas de voz en .opus, un formato optimizado para compresión.

El detalle es que muchos reproductores (por ejemplo Windows Media Player o algunos móviles) no lo soportan de forma nativa.

Lo mismo ocurre con .aac, .amr o incluso grabaciones hechas con ciertas apps.

🔧 Opción 1: Convertir con FFmpeg

Si te gusta la terminal o estás construyendo tu propia herramienta, puedes usar FFmpeg.

Aquí un snippet en Python que convierte cualquier audio a MP3:

import subprocess

def convertir_a_mp3(archivo_entrada: str, archivo_salida: str, calidad: str = "128k"):
    """
    Convierte un archivo de audio a MP3 usando ffmpeg.
    - archivo_entrada: ruta del archivo original (ej. 'audio.opus')
    - archivo_salida: ruta donde se guardará el mp3 (ej. 'audio.mp3')
    - calidad: bitrate del mp3 (ej. '64k', '128k', '192k')
    """
    comando = [
        "ffmpeg",
        "-y",                # sobrescribir si existe
        "-i", archivo_entrada,
        "-vn",               # sin video
        "-c:a", "libmp3lame",
        "-b:a", calidad,
        "-ar", "44100",      # frecuencia estándar
        "-ac", "2",          # estéreo
        archivo_salida
    ]
    subprocess.run(comando, check=True)

# Ejemplo de uso:
# convertir_a_mp3("nota_whatsapp.opus", "nota_whatsapp.mp3", "128k")

Con esto ya puedes convertir un .opus de WhatsApp o un .aac de tu grabadora en un MP3 estándar.

🚀 Opción 2: Convertir online (sin instalar nada)

Si no quieres instalar librerías ni pelearte con la terminal, existe una alternativa mucho más sencilla:

👉 convertiraudioamp3.com

Solo necesitas:

Subir tu archivo de audio.
Elegir la calidad del MP3.
Descargarlo listo para usar en cualquier dispositivo.

Cómo convertir YouTube a MP3 online (gratis y sin programas)

Mario — Wed, 03 Sep 2025 09:37:57 +0000

🎧 Cómo convertir YouTube a MP3 online (guía 2025)

A veces solo necesitas el audio de un video de YouTube: una clase, un podcast, una canción.

La forma más rápida de hacerlo es con un conversor online a MP3, sin instalar nada.

👉 Aquí tienes la guía completa: Convertir YouTube a MP3

🚀 Características

Gratis y online: no necesitas programas adicionales.
Calidad a elegir: 64k, 128k o 192k según tu uso.
Funciona en PC y móvil.
Privacidad: los archivos se eliminan cada 24 horas.

📌 Paso a paso

Abre el conversor ➡️ Convertir YouTube a MP3
Pega la URL del video de YouTube.
Selecciona la calidad:
- 🎶 192 kbps → música de buena calidad.
- 🎤 128 kbps → estándar (bueno para voz y música).
- 📱 64 kbps → muy ligero, ideal en móvil.
Descarga tu archivo MP3 listo para usar.

🎯 Casos de uso

Guardar canciones de YouTube en tu móvil.
Descargar solo el audio de conferencias y charlas.
Escuchar playlists offline.
Compartir audios más ligeros por WhatsApp o email.

❓ Preguntas frecuentes

¿Necesito instalar un programa?

No, todo funciona en el navegador.

¿Puedo convertir playlists?

Sí, pegando cada enlace de la lista uno por uno.

¿Qué pasa con mis archivos?

Se eliminan automáticamente cada 24h.

🔗 Prueba ahora mismo:

👉 Convertir YouTube a MP3

Convert Audio to MP3 Online — A Simple Tool for Developers, Podcasters & Content Creators

Mario — Thu, 31 Jul 2025 08:33:01 +0000

If you've ever needed to quickly convert audio files to MP3 — whether it's for a podcast, app integration, or social media content — you've likely found yourself jumping between unreliable tools, weird installers, or questionable ads.

I just launched a lightweight online MP3 converter that you can use instantly:
👉 [https://convertiraudioamp3.com]

✅ What it does
You can upload any supported audio file (WAV, M4A, OGG, etc.), and the service will convert it to high-quality MP3 in seconds — directly in your browser, no sign-up needed.

🔧 How it's built

Backend: Python + FastAPI
Audio processing: FFmpeg
Hosting: Deployed on a Linux server with reverse proxy via Apache
Frontend: Simple responsive layout, mobile-friendly
Privacy: Files are automatically removed after conversion

🔁 Use cases

You’re editing a podcast and need a quick way to compress a WAV file
You’re coding a music app and need test MP3s
You're sending a voice note to a client and need smaller size
You just need a dead-simple conversion tool without installing anything

🧪 Future features

Batch conversion
Drag & drop UI
MP3 metadata editing
Mobile upload support from WhatsApp/Telegram voice notes

🤝 Open for feedback
Let me know what would make this tool more helpful to you. I'm open to ideas, especially if you work in audio dev, content creation or music tech.

Try it here:
🔗 [https://convertiraudioamp3.com]

Forem: Mario

Mi flujo ultra rápido para limpiar audios (WhatsApp, reuniones, vídeos) solo con el navegador

1. El kit mínimo para sobrevivir al caos de audios

2. De nota de voz de WhatsApp a MP3 limpio (flujo completo)

Paso 1: convertir cualquier cosa a MP3

Paso 2: recortar el ruido de “antes” y “después”

Paso 3: comprimir sin matar la calidad

3. Cuando tienes 10 notas de voz: mezclarlas y olvidarte

4. Extra: transcribir audios a texto para documentación

5. ¿Por qué hacerlo en web y no con una app de escritorio?

6. Ideas si quieres montarte algo parecido como dev

7. Resumen

Construyendo un extractor de audio (YouTube MP3) con FastAPI, yt-dlp y ffmpeg

Flujo general: de URL a MP3 descargable

Capa HTTP: FastAPI + reCAPTCHA

yt-dlp: elegir bien el stream de audio

Jugar con player_client: Android, iOS y Web

Conversión a MP3 con ffmpeg

Seguridad, límites y aspectos legales

Cómo hemos adaptado nuestro recortador de audio para funcionar bien en móvil

Arquitectura: jobs asíncronos con FastAPI + FFmpeg

Modo simple de recorte: centrado en el móvil

Pantalla de estado: caches, móvil y progreso real

Para el texto “bonito” seguimos usando el step

Mezclar varios audios en el móvil (también sin apps)

mezclador simple de audios pensado para móvil

Recortar audios a MP3 en el móvil — Preguntas frecuentes ❓

🎧 Cómo hice un recortador de audio MP3 online con FastAPI + FFmpeg

El objetivo

La arquitectura

Despliegue y rendimiento

Resultado final: un recortador de audio MP3 online, ligero y privado

Convertir YouTube a MP3 online con FastAPI, yt-dlp y FFmpeg

Convertir YouTube a MP3 online con FastAPI, yt-dlp y FFmpeg

🎬 Descargando el video de YouTube con yt-dlp

Paso 2. Convertir el audio a MP3 con ffmpeg

🔹 Endpoint en FastAPI

🔹 Script de arranque con Uvicorn en cPanel

🔹 Resultado final

👉 Puedes probarlo en mi proyecto:

✅ Conclusión:

Cómo convertir audios de WhatsApp, Opus y AAC a MP3 fácilmente (guía práctica)

📌 ¿Por qué los audios de WhatsApp no abren en PC?

🔧 Opción 1: Convertir con FFmpeg

🚀 Opción 2: Convertir online (sin instalar nada)

Cómo convertir YouTube a MP3 online (gratis y sin programas)

🎧 Cómo convertir YouTube a MP3 online (guía 2025)

🚀 Características

📌 Paso a paso

🎯 Casos de uso

❓ Preguntas frecuentes

Convert Audio to MP3 Online — A Simple Tool for Developers, Podcasters & Content Creators

🎬 Descargando el video de YouTube con `yt-dlp`