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.

Bildschirmfoto: Web-Interface von eigenem Podcast-Sammeldienst

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:

Smartphone liegt auf hellem Hintergrund, darin eine Podcast-App geöffnet

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:

Smartphone (Ausschnitt) vor hellem Hintergrund mit App, die eine URL an diverse Dienste teilen kann.

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:

Raspberry Pi an Wand montiert
Mit dem Raspberry Pi lassen sich die tollsten Dinge anstellen. Ich nutze ihn täglich für sehr viele Aufgaben → Wozu ich meinen Raspberry Pi alles nutze

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.

Amazon

Preis: € 154,99

auf Amazon ansehenWerbung

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.

Selbstverständlich erfolgt die Nutzung dieses Konzepts auf eigene Gefahr. Ich habe mir den PodSammler für meine eigenen Bedürfnisse erstellt – teile den Code jedoch gerne, weil es so etwas (derzeit) offenbar anderweitig nicht gibt.

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:
Icon der Anwendung PodSammler (beinhaltet typische Icons für Podcasts wie Mikrofon, Play-Button usw.)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.).

Bildschirmfoto: Web-Interface von eigenem Podcast-Sammeldienst
Das Web-Interface des PodSammlers sollte nun erreichbar- und bedienbar sein. Fügen Sie oben zum Test die URL eines (kurzen) YouTube-Videos ein, klicken Sie auf „Hinzufügen“ und warten Sie. Aktualisieren Sie die Seite mehrmals. Irgendwann sollte „Fertig“ erscheinen bzw. die Option, den Ton dieses Videos direkt auf dieser Seite abspielen zu können.

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.

Amazon

Preis: € 154,99

auf Amazon ansehenWerbung

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.

schematische Darstellung Youtube-Kanal in Podcast-Feed umwandeln via Raspberry Pi
Lesen Sie bei Interesse auch: YouTube-Kanäle als Podcast-Feed abonnieren

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).

Kommentar schreiben

Hier gibt es die Möglichkeit für Resonanz. Pflichtfelder sind mit * markiert.

Kommentare erscheinen nicht sofort bzw. werden manuell freigegeben. Mit dem Absenden des Formulars stimmen Sie der Datenschutzerklärung zu bzw., dass Ihre eingegebenen Daten gespeichert werden. IP-Adressen werden dabei grundsätzlich nicht gespeichert.