Actualizado 5 junio 2026 · 12 min de lectura

Automatizar resúmenes de podcast con API y RSS

¿Sigues 10 podcasts pero solo escuchas 2? El problema no es falta de interés — es falta de tiempo. La solución: un sistema automático que resuma cada episodio nuevo y te envíe el resultado sin que hagas nada.

En este tutorial construimos un bot en Python que monitorea feeds RSS, detecta episodios nuevos y usa la API de Brevecast para generar resúmenes en texto y audio automáticamente.

Arquitectura del sistema

El flujo es simple:

1. Cron (cada hora) ejecuta el script
2. El script lee los feeds RSS de tus podcasts
3. Compara con una lista de episodios ya procesados (processed.json)
4. Para cada episodio nuevo, llama a POST /v1/summarize
5. Guarda el resumen y opcionalmente lo envía por email/Telegram

Dependencias: Python 3.9+, feedparser, httpx. Nada más.

Paso 1: Listar tus feeds RSS

Crea un archivo feeds.json con los podcasts que quieres monitorear:

{
  "feeds": [
    {
      "name": "Lex Fridman Podcast",
      "rss": "https://lexfridman.com/feed/podcast/"
    },
    {
      "name": "Cafe con Victor",
      "rss": "https://anchor.fm/s/xxx/podcast/rss"
    },
    {
      "name": "La Resistencia (audio)",
      "rss": "https://feeds.example.com/laresistencia"
    }
  ]
}

Tip: para encontrar el RSS de cualquier podcast, busca en Google "[nombre podcast] RSS feed" o usa getrssfeed.com.

Paso 2: Script de monitoreo

#!/usr/bin/env python3
"""podcast_monitor.py — Monitorea RSS y resume episodios nuevos."""
import json
import time
from pathlib import Path

import feedparser
import httpx

FEEDS_FILE = Path("feeds.json")
PROCESSED_FILE = Path("processed.json")
BREVECAST_API = "https://brevecast.4l3.org/v1/summarize"
OUTPUT_DIR = Path("summaries")
OUTPUT_DIR.mkdir(exist_ok=True)

def load_processed():
    if PROCESSED_FILE.exists():
        return set(json.loads(PROCESSED_FILE.read_text()))
    return set()

def save_processed(ids: set):
    PROCESSED_FILE.write_text(json.dumps(list(ids), indent=2))

def get_audio_url(entry) -> str | None:
    """Extrae URL del MP3 desde un entry RSS."""
    for link in entry.get("links", []):
        if link.get("type", "").startswith("audio/"):
            return link["href"]
    for enc in entry.get("enclosures", []):
        if enc.get("type", "").startswith("audio/"):
            return enc["href"]
    return None

def summarize(url: str, title: str) -> dict | None:
    """Llama a la API de Brevecast."""
    try:
        resp = httpx.post(BREVECAST_API, json={
            "url": url,
            "format": "both",
            "language": "es"
        }, timeout=300)
        resp.raise_for_status()
        return resp.json()
    except Exception as e:
        print(f"  Error resumiendo {title}: {e}")
        return None

def main():
    feeds = json.loads(FEEDS_FILE.read_text())["feeds"]
    processed = load_processed()
    new_count = 0

    for feed_info in feeds:
        print(f"\nRevisando: {feed_info['name']}")
        feed = feedparser.parse(feed_info["rss"])

        for entry in feed.entries[:3]:  # solo ultimos 3 episodios
            ep_id = entry.get("id", entry.get("link", ""))
            if ep_id in processed:
                continue

            audio_url = get_audio_url(entry)
            if not audio_url:
                print(f"  Sin audio: {entry.get('title', '?')}")
                continue

            title = entry.get("title", "Sin titulo")
            print(f"  Resumiendo: {title}")

            result = summarize(audio_url, title)
            if result:
                # Guardar resumen
                slug = title[:60].lower().replace(" ", "-")
                out = OUTPUT_DIR / f"{slug}.json"
                out.write_text(json.dumps({
                    "title": title,
                    "podcast": feed_info["name"],
                    "summary": result.get("summary", ""),
                    "audio_url": result.get("audio_url", ""),
                    "date": entry.get("published", "")
                }, indent=2, ensure_ascii=False))
                print(f"  Guardado: {out}")
                new_count += 1

            processed.add(ep_id)
            time.sleep(2)  # rate limit

    save_processed(processed)
    print(f"\nTotal nuevos resumidos: {new_count}")

if __name__ == "__main__":
    main()

Paso 3: Configurar el cron

Ejecuta crontab -e y agrega:

# Cada 6 horas, revisar si hay episodios nuevos
0 */6 * * * cd /home/tu-usuario/podcast-monitor && python3 podcast_monitor.py >> cron.log 2>&1

También puedes usar GitHub Actions si no tienes un servidor:

# .github/workflows/podcast-monitor.yml
name: Podcast Monitor
on:
  schedule:
    - cron: '0 */6 * * *'
  workflow_dispatch:

jobs:
  monitor:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.11'
      - run: pip install feedparser httpx
      - run: python podcast_monitor.py
      - uses: actions/upload-artifact@v4
        with:
          name: summaries
          path: summaries/

Paso 4: Notificaciones (opcional)

Añade notificaciones por Telegram cuando se genere un resumen nuevo:

import httpx

def notify_telegram(bot_token: str, chat_id: str, text: str):
    httpx.post(
        f"https://api.telegram.org/bot{bot_token}/sendMessage",
        json={"chat_id": chat_id, "text": text, "parse_mode": "HTML"}
    )

# Después de cada resumen exitoso:
notify_telegram(
    bot_token="TU_BOT_TOKEN",
    chat_id="TU_CHAT_ID",
    text=f"<b>Nuevo resumen</b>\n{title}\n{result['audio_url']}"
)

Ideas avanzadas

Newsletter semanal con resúmenes

Combina los resúmenes de la semana en un email automático con Listmonk o Brevo. Puedes crear una newsletter que tus suscriptores reciban cada lunes con los highlights de los podcasts de su industria.

Base de conocimiento

Guarda los resúmenes en una base de datos con embeddings (pgvector, ChromaDB) y crea un chatbot que responda preguntas basado en todo lo que has “escuchado”.

Filtro inteligente

Antes de resumir, analiza el título del episodio con un prompt rápido: “¿Este episodio trata sobre [tu tema de interés]?”. Si no, salta el episodio. Así solo resumes lo que realmente te importa.

Precios

Para automatización, el plan Pro o Lifetime es ideal — sin límites mensuales en la API.