Webvideos später anhören
PodSammler: Netzfundstücke (Videos) sammeln und in regulärer Podcast-App abonnieren
In diesem Beitrag stelle ich meine kleine Anwendung „PodSammler“ vor: Sie konvertiert diverse Webvideos (z. B. YouTube) als MP3 und trägt diese in einen eigenen Feed ein, welcher wiederum mit jeder normalen Podcast-App abonnierbar ist. PodSammler besitzt einen Endpunkt, um URLs auf dem Smartphone bequem per „Teilen“ zu übermitteln.
Zusammenfassung kurz & knapp
- PodSammler sammelt Webvideos von YouTube, Mediatheken und anderen Websites und wandelt deren Ton in MP3-Dateien um.
- Die Audiodateien werden in einen eigenen RSS-Feed aufgenommen, der sich in einer normalen Podcast-App abonnieren lässt.
- Neue Fundstücke können direkt über die Teilen-Funktion des Smartphones an PodSammler übermittelt werden, sodass sie automatisch im Feed eingepflegt werden.
- Für den Betrieb wird ein eigener, möglichst dauerhaft erreichbarer Server benötigt – beispielsweise ein Raspberry Pi daheim.
Lesezeit für den gesamten Artikel:
Beim Surfen im Netz begegnen mir manchmal Videos auf diversen Internetseiten, wo ich mir denke: »Da wird eh nur gesprochen – das möchte ich mir später in Ruhe beim Spazierengehen, Einschlafen oder Autofahren anhören.« Ich möchte diese Daten also idealerweise als ganz normale Einträge in meiner gewohnten Podcast-App haben, die ich eh regelmäßig nutze. Ich möchte mir die URLs dieser Videos nicht anderweitig notieren müssen. Dies wäre schnell aus dem Sinn.
Vorstellung PodSammler
Daher habe ich mir meinen kleinen PodSammler gebaut. Man muss ihn jedoch selber hosten: Man benötigt also einen kleinen, stets aktiven Server (z. B. Raspberry Pi). Dazu später mehr.

PodSammler wird ganz normal im Browser bedient: Oben kann man die URL einer Website eintragen, auf der sich ein Video befindet (YouTube, Mediatheken, …). Dann wird daraus intern je eine MP3 generiert und ein Thumbnail. Dies wird dann gelistet und der RSS-Feed wird aktualisiert. Es gibt auch eine einfache Abspielmöglichkeit.
Aber der eigentliche Kern ist, dass dieser Feed (der „Podcast“) in einer ganz normalen Podcast-App abonnierbar ist:

Ich nutze die App AntennaPod. Das Abonnieren von RSS-Feeds sollten jedoch auch viele andere Podcast-Apps beherrschen.
Beim Aktualisieren aller meiner Podcasts (Feeds) werden mir als neue Folgen dann auch die meiner eigenen Sammlung angezeigt – also der Ton der Webvideos, die ich vorher in den PodSammler einpflegte.
Und das Hinzufügen neuer Einträge gelingt am Unkompliziertesten und schnellsten mit der Teilen-Funktion am Smartphone oder Tablet:

Ich nutze hierzu die App ›HTTP Shortcuts‹, mittels der man die jeweilige URL im Browser an diverse Dienste („Endpunkte“) übermitteln kann. Ich könnte diese URL somit auch an das „Notizbuch“ meiner persönlichen Browser-Startseite senden. Aber dies ist eine andere Geschichte – jedoch nicht minder interessant.
Am Desktop-Computer könnte man sich ein Bookmarklet anlegen. Allerdings müsste PodSammler dann via https erreichbar sein, sonst verweigern viele Browser das Teilen darüber.
Selber hosten
Wie oben bereits angesprochen: Diese kleine Anwendung (Python) muss auf einem Server laufen, der (möglichst) permanent via Internet erreichbar ist. Mein kleiner Raspberry Pi verbraucht kaum Strom und läuft den ganzen Tag:
Natürlich kann man sich auch einen kleinen virtuellen Server (VPS) bei einem Hoster mieten. Dann müsste man sich nicht mehr selbst um die Hardware und Erreichbarkeit kümmern. Der Raspberry Pi ist jedoch recht günstig und läuft jahrelang zuverlässig.
db-tronic Raspberry Pi 4 4GB Starter Set | 64GB Edition | Netzteil 15W | Gehäuse rot/weiß | Kühlkörper Set | 4K Micro HDMI Kabel | Ideal für Smart Home, Retro Gaming & Home Assistant
Der Minicomputer Raspberry Pi eignet sich als kleiner, stromsparender Computer für zahlreiche Aufgaben: beispielsweise als Medienzentrale, Server, Netzwerkgerät oder für Archivierungs- und Automatisierungsaufgaben. Idealerweise kauft man den Raspi günstig im Set mit dem nötigen Zubehör.
Werbung | Preis(e) aktualisiert am 15. November 2026, inkl. MwSt., ggf. zzgl. Versandkosten | Alle Angaben ohne Gewähr
Für die permanente Verfügbarkeit aus dem Internet müsste man sich dann jedoch um eine (kostenlose) Dyn-DNS-Domain x kümmern. Die FritzBox hat die hierfür nötige Technik bereits integriert (falls man eine solche nutzt). Ansonsten müsste man sich eben einen kleinen DynDNS-Dienst auf dem Raspberry selbst installieren.
x Der eigene Raspberry Pi ist dann permanent über eine feste Domain erreichbar anstelle über ein (sich wechselnde) IP-Adresse. Dem Domainanbieter (z. B. Duck DNS) muss jedoch regelmäßig die eigene externe IP-Adresse mitgeteilt werden, daher der Dienst – z. B. in der FritzBox integriert).
Damit PodSammler sowohl für die Teilen-App (z. B. ›HTTP-Shortcuts‹) wie auch für die Podcast-App aus dem Internet erreichbar ist, muss a: entweder ein Port im Router nach außen freigegeben werden. Oder b: man nutzt am Smartphone eine permanente VPN-Verbindung zum eigenen Heimnetzwerk.
Ich nutze Letzteres. Dies ist auch viel sicherer als ein offener Port (zumal PodSammler überhaupt keine Login-Hürde besitzt). Neuere FritzBox-Modelle besitzen mittlerweile eine WireGuard-Funktion, mittels der ein VPN-Kanal ins Heimnetz sehr einfach zu bewerkstelligen ist. Ansonsten kann man sich auch auf dem Raspberry Pi selbst einen kleinen WireGuard-Server installieren. Auf dem Smartphone benötigt man dann noch die dazugehörige WireGuard-App.
Außerdem benötigt der Raspberry Pi stets die selbe (eine feste) interne IP-Adresse. Dies konfiguriert man im Router.
Soviel zum technischen Hintergrund. Die Sache ist leider nicht für Laien nutzbar. Mir ist allerdings auch kein Anbieter bekannt, der so einen Dienst anbietet. Daher habe ich mir (als Nicht-Programmierer) so etwas einfach via KI erstellen lassen. Der PodSammler ist so ein richtig schönes, kleines Vibe-Coding-Projekt: Es gibt einen Wunsch aber keine bestehende Lösung. Also erstellt KI dieses Programm einfach nach meinen Vorgaben. Basis-Hintergrundwissen in puncto Linux / Programmieren musste natürlich vorhanden sein.
Ich gehe jetzt davon aus, dass Sie vor einem Terminal bzw. an einem Linux-Rechner sitzen. Dann bauen wir uns den PodSammler also selber zusammen. Das geht schnell. Das Programm ist eigentlich sehr minimalistisch aufgebaut:
Das Programm erstellen
Die Sache funktioniert als kleine Python-Anwendung innerhalb einer venv-Umgebung. Denn wir benötigen einige zusätzliche Python-Komponenten, die nativ nicht auf dem Betriebssystem (zumindest nicht auf meinem Raspberry-OS) vorhanden sein werden und seit einiger Zeit beschweren sich ja Debian-basierte Betriebssysteme, wenn man ihnen global weitere Python-Komponenten (z. B. den Mini-Webserver „flask“) hinzufügen möchte.
Allerdings benötigen wir ffmpeg global auf dem System. Mit ffmpeg konvertieren wir später den Audio-Rohstream je in eine MP3. Das installieren wir zuerst, falls noch nicht vorhanden:
sudo apt update && sudo apt install -y ffmpeg
Bei mir war dieses Paket bereits vorhanden, da ich es bereits für andere Dinge benötige.
Nun legen wir den Stammordner von „PodSammler“ an und erstellen darin die Python-venv-Umgebung, in die wir auch gleich wechseln bzw. sie zunächst aktivieren:
mkdir ~/podsammler && cd ~/podsammler python3 -m venv venv source venv/bin/activate pip install flask yt-dlp
Falls Sie das Stammverzeichnis woanders als im Home-Ordner erstellen möchten, müsste der Pfad natürlich geändert werden. Wie man sieht, installieren wir auch zwei zusätzliche Komponenten (flask und yt-dlp).
„flask“ ist ein winziger Webserver und „yt-dlp“ ermittelt die eigentliche Video-URL eines auf einer Website eingebetteten Videos. „ffmpeg“ wird dessen Audio-Rohstream später in eine MP3 konvertieren.
Werbung
Zudem erstellen wir im Stammverzeichnis einige Unterordner:
mkdir templates mkdir static mkdir downloads
Ein Ordner „venv“ mit vielen Python-Systemdateien müsste bereits durch den ersten Schritt erstellt worden sein.
Im Stammordner erstellen wir nun die eigentliche Programmdatei app.py:
Code app.py
import os
import sqlite3
import threading
import uuid
import urllib.request
from datetime import datetime, timezone
from xml.sax.saxutils import escape as xml_escape
from flask import (Flask, jsonify, redirect, render_template, request,
send_from_directory, url_for)
import yt_dlp
# ---------------------------------------------------------------------------
# Flask-App initialisieren
# ---------------------------------------------------------------------------
app = Flask(__name__)
# ---------------------------------------------------------------------------
# Konfiguration
# ---------------------------------------------------------------------------
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DB_PATH = os.path.join(BASE_DIR, 'podsammler.db')
DOWNLOAD_DIR = os.path.join(BASE_DIR, 'downloads')
MAX_AUDIO_BITRATE = 128 # kbps
os.makedirs(DOWNLOAD_DIR, exist_ok=True)
# ---------------------------------------------------------------------------
# Datenbank
# ---------------------------------------------------------------------------
def init_db():
"""Legt die Tabelle an und räumt unfertige Einträge auf."""
conn = sqlite3.connect(DB_PATH)
c = conn.cursor()
c.execute('''
CREATE TABLE IF NOT EXISTS items (
id TEXT PRIMARY KEY,
url TEXT UNIQUE,
title TEXT,
description TEXT,
thumbnail_path TEXT,
audio_path TEXT,
status TEXT DEFAULT 'pending',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)
''')
# Nach Absturz oder Neustart bleiben Einträge im Status 'downloading'
# zurück. Sie erscheinen nie im Feed, wären in der Oberfläche aber
# unsichtbar -> als 'failed' markieren, damit sie löschbar sind.
c.execute("UPDATE items SET status='failed' "
"WHERE status IN ('pending', 'downloading')")
conn.commit()
conn.close()
def get_db_connection():
conn = sqlite3.connect(DB_PATH)
conn.row_factory = sqlite3.Row
return conn
def db_update(item_id, **fields):
"""Aktualisiert einzelne Felder eines Eintrags."""
assignments = ', '.join(f"{key}=?" for key in fields)
conn = get_db_connection()
conn.execute(f"UPDATE items SET {assignments} WHERE id=?",
(*fields.values(), item_id))
conn.commit()
conn.close()
# ---------------------------------------------------------------------------
# Download und Konvertierung
# ---------------------------------------------------------------------------
def download_and_process(url, item_id):
"""Lädt Metadaten, Thumbnail und Audio; läuft in einem eigenen Thread."""
audio_name = f"{item_id}.mp3"
thumb_name = f"{item_id}_thumb.jpg"
audio_path = os.path.join(DOWNLOAD_DIR, audio_name)
thumb_path = os.path.join(DOWNLOAD_DIR, thumb_name)
try:
# --- Schritt 1: Metadaten lesen (nichts herunterladen) -------------
meta_opts = {
'quiet': True,
'no_warnings': True,
'skip_download': True,
'extract_flat': 'in_playlist', # Playlist-Einträge nur flach -> schnell
'noplaylist': True,
}
with yt_dlp.YoutubeDL(meta_opts) as ydl:
info = ydl.extract_info(url, download=False)
# Playlists und Kanäle werden abgelehnt: yt-dlp würde alle Einträge
# nacheinander in dieselbe Zieldatei schreiben.
if info.get('_type') == 'playlist':
raise ValueError('Playlist- oder Kanal-URL. Bitte eine einzelne '
'Video-URL angeben.')
title = info.get('title') or 'Unbekannter Titel'
description = info.get('description') or ''
thumbnail_url = info.get('thumbnail')
# --- Schritt 2: Thumbnail per einfachem HTTP-GET laden -------------
if thumbnail_url:
try:
req = urllib.request.Request(
thumbnail_url, headers={'User-Agent': 'Mozilla/5.0'})
with urllib.request.urlopen(req, timeout=15) as resp:
with open(thumb_path, 'wb') as f:
f.write(resp.read())
except Exception as e:
print(f"Warnung: Thumbnail-Download fehlgeschlagen ({e}).")
thumb_name = None
else:
thumb_name = None
# --- Schritt 3: Audio laden und nach MP3 konvertieren --------------
audio_opts = {
'format': 'bestaudio/best',
'postprocessors': [{
'key': 'FFmpegExtractAudio',
'preferredcodec': 'mp3',
'preferredquality': str(MAX_AUDIO_BITRATE),
}],
'outtmpl': os.path.join(DOWNLOAD_DIR, f"{item_id}.%(ext)s"),
'noplaylist': True,
'quiet': False,
'no_warnings': True,
}
with yt_dlp.YoutubeDL(audio_opts) as ydl:
ydl.download([url])
# --- Schritt 4: Datenbank aktualisieren ----------------------------
# Gespeichert werden nur Dateinamen, keine absoluten Pfade. Damit
# bleibt die DB unabhängig vom Programmverzeichnis.
db_update(item_id,
title=title,
description=description,
thumbnail_path=thumb_name,
audio_path=audio_name,
status='completed')
except Exception as e:
print(f"Fehler beim Verarbeiten von {item_id}: {e}")
db_update(item_id, status='failed', description=str(e))
# ---------------------------------------------------------------------------
# Routen
# ---------------------------------------------------------------------------
@app.route('/')
def index():
"""Administrationsoberfläche."""
conn = get_db_connection()
items = conn.execute(
'SELECT * FROM items ORDER BY created_at DESC, rowid DESC'
).fetchall()
conn.close()
return render_template('index.html', items=items)
@app.route('/add', methods=['POST'])
def add_item():
"""API: URL entgegennehmen und Download starten."""
data = request.get_json(silent=True) or {}
url = (data.get('url') or '').strip()
if not url:
return jsonify({'error': 'Keine URL angegeben'}), 400
item_id = str(uuid.uuid4())
conn = get_db_connection()
try:
if conn.execute('SELECT 1 FROM items WHERE url=?', (url,)).fetchone():
return jsonify({'error': 'URL bereits vorhanden'}), 409
conn.execute('INSERT INTO items (id, url, status) VALUES (?,?,?)',
(item_id, url, 'downloading'))
conn.commit()
finally:
conn.close()
threading.Thread(target=download_and_process, args=(url, item_id),
daemon=True).start()
return jsonify({'message': 'Download gestartet', 'id': item_id}), 202
@app.route('/delete/<item_id>')
def delete_item(item_id):
"""Löscht Dateien und Datenbankeintrag."""
conn = get_db_connection()
item = conn.execute('SELECT * FROM items WHERE id=?', (item_id,)).fetchone()
if item:
for name in (item['audio_path'], item['thumbnail_path']):
if name:
path = os.path.join(DOWNLOAD_DIR, os.path.basename(name))
if os.path.exists(path):
os.remove(path)
conn.execute('DELETE FROM items WHERE id=?', (item_id,))
conn.commit()
conn.close()
return redirect(url_for('index'))
@app.route('/download/<filename>')
def serve_file(filename):
"""Liefert MP3- und Bilddateien aus."""
return send_from_directory(DOWNLOAD_DIR, filename)
# ---------------------------------------------------------------------------
# RSS-Feed
# ---------------------------------------------------------------------------
WEEKDAYS = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
def rfc822(dt):
"""Formatiert ein datetime als RFC-822-Datum (englisch, UTC)."""
if dt.tzinfo is None:
dt = dt.replace(tzinfo=timezone.utc)
dt = dt.astimezone(timezone.utc)
return (f"{WEEKDAYS[dt.weekday()]}, {dt.day:02d} {MONTHS[dt.month - 1]} "
f"{dt.year} {dt.hour:02d}:{dt.minute:02d}:{dt.second:02d} +0000")
def cdata(text):
"""Verpackt Text in CDATA und entschärft die Sequenz ]]>."""
if text is None:
text = ''
return '<![CDATA[' + str(text).replace(']]>', ']]]]><![CDATA[>') + ']]>'
@app.route('/feed.xml')
def feed():
"""Erzeugt den RSS-Feed aus dem aktuellen Datenbankstand."""
conn = get_db_connection()
items = conn.execute(
"SELECT * FROM items WHERE status='completed' "
"ORDER BY created_at DESC, rowid DESC"
).fetchall()
conn.close()
host = request.host_url.rstrip('/')
# Kanal-Cover: nur referenzieren, wenn die Datei existiert
cover_file = os.path.join(app.static_folder, 'podcast_cover.jpg')
cover_url = f"{host}/static/podcast_cover.jpg" if os.path.exists(cover_file) else None
x = []
x.append('<?xml version="1.0" encoding="UTF-8"?>')
x.append('<rss version="2.0"')
x.append(' xmlns:atom="http://www.w3.org/2005/Atom"')
x.append(' xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd"')
x.append(' xmlns:media="http://search.yahoo.com/mrss/">')
x.append(' <channel>')
x.append(' <title>PodSammler – Meine Fundstücke</title>')
x.append(f' <link>{xml_escape(host)}</link>')
x.append(f' <atom:link href="{xml_escape(host)}/feed.xml" '
'rel="self" type="application/rss+xml" />')
x.append(' <description>Meine persönlichen Audio-Fundstücke</description>')
x.append(' <language>de-de</language>')
x.append(' <generator>PodSammler</generator>')
x.append(f' <lastBuildDate>{rfc822(datetime.now(timezone.utc))}</lastBuildDate>')
x.append(' <itunes:author>PodSammler</itunes:author>')
x.append(' <itunes:explicit>false</itunes:explicit>')
x.append(' <itunes:category text="Society & Culture" />')
if cover_url:
x.append(f' <itunes:image href="{xml_escape(cover_url)}" />')
for item in items:
if not item['audio_path']:
continue
# os.path.basename toleriert auch noch nicht migrierte Alteinträge
audio_name = os.path.basename(item['audio_path'])
audio_full = os.path.join(DOWNLOAD_DIR, audio_name)
if not os.path.exists(audio_full):
continue
audio_url = f"{host}/download/{audio_name}"
size = os.path.getsize(audio_full)
thumb_url = None
if item['thumbnail_path']:
thumb_name = os.path.basename(item['thumbnail_path'])
if os.path.exists(os.path.join(DOWNLOAD_DIR, thumb_name)):
thumb_url = f"{host}/download/{thumb_name}"
original_url = item['url'] or audio_url
title = item['title'] or 'Unbekannt'
# Zeilenumbrüche normalisieren, für HTML-Darstellung aufbereiten
desc = (item['description'] or '').replace('\r\n', '\n').replace('\r', '\n')
desc_html = desc.replace('\n', '<br />')
# SQLite liefert "YYYY-MM-DD HH:MM:SS" in UTC
try:
pub = datetime.fromisoformat(str(item['created_at']).replace(' ', 'T'))
except (TypeError, ValueError):
pub = datetime.now(timezone.utc)
x.append(' <item>')
x.append(f' <title>{cdata(title)}</title>')
x.append(f' <description>{cdata(desc_html)}</description>')
x.append(f' <link>{xml_escape(original_url)}</link>')
x.append(f' <guid isPermaLink="true">{xml_escape(original_url)}</guid>')
x.append(f' <pubDate>{rfc822(pub)}</pubDate>')
x.append(f' <enclosure url="{xml_escape(audio_url)}" '
f'length="{size}" type="audio/mpeg" />')
if thumb_url:
x.append(f' <itunes:image href="{xml_escape(thumb_url)}" />')
x.append(f' <media:thumbnail url="{xml_escape(thumb_url)}" />')
x.append(' </item>')
x.append(' </channel>')
x.append('</rss>')
return '\n'.join(x), 200, {'Content-Type': 'application/rss+xml; charset=utf-8'}
if __name__ == '__main__':
init_db()
app.run(host='0.0.0.0', port=5007, debug=False)Als nächstes erstellen wir templates/index.html:
Code templates/index.html
<!DOCTYPE html>
<html lang="de">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>PodSammler</title>
<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
<script src="{{ url_for('static', filename='scripts.js') }}" defer></script>
<link rel="icon" href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 100 100%22><text y=%22.9em%22 font-size=%2290%22>📻</text></svg>">
</head>
<body>
<div class="container">
<header>
<h1>PodSammler</h1>
<p>Fundstücke sammeln, konvertieren, in Feed integrieren</p>
</header>
<section class="add-section">
<form id="addForm" onsubmit="handleAdd(event)">
<input type="text" id="urlInput" placeholder="URL eingeben (YouTube, Mediathek …)" required>
<button type="submit">Hinzufügen</button>
</form>
<div id="statusMsg"></div>
</section>
<!-- Globaler Audio-Player (Fortschrittsleiste) -->
<section id="player-bar" class="player-bar" style="display: none;">
<div class="player-info">
<span id="playerTitle">Titel wird abgespielt</span>
<span id="playerTime">0:00 / 0:00</span>
</div>
<div class="progress-container" id="progressContainer">
<div class="progress-bar" id="progressBar"></div>
</div>
</section>
<section class="list-section">
<h2>Aktuelle Fundstücke</h2>
{% if items %}
<table class="responsive-table">
<thead>
<tr>
<th>Bild</th>
<th>Titel</th>
<th>Status</th>
<th>Aktion</th>
<th>Abruf</th>
</tr>
</thead>
<tbody>
{% for item in items %}
<tr>
<td class="thumb-cell" data-label="Bild">
{% if item.thumbnail_path %}
<img src="{{ url_for('serve_file', filename=item.thumbnail_path) }}" alt="">
{% else %}
<span class="no-img">–</span>
{% endif %}
</td>
<td class="title-cell" data-label="Titel">
<strong class="item-title">{{ item.title or 'Wird geladen …' }}</strong>
<small class="item-date">{{ item.created_at }}</small>
<a class="src-link" href="{{ item.url }}" target="_blank"
rel="noopener noreferrer">{{ item.url }}</a>
</td>
<td class="status-cell" data-label="Status">
{% if item.status == 'completed' %}
<span class="status-ok">Fertig</span>
{% elif item.status == 'failed' %}
<span class="status-error">Fehler</span>
{% else %}
<span class="status-waiting">Lädt …</span>
{% endif %}
</td>
<td class="action-cell" data-label="Aktion">
<a href="/delete/{{ item.id }}" class="btn-delete"
onclick="return confirm('Wirklich löschen?')">Löschen</a>
</td>
<td class="play-cell" data-label="Abruf">
{% if item.status == 'completed' and item.audio_path %}
<button class="btn-play"
data-src="{{ url_for('serve_file', filename=item.audio_path) }}"
title="Abspielen">▶</button>
{% else %}
<span class="no-play">–</span>
{% endif %}
</td>
</tr>
{% endfor %}
</tbody>
</table>
{% else %}
<p class="empty-msg">Noch keine Fundstücke gespeichert.</p>
{% endif %}
</section>
<footer>
<p>RSS-Feed: <a href="/feed.xml" target="_blank">/feed.xml</a></p>
</footer>
</div>
<!-- Gemeinsamer Audio-Player (unsichtbar) -->
<audio id="player"></audio>
</body>
</html>Jetzt erstellen wir die Datei static/style.css:
Code static/style.css
/* ==========================================================================
* 1. GLOBALE VARIABLEN & RESET
* ========================================================================== */
:root {
/* Farben */
--bg-color: #f8f9fa;
--card-bg: #ffffff;
--primary: #6d4aff;
--primary-hover: #5939e0;
--text-main: #333333;
--text-muted: #666666;
--border: #e0e0e0;
--success: #28a745;
--error: #dc3545;
--waiting: #ffc107;
/* Player-spezifisch */
--player-bg: #f1f0ff;
--player-progress-bg: #e0dcfc;
/* Design-Tokens (UI-Hilfen) */
--radius-sm: 4px;
--radius-md: 6px;
--radius-lg: 8px;
--radius-xl: 12px;
--transition-fast: 0.1s linear;
}
* {
box-sizing: border-box;
}
body {
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
background-color: var(--bg-color);
color: var(--text-main);
margin: 0;
padding: 20px;
line-height: 1.6;
}
.container {
max-width: 960px;
margin: 0 auto;
background: var(--card-bg);
padding: 30px;
border-radius: var(--radius-xl);
box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
}
/* ==========================================================================
* 2. HEADER
* ========================================================================== */
header h1 {
margin-top: 0;
margin-bottom: 4px;
color: var(--primary);
font-size: 1.8rem;
}
header p {
color: var(--text-muted);
margin-top: 0;
margin-bottom: 30px;
}
/* ==========================================================================
* 3. EINGABEBEREICH (ADD-SECTION)
* ========================================================================== */
.add-section {
margin-bottom: 30px;
}
.add-section form {
display: flex;
gap: 10px;
}
input[type="text"] {
flex: 1;
width: 100%;
padding: 12px;
border: 1px solid var(--border);
border-radius: var(--radius-md);
font-size: 16px;
font-family: inherit;
background: var(--card-bg);
color: var(--text-main);
}
input[type="text"]:focus {
outline: none;
border-color: var(--primary);
}
button[type="submit"] {
background: var(--primary);
color: var(--card-bg);
border: none;
padding: 12px 24px;
border-radius: var(--radius-md);
cursor: pointer;
font-weight: 600;
font-size: 16px;
font-family: inherit;
white-space: nowrap;
}
button[type="submit"]:hover {
background: var(--primary-hover);
}
button[type="submit"]:disabled {
background: var(--border);
cursor: not-allowed;
}
#statusMsg {
margin-top: 10px;
font-weight: 600;
min-height: 1.2em;
}
.success { color: var(--success); }
.error { color: var(--error); }
/* ==========================================================================
* 4. AUDIO-PLAYER (PLAYER-BAR)
* ========================================================================== */
.player-bar {
background: var(--player-bg);
border: 1px solid var(--primary);
border-radius: var(--radius-lg);
padding: 12px 16px;
margin-bottom: 30px;
}
.player-info {
display: flex;
justify-content: space-between;
font-size: 0.85rem;
font-weight: 600;
color: var(--primary);
margin-bottom: 8px;
}
.progress-container {
background: var(--player-progress-bg);
height: 8px;
border-radius: var(--radius-sm);
cursor: pointer;
position: relative;
overflow: hidden;
}
.progress-bar {
background: var(--primary);
width: 0%;
height: 100%;
transition: width var(--transition-fast);
}
/* ==========================================================================
* 5. LISTE / TABELLE (LIST-SECTION)
* ========================================================================== */
.list-section h2 {
font-size: 1.2rem;
margin-bottom: 10px;
}
.responsive-table {
width: 100%;
border-collapse: collapse;
margin-top: 10px;
}
.responsive-table th,
.responsive-table td {
padding: 12px 10px;
text-align: left;
border-bottom: 1px solid var(--border);
vertical-align: middle;
}
.responsive-table th {
background: #f1f1f1;
font-weight: 600;
font-size: 0.9rem;
color: var(--text-muted);
text-transform: uppercase;
letter-spacing: 0.03em;
}
/* Vorschaubild */
.thumb-cell img {
width: 60px;
height: 60px;
object-fit: cover;
border-radius: var(--radius-md);
display: block;
}
.no-img,
.no-play {
color: var(--border);
}
/* Titel & Metadaten */
.item-title {
display: block;
word-break: break-word;
}
.item-date {
display: block;
color: var(--text-muted);
font-size: 0.8rem;
margin-top: 2px;
}
.src-link {
display: inline-block;
max-width: 300px;
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
vertical-align: bottom;
font-size: 0.78rem;
color: var(--text-muted);
text-decoration: none;
border-bottom: 1px dotted var(--border);
margin-top: 2px;
}
.src-link:hover {
color: var(--primary);
border-bottom-color: var(--primary);
}
/* Statusindikator */
.status-ok { color: var(--success); font-weight: 600; }
.status-error { color: var(--error); font-weight: 600; }
.status-waiting { color: var(--waiting); font-weight: 600; }
/* Aktion: Löschen */
.btn-delete {
color: var(--error);
text-decoration: none;
font-weight: 600;
padding: 6px 12px;
border: 1px solid var(--error);
border-radius: var(--radius-sm);
font-size: 0.9rem;
white-space: nowrap;
display: inline-block;
}
.btn-delete:hover {
background: var(--error);
color: var(--card-bg);
}
/* Aktion: Abspielen */
.play-cell {
text-align: center;
}
.btn-play {
background: none;
border: 1px solid var(--primary);
color: var(--primary);
border-radius: var(--radius-sm);
width: 38px;
height: 34px;
padding: 0;
font-size: 14px;
line-height: 1;
cursor: pointer;
font-family: inherit;
display: inline-flex;
align-items: center;
justify-content: center;
}
.btn-play:hover,
.btn-play.playing {
background: var(--primary);
color: var(--card-bg);
}
.empty-msg {
text-align: center;
color: var(--text-muted);
font-style: italic;
padding: 20px 0;
}
/* ==========================================================================
* 6. FOOTER & HINTERGRUND-ELEMENTE
* ========================================================================== */
footer {
margin-top: 40px;
text-align: center;
font-size: 0.9rem;
color: var(--text-muted);
}
footer a {
color: var(--primary);
}
#player {
display: none;
}
/* ==========================================================================
* 7. RESPONSIVE TRANSFORMATION (MOBILE VIEWPORTS <= 640px)
* ========================================================================== */
@media (max-width: 640px) {
body {
padding: 10px;
}
.container {
padding: 16px;
}
/* Formular */
.add-section form {
flex-direction: column;
}
button[type="submit"] {
width: 100%;
}
/* Tabellenkopf ausblenden */
.responsive-table thead {
display: none;
}
/* Tabellenstruktur auflösen */
.responsive-table,
.responsive-table tbody {
display: block;
width: 100%;
}
/* Zeilen in Karten transformieren */
.responsive-table tr {
display: grid;
width: 100%;
background: var(--card-bg);
border: 1px solid var(--border);
border-radius: var(--radius-lg);
margin-bottom: 12px;
padding: 12px;
grid-template-columns: 70px minmax(0, 1fr);
grid-template-areas:
"thumb title"
"status status"
"controls controls";
gap: 8px 12px;
align-items: center;
}
.responsive-table td {
display: block;
padding: 0;
border: none;
}
/* Card-Bereiche zuweisen */
.thumb-cell {
grid-area: thumb;
align-self: start;
}
.thumb-cell img {
width: 70px;
height: 70px;
}
.title-cell {
grid-area: title;
min-width: 0;
overflow: hidden;
}
.item-title {
word-break: break-word;
overflow-wrap: break-word;
}
.src-link {
display: block;
max-width: 100%;
}
.status-cell {
grid-area: status;
padding-top: 6px;
border-top: 1px dashed var(--border);
font-size: 0.85rem;
}
.status-cell::before {
content: "Status: ";
color: var(--text-muted);
font-weight: normal;
}
.action-cell {
grid-area: controls;
justify-self: start;
}
.play-cell {
grid-area: controls;
justify-self: end;
text-align: right;
}
}Und schließlich benötigen wir noch etwas Javascript in static/scripts.js:
Code static/scripts.js
// --- Wiedergabe-Steuerung -------------------------------------------
// Der aktuell spielende Button wird in einer Variablen gehalten.
// Ein URL-Vergleich (player.src === data-src) wäre unzuverlässig,
// weil player.src immer die absolute URL liefert.
const player = document.getElementById('player');
const playButtons = document.querySelectorAll('.btn-play');
let currentBtn = null;
// Elemente für den Fortschrittsbalken
const playerBar = document.getElementById('player-bar');
const progressBar = document.getElementById('progressBar');
const progressContainer = document.getElementById('progressContainer');
const playerTime = document.getElementById('playerTime');
function formatTime(seconds) {
if (isNaN(seconds)) return "0:00";
const mins = Math.floor(seconds / 60);
const secs = Math.floor(seconds % 60);
return `${mins}:${secs < 10 ? '0' : ''}${secs}`;
}
function setPlaying(btn, playing) {
if (!btn) return;
btn.textContent = playing ? '■' : '▶';
btn.classList.toggle('playing', playing);
}
playButtons.forEach(btn => {
btn.addEventListener('click', () => {
// Derselbe Titel läuft gerade -> pausieren
if (currentBtn === btn && !player.paused) {
player.pause();
setPlaying(btn, false);
return;
}
// Anderer Titel -> vorherigen Button zurücksetzen
if (currentBtn && currentBtn !== btn) {
setPlaying(currentBtn, false);
}
// Quelle nur bei einem Wechsel neu setzen.
// Beim Fortsetzen desselben Titels bleibt die Position erhalten.
if (currentBtn !== btn) {
player.src = btn.dataset.src;
currentBtn = btn;
// Player-Leiste einblenden, sobald ein Titel gewählt wird
if (playerBar) playerBar.style.display = 'block';
}
setPlaying(btn, true);
player.play().catch(err => {
console.error('Wiedergabefehler:', err);
setPlaying(btn, false);
currentBtn = null;
if (playerBar) playerBar.style.display = 'none';
});
});
});
// Aktualisierung des Fortschrittsbalkens während der Wiedergabe
player.addEventListener('timeupdate', () => {
if (player.duration && progressBar && playerTime) {
const percent = (player.currentTime / player.duration) * 100;
progressBar.style.width = `${percent}%`;
playerTime.textContent = `${formatTime(player.currentTime)} / ${formatTime(player.duration)}`;
}
});
// Fortschrittsbalken anklickbar machen (Springen im Audio)
if (progressContainer) {
progressContainer.addEventListener('click', (e) => {
const rect = progressContainer.getBoundingClientRect();
const pos = (e.clientX - rect.left) / rect.width;
if (player.duration) {
player.currentTime = pos * player.duration;
}
});
}
// Nach dem Ende zurücksetzen
player.addEventListener('ended', () => {
setPlaying(currentBtn, false);
currentBtn = null;
if (playerBar) playerBar.style.display = 'none';
});
// Bei Ladefehlern
player.addEventListener('error', () => {
setPlaying(currentBtn, false);
currentBtn = null;
if (playerBar) playerBar.style.display = 'none';
});
// --- Formular-Handling ----------------------------------------------
async function handleAdd(e) {
e.preventDefault();
const url = document.getElementById('urlInput').value.trim();
const msgDiv = document.getElementById('statusMsg');
const btn = e.target.querySelector('button');
btn.disabled = true;
btn.textContent = 'Senden …';
msgDiv.textContent = '';
msgDiv.className = '';
try {
const res = await fetch('/add', {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({url: url})
});
const data = await res.json();
if (res.ok) {
msgDiv.textContent = 'Download gestartet. Seite wird aktualisiert …';
msgDiv.className = 'success';
document.getElementById('urlInput').value = '';
setTimeout(() => location.reload(), 2500);
} else {
msgDiv.textContent = 'Fehler: ' + (data.error || 'Unbekannt');
msgDiv.className = 'error';
}
} catch (err) {
msgDiv.textContent = 'Netzwerkfehler';
msgDiv.className = 'error';
} finally {
btn.disabled = false;
btn.textContent = 'Hinzufügen';
}
}Optional sollten wir noch eine Bilddatei unter static/podcast_cover.jpg ablegen:
Speichern Sie diese (oder eine andere quadratische JPG-Bilddatei) unter static/podcast_cover.jpg. Nehmen Sie aber die 1400px-breite Originaldatei (öffnen in neuem Tab). Sie dient dann als unser „Podcast-Bild“ bzw. wird dann in der jeweiligen Podcast-App, innerhalb der wir später unseren privaten Podcast abonnieren, angezeigt.
Damit haben wir unser Programm bereits erstellt. Wir sollten es erst einmal testen. Wir befinden uns im Terminal ja noch in der venv-Umgebung und diese ist auch noch aktiviert (im Terminal steht „venv“ vor der Eingabe).
➜ Also starten wir unser kleines Programm erst einmal manuell:
python app.py
Es sollte keine Fehlermeldung im Terminal erscheinen (außer ggf. einige Warnmeldungen). In der app.py ist Port 5007 definiert. Dieser sollte natürlich nicht bereits durch eine andere laufende Anwendung auf dem Rechner bespielt sein. Dies würde eine Fehlermeldung im Terminal erzeugen bzw. das Programm würde nicht starten. Wenn eine solche nicht kommt, rufen wir im Browser die Nutzeroberfläche auf:
http://[LOKALE-IP-DES-RASPBERRY]:5007
Die lokale IP-Adresse des Rechners muss man natürlich kennen, bzw. man definiert diese in den Router-Einstellungen (s. o.).
Im Hintergrund wurden mehrere (temporäre) Dateien im download-Ordner abgelegt. Am Ende sollte dann jeweils nur eine MP3-Datei und eine Bilddatei übrigbleiben. Zudem wird im Stammverzeichnis automatisch eine Datei podsammler.db angelegt: Eine SQLITE-Datenbank mit den nötigen Metainformationen je Eintrag – ganz simpel.
Sie können danach auch unten auf den Link RSS-Feed: /feed.xml klicken: Dies ist die Podcast-Feed-Datei, um die es ja eigentlich geht. Denn deren URL kann dann in der Podcast-App abonniert– bzw. eingetragen werden.
Wenn alles funktioniert können wir die manuelle Ausführung des Programms in der Konsole beenden: CTRL + C. Wir verlassen dann auch die virtuelle Python-Umgebung mit der Eingabe von exit.
Werbung
Startdienst anlegen
Natürlich soll der PodSammler permanent laufen bzw. erreichbar sein – bereits nach dem Neustart des Raspberry Pi / des Servers. Dies geht einfach:
Wir legen eine neue Dienst-Datei an (die manuelle Ausführung ist bereits beendet):
sudo nano /etc/systemd/system/podsammler.service
Wir füllen sie mit diesem Inhalt:
[Unit] Description=PodSammler - Audio-Fundstuecke sammeln After=network-online.target Wants=network-online.target [Service] Type=simple User=pi Group=pi WorkingDirectory=/home/pi/podsammler ExecStart=/home/pi/podsammler/venv/bin/python /home/pi/podsammler/app.py Restart=on-failure RestartSec=5 [Install] WantedBy=multi-user.target
Achten Sie aber auf die Pfade. Ggf. liegt das Stammverzeichnis des Programms bei Ihnen an einem anderen Ort. Achten Sie zudem auf User und Group. Ggf. gilt bei Ihrem System eine andere Umgebung. Nicht einfach alles kopieren, ohne zu studieren.
Speichern mit STRG + S und den Editor verlassen mit STRG + X.
Nun laden wir den Daemon neu und aktivieren den neuen Dienst:
sudo systemctl daemon-reload sudo systemctl enable podsammler.service
Jetzt starten wir unseren neuen Dienst:
sudo systemctl start podsammler.service
Sicherheitshalber prüfen wir diesen:
sudo systemctl status podsammler.service
Es sollte alles im grünen Bereich sein („active running“).
Nach einem Neustart des Rechners (Raspberry Pi) sollte das Webinterface / das Programm also erreichbar sein.
yt-dlp gelegentlich aktualisieren
Wer aufmerksam gelesen hatte: PodSammler nutzt yt-dlp. Dieses Paket ist in unzähligen Projekten im Einsatz – nämlich immer dort, wo es darum geht, konkrete Video- oder Audio-Daten aus Websites zu extrahieren – wie auch in meinem Video-Übermittler für den Smart-TV. Dies ist ein Katz-und-Maus-Spiel und daher sollte yt-dlp gelegentlich aktualisiert werden:
/home/pi/podsammler/venv/bin/pip install --upgrade yt-dlp && sudo systemctl restart podsammler.service
Auch hier: ggf. den Pfad anpassen. Diesen Befehl sollte man via Cronjob vielleicht alle zwei Wochen einmal ausführen. Er startet sicherheitshalber auch den dazugehörigen Dienst neu, damit evtl. Änderungen direkt übernommen werden.
Werbung
Videos per Teilen-Funktion als Podcast-Episode hinzufügen
Zwar kann man das kleine Formular im Web-Interface nutzen, um neue Podcast-Episoden dem eigenen Feed hinzuzufügen. Eleganter ist es natürlich, wenn man dies direkt mit der Teilen-Funktion des Browsers auf dem Handy oder Tablet macht.
Ich nutze Android-Geräte und dort gibt es die eingangs bereits erwähnte App HTTP Shortcuts. Ob es so etwas für Apple-Geräte gibt, weiß ich nicht – vermutlich.
In ›HTTP Shortcuts‹ legt man als erstes eine Variable an:
Name: url
Wert: leer lassen
Teilen erlauben: ja, angehakt
Art der geteilten Daten: Nur Text
Alle anderen Optionen können so beibehalten bleiben.
Als nächstes legt man dort einen neuen Shortcut an:
Typ: Von Grund auf erstellen
Name: z. B. „URL an PodSammler senden “
Allgemeine Einstellungen
Methode: POST
URL: http://[IP-des-Raspberry]:5007/add
Request-Header
nicht gesetzt
Request-Body
Request-Body-Typ: Benutzerdefinierter Text
Content-Type: application/json
Request-Body:
{"url": "{url}"}„{url}“ ist hier unsere eben angelegte Variable und müsste ggf. mittels Button oder Dropdown oder ähnlich eingefügt werden (nicht eintippen).
Response-Einstellungen
Bei Erfolg: Response anzeigen
Bei Fehler: Vereinfachte Fehlermeldung anzeigen
Anzeige-Typ: Toast-Popup
Damit sollte die jeweilige URL direkt aus dem Browser an PodSammler übertragen werden können und ein in dieser Website eingebettetes Video sollte dann – nach etwas Rechenarbeit – als MP3 in unserem privaten Podcast verfügbar sein und natürlich auch in dessen Feed bzw. dann auch in der eigenen Podcast-App.
Kurzum
Mit meinem PodSammler bzw. mittels der Teilen-Funktion via ›HTTP Shortcuts‹ sammele ich diverse Fundstücke (Videos) im Netz und integriere sie per Klick in einen eigenen, privaten Podcast-Feed. Auf diesen greift meine Podcast-App zu und diese Episoden erscheinen dann dort neben den vielen anderen „regulären“ in meinem dortigen Posteingang – obwohl die Macher dieser Sendungen diese nie in einem Podcast-Dienst eingepflegt hatten: Die letzte Tagesschau bequem noch abends im Bett hören? Kein Problem.
db-tronic Raspberry Pi 4 4GB Starter Set | 64GB Edition | Netzteil 15W | Gehäuse rot/weiß | Kühlkörper Set | 4K Micro HDMI Kabel | Ideal für Smart Home, Retro Gaming & Home Assistant
Der Minicomputer Raspberry Pi eignet sich als kleiner, stromsparender Computer für zahlreiche Aufgaben: beispielsweise als Medienzentrale, Server, Netzwerkgerät oder für Archivierungs- und Automatisierungsaufgaben. Idealerweise kauft man den Raspi günstig im Set mit dem nötigen Zubehör.
Werbung | Preis(e) aktualisiert am 15. November 2026, inkl. MwSt., ggf. zzgl. Versandkosten | Alle Angaben ohne Gewähr
Sicherlich könnte man die URLs solcher, externen Medien auch in einem „Später-Lesen-Dienst“ speichern. Aber ich möchte ja alle Hör-Angebote an einem Ort (meiner Podcast-App) versammelt wissen, ohne zwischen mehreren Aggregatoren, Apps oder Websites hin und her wechseln zu müssen. Bei der Menge an Angeboten im Netz verliert man ansonsten schnell den Überblick.
Allerdings sollte der Server (hier mein Raspberry Pi), auf dem PodSammler läuft, permanent aus dem Internet erreichbar sein. Am einfachsten und sichersten gelingt dies, wenn das Smartphone oder Tablet eh ständig via VPN (WireGuard) mit dem Heimnetzwerk verbunden ist. Somit kommt man mobil zudem auch in den Genuss vieler weiterer lokalen Dienste, die auf dem Raspberry Pi daheim laufen (z. B. Pi-Hole).



