Skip to content

Technik Blog

IoT, Smart Home & Mikrocontroller einfach erklärt

Menu
  • Smarthome
  • Gartenautomation
  • Mikrocontroller
    • Arduino
    • ESP32 & Co.
    • Calliope Mini
    • Raspberry Pi & Pico
  • Solo Mining
  • Über mich
Menu

Wie viele Token verbraucht Claude? Mein Mini-Display zeigt’s

Veröffentlicht am 18. November 202614. November 2026 von Stefan Draeger

Wie viele Token verbrauche ich bei der Arbeit mit Claude? Mein Claude-Tokenmonitor zeigt mir die Tages-, Wochen- und Monatsübersicht direkt auf dem Schreibtisch. Dafür habe ich einen vorhandenen Krypto-Ticker umprogrammiert: Auf dem GeekMagic SmallTV mit ESP8266 und MicroPython läuft jetzt mein eigenes kleines Dashboard.

Ein kurzer Blick auf das Display genügt, um den bisherigen Verbrauch zu sehen. Gerade beim Programmieren und bei längeren KI-Projekten möchte ich nachvollziehen können, wie sich meine Nutzung über den Tag und die Woche entwickelt. Die Anzeige bringt diese Werte auf ein eigenes Gerät neben dem Computer.

Vom Mini-TV zum Claude-Tokenmonitor – GeekMagic SmallTV umprogrammieren
Dieses Video auf YouTube ansehen.

Die Grundlage dafür habe ich im Beitrag GeekMagic SmallTV umprogrammieren: Originalfirmware sichern und MicroPython installieren geschaffen. Dort geht es vom Firmware-Backup bis zur ersten Text- und Bildausgabe. Hier bekommt das Display mit dem Claude-Tokenmonitor eine konkrete Aufgabe.

Alle Beispiele für den SmallTV findest du in meinem GitHub-Repository GeekMagicSmallTV-MicroPython. Die Projekte sind in eigenen Verzeichnissen abgelegt und jeweils mit einer README.md beschrieben. Dort findest du auch die Dateien für den Claude-Tokenmonitor mit PC-Bridge und MicroPython-Programm.

Claude Tokenmonitor - Startscreen
Claude Tokenmonitor – Startscreen
Claude Tokenmonitor - aktueller Verbrauch
Claude Tokenmonitor – aktueller Verbrauch

Inhaltsverzeichnis

  • Was ist der GeekMagic SmallTV und wo bekommst du ihn?
    • SmallTV Ultra und SmallTV Pro unterscheiden
  • Architektur: So kommen die Claude-Daten auf das Mini-Display
    • Welche Aufgabe übernimmt die Bridge?
    • Welche Aufgabe übernimmt der ESP8266?
  • Die PC-Bridge: Claude-Code-Verbrauch auslesen und bereitstellen
    • Woher stammen die Verbrauchsdaten?
    • Welche Token werden gezählt?
    • Wie verarbeitet die Bridge neue Einträge?
    • Die Bridge starten und zunächst am PC prüfen
    • Welche Daten erhält das Display?
  • Den Claude-Tokenmonitor auf dem GeekMagic SmallTV Ultra einrichten
    • WLAN und Verbindung zur Bridge konfigurieren
    • Programm, Schriftdateien und Logo übertragen
    • Vom JSON zum Dashboard
    • Erster Start und Verhalten bei Verbindungsproblemen
  • Fazit: Mein Claude-Code-Verbrauch auf einen Blick
  • Quellen und weiterführende Links
    • Projektdateien und verwendeter Treiber
    • Dokumentation und Herstellerangaben
    • Vorbereitung des SmallTV

Was ist der GeekMagic SmallTV und wo bekommst du ihn?

Der GeekMagic SmallTV ist ein kleines Schreibtischgadget im Look eines Mini-Fernsehers. Es verbindet einen WLAN-fähigen Mikrocontroller mit einem 1,54-Zoll-Farbdisplay mit 240×240 Pixeln. Die Stromversorgung erfolgt über USB-C. Mit eigener Firmware lässt sich daraus eine Anzeige für Projekte wie meinen Claude-Tokenmonitor machen. Bei meinem Gerät funktioniert die Displayansteuerung mit dem ST7789-Treiber.

GeekMagic SmallTV mit Ausgabe von Hello World auf dem Display
GeekMagic SmallTV mit Ausgabe von Hello World auf dem Display
ESP8266 Chip am GeekMagic SmallTV
ESP8266 Chip am GeekMagic SmallTV
GeekMagic SmallTV - Platine und Display
GeekMagic SmallTV – Platine und Display
GeekMagic SmallTV - geöffnet
GeekMagic SmallTV – geöffnet
CH340 Serial-USB Konverter im GeekMagic SmallTV
CH340 Serial-USB Konverter im GeekMagic SmallTV

Du bekommst die Geräte in verschiedenen Gehäusefarben unter anderem bei AliExpress. Je nach Angebot starten die Preise bereits bei knapp 11 Euro. Das ist eine Momentaufnahme: Modell, Farbe, Rabattaktionen und Versandkosten können den Endpreis verändern. Achte deshalb vor allem darauf, welche Hardware du tatsächlich auswählst.

SmallTV Ultra und SmallTV Pro unterscheiden

Der Hersteller führt die ESP8266-Ausführung aktuell als SmallTV Ultra. Daneben gibt es das SmallTV Pro mit ESP32. Die wichtigsten Unterschiede für unser Projekt:

MerkmalSmallTV UltraSmallTV Pro
MikrocontrollerESP8266EXESP32
Flashspeicher laut Hersteller4 MB8 MB
Display1,54 Zoll, 240×240 Pixel, IPS1,54 Zoll, 240×240 Pixel, IPS
BedienungEinrichtung über den BrowserEinrichtung über den Browser und Touch-Button auf der Oberseite
StromversorgungUSB-C, 5 VUSB-C, 5 V

Für meinen Tokenmonitor verwende ich den vorhandenen Jingle Mining CryptoTracker mit ESP8266EX und 4 MB Flashspeicher. Der ESP32 des Pro-Modells bietet mehr Leistungsreserven, benötigt aber eine zu seiner Hardware passende Firmware. Die MicroPython-Firmware für den ESP8266 darfst du deshalb nicht auf das Pro-Modell übertragen.

Mein CryptoTracker besitzt außerdem einen eingebauten CH340 als USB-Seriell-Wandler. Damit kann ich ihn direkt am Computer programmieren. Diese Ausstattung ist nicht bei jeder SmallTV-Ausführung vorhanden: Ein USB-C-Anschluss allein garantiert keine serielle Datenverbindung. Prüfe diese Eigenschaft vor dem Kauf, wenn du den Umbau wie in meinem vorherigen Beitrag durchführen möchtest.

Architektur: So kommen die Claude-Daten auf das Mini-Display

Damit der GeekMagic SmallTV meinen Claude-Tokenverbrauch anzeigen kann, benötigt er die passenden Daten. Dafür verwende ich eine Bridge, die auf meinem PC läuft. Sie übernimmt den Zugriff auf die Claude-Verbrauchsdaten und stellt diese als JSON bereit. Der PC bildet damit die Verbindung zwischen der Datenquelle und dem Mini-Display.

Diese Aufteilung vereinfacht die Umsetzung: Die Bridge kümmert sich um das Einlesen und Aufbereiten der Daten. Das MicroPython-Programm auf dem ESP8266 verarbeitet die bereitgestellten Werte und zeichnet daraus das Dashboard auf dem Display.

Architektur in zwei Zeilen: Claude-Verbrauchsdaten und Bridge auf dem PC, JSON-Übertragung zum ESP8266 und Darstellung auf dem SmallTV-Display.
Die Bridge auf dem PC bereitet die Claude-Verbrauchsdaten auf. Der ESP8266 verarbeitet die JSON-Werte und zeichnet das Dashboard auf dem SmallTV.

Welche Aufgabe übernimmt die Bridge?

Die Bridge bereitet die Verbrauchsdaten so auf, dass das Display sie direkt verwenden kann. JSON ist dabei das Austauschformat: Es ordnet Werte eindeutigen Bezeichnungen zu. Das MicroPython-Programm kann dadurch die benötigten Angaben aus der Antwort auslesen und für die Anzeige verwenden.

Ändert sich später der Zugriff auf die Datenquelle, kann ich die Bridge entsprechend anpassen. Solange die Struktur der JSON-Daten gleich bleibt, muss ich die Darstellung auf dem SmallTV dafür nicht ändern.

Welche Aufgabe übernimmt der ESP8266?

Der ESP8266 übernimmt die Anzeige. Aus den übermittelten JSON-Daten liest das MicroPython-Programm die benötigten Werte aus und stellt sie als Zahlen, Balken und Diagramme auf dem 240 × 240 Pixel großen Display dar.

Die Bridge bleibt dabei ein notwendiger Bestandteil des Aufbaus: Neue Verbrauchswerte stehen nur zur Verfügung, solange der PC und die Bridge laufen und für das Display erreichbar sind. Der SmallTV dient als kompakte zusätzliche Anzeige für die vom PC bereitgestellten Daten.

Die PC-Bridge: Claude-Code-Verbrauch auslesen und bereitstellen

Claude Code speichert seine Gesprächsprotokolle lokal auf dem Computer. Diese Dateien enthalten neben den Nachrichten auch Angaben zum Tokenverbrauch. Genau diese Informationen nutzt meine Bridge: Sie liest die vorhandenen Protokolle, fasst die Verbrauchswerte zusammen und stellt das Ergebnis über einen kleinen HTTP-Server bereit. Der SmallTV holt diese Daten anschließend über das WLAN ab.

Erfasst wird die lokal protokollierte Nutzung von Claude Code auf diesem PC. Gespräche aus der Claude-Weboberfläche oder der Smartphone-App werden dadurch nicht automatisch berücksichtigt. Auch die Nutzung auf weiteren Computern fehlt, solange deren Protokolle nicht einbezogen werden.

Woher stammen die Verbrauchsdaten?

Standardmäßig sucht die Bridge unter ~/.claude/projects nach Dateien mit der Endung .jsonl. Unter Windows liegt dieser Ordner normalerweise im Benutzerverzeichnis, beispielsweise unter C:\Users\stefa\.claude\projects. Ist die Umgebungsvariable CLAUDE_CONFIG_DIR gesetzt, verwendet das Skript stattdessen dieses Verzeichnis als Ausgangspunkt und sucht dort im Unterordner projects.

JSONL bedeutet, dass jede Zeile ein eigenes JSON-Objekt enthält. Die Bridge durchsucht diese Einträge nach Verbrauchsangaben und übernimmt die zugehörigen Tokenzahlen, das Modell und den Zeitpunkt.

Dafür benötigt sie keinen API-Schlüssel und stellt keine zusätzlichen Anfragen an Claude. Die Auswertung erfolgt anhand der bereits vorhandenen lokalen Dateien.

Welche Token werden gezählt?

Die große Zahl auf dem Display setzt sich aus mehreren Tokenarten zusammen:

  • Input: Eingabetoken außerhalb der gesonderten Cache-Kategorien.
  • Output: Token der erzeugten Antworten.
  • Cache Read: Token aus erneut verwendetem Kontext.
  • Cache Write: Token, die zum Aufbau des Caches verarbeitet wurden.

Die Anzeige zählt damit mehr als nur den Text, den du selbst eingibst und als Antwort liest. Gerade wiederholt verwendeter Kontext kann einen großen Anteil ausmachen. Eine hohe Tokenzahl lässt sich deshalb nicht direkt mit entsprechend hohen Kosten gleichsetzen.

Für die zeitliche Zuordnung verwendet die Bridge das lokale Datum des PCs. Die Wochenübersicht beginnt am Montag, die Monatsübersicht am ersten Tag des aktuellen Monats. Das Balkendiagramm zeigt dagegen die letzten sieben Kalendertage einschließlich heute.

Wie verarbeitet die Bridge neue Einträge?

Beim Start liest das Skript die vorhandenen Protokolldateien ein. Anschließend merkt es sich für jede Datei die zuletzt gelesene Position. Bei einer weiteren Auswertung verarbeitet es nur die neu hinzugekommenen vollständigen Zeilen.

Auch mehrfach protokollierte Zwischenstände einer gestreamten Antwort werden berücksichtigt: Einträge mit derselben Kombination aus Nachrichten-ID und Request-ID ersetzen den vorherigen Stand. Dadurch werden diese Zwischenstände nicht einfach mehrfach addiert.

Im Serverbetrieb wird bei einer Anfrage geprüft, ob die letzte Dateiauswertung mindestens zehn Sekunden zurückliegt. Die Bridge aktualisiert die Werte somit bei Bedarf; sie liest die Dateien nicht unabhängig von Anfragen alle zehn Sekunden neu ein.

Die Bridge starten und zunächst am PC prüfen

Das Skript heißt usage_bridge.py und benötigt Python 3.9 oder neuer. Zusätzliche Python-Pakete sind nicht erforderlich, da ausschließlich Module der Standardbibliothek verwendet werden.

Die Datei usage_bridge.py findest du zusammen mit den übrigen Projektdateien im GitHub-Repository zum SmallTV. Lade für den Nachbau die zusammengehörigen Dateien des Tokenmonitors herunter und beachte die Hinweise in der zugehörigen README.md. Den Bridge-Code kannst du auch direkt hier aufklappen.

Python Bridge usage_bridge.py zum sammeln und bereitstellen von Claude Session Daten
"""Claude-Code-Tokenverbrauch fuer das GeekMagic SmallTV bereitstellen.

Liest die lokalen Claude-Code-Transkripte (~/.claude/projects/**/*.jsonl),
summiert den Tokenverbrauch und liefert eine kleine JSON-Antwort per HTTP,
die das SmallTV im WLAN abholt.

Start:
    python usage_bridge.py              # HTTP-Server auf Port 8765
    python usage_bridge.py --once       # einmal ausgeben und beenden
    python usage_bridge.py --port 9000 --bind 0.0.0.0

Nur Standardbibliothek, Python 3.9+.
"""

from __future__ import annotations

import argparse
import json
import os
import socket
import threading
import time
import functools
from datetime import date, datetime, timedelta
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path

# Preise in USD pro 1 Mio. Tokens: (input, output, cache_read).
# Nur eine Schaetzung zu API-Listenpreisen; bei einer Enterprise-Lizenz
# zahlt ihr pro Sitz, nicht pro Token. Laengster passender Praefix gewinnt.
PRICES = {
    "claude-fable-5-2": (8.00, 40.00, 0.20),
    "claude-mythos-5-2": (8.00, 40.00, 0.20),
    "claude-fable-5": (10.00, 50.00, 1.00),
    "claude-mythos-5": (10.00, 50.00, 1.00),
    "claude-opus-5-5": (4.00, 20.00, 0.20),
    "claude-opus-5": (5.00, 25.00, 0.50),
    "claude-opus-4": (5.00, 25.00, 0.50),
    "claude-sonnet-5-5": (2.00, 10.00, 0.10),
    "claude-sonnet-5": (2.00, 10.00, 0.20),
    "claude-sonnet-4": (3.00, 15.00, 0.30),
    "claude-haiku-5-5": (0.10, 0.50, 0.01),
    "claude-haiku-4": (1.00, 5.00, 0.10),
}
CACHE_WRITE_5M = 1.25  # Faktor auf den Input-Preis
CACHE_WRITE_1H = 2.0

print = functools.partial(print, flush=True)  # sofort ins Log schreiben

WEEKDAYS = "MDMDFSS"  # Mo..So


def projects_dir() -> Path:
    base = os.environ.get("CLAUDE_CONFIG_DIR")
    root = Path(base) if base else Path.home() / ".claude"
    return root / "projects"


def price_for(model: str):
    best = None
    for prefix, price in PRICES.items():
        if model.startswith(prefix) and (best is None or len(prefix) > len(best[0])):
            best = (prefix, price)
    return best[1] if best else None


class UsageStore:
    """Liest JSONL-Dateien inkrementell und haelt eine Nachricht pro ID."""

    def __init__(self, root: Path):
        self.root = root
        self.offsets: dict[Path, int] = {}
        # (message.id, requestId) -> (lokales Datum, model, in, out, cache_read, cw5m, cw1h)
        self.entries: dict[tuple, tuple] = {}
        self.lock = threading.Lock()

    def refresh(self) -> None:
        with self.lock:
            if not self.root.is_dir():
                return
            for path in self.root.rglob("*.jsonl"):
                try:
                    size = path.stat().st_size
                except OSError:
                    continue
                start = self.offsets.get(path, 0)
                if size < start:  # Datei wurde gekuerzt/ersetzt
                    start = 0
                if size == start:
                    continue
                self.offsets[path] = self._read_from(path, start)

    def _read_from(self, path: Path, start: int) -> int:
        with open(path, "rb") as fh:
            fh.seek(start)
            data = fh.read()
        end = data.rfind(b"\n")
        if end < 0:  # noch keine vollstaendige Zeile
            return start
        for raw in data[: end + 1].splitlines():
            self._ingest(raw)
        return start + end + 1

    def _ingest(self, raw: bytes) -> None:
        if b'"usage"' not in raw:
            return
        try:
            rec = json.loads(raw)
        except ValueError:
            return
        msg = rec.get("message")
        if not isinstance(msg, dict):
            return
        usage = msg.get("usage")
        model = msg.get("model") or ""
        ts = rec.get("timestamp")
        if not isinstance(usage, dict) or not ts or model.startswith("<"):
            return
        try:
            day = datetime.fromisoformat(ts.replace("Z", "+00:00")).astimezone().date()
        except ValueError:
            return
        cache = usage.get("cache_creation") or {}
        cw_total = usage.get("cache_creation_input_tokens") or 0
        cw1h = cache.get("ephemeral_1h_input_tokens") or 0
        cw5m = cache.get("ephemeral_5m_input_tokens")
        if cw5m is None:
            cw5m = max(cw_total - cw1h, 0)
        key = (msg.get("id") or id(rec), rec.get("requestId"))
        # Gestreamte Antworten stehen mehrfach im Log; der letzte Eintrag gewinnt.
        self.entries[key] = (
            day,
            model,
            usage.get("input_tokens") or 0,
            usage.get("output_tokens") or 0,
            usage.get("cache_read_input_tokens") or 0,
            cw5m,
            cw1h,
        )

    def summary(self) -> dict:
        today = date.today()
        week_start = today - timedelta(days=today.weekday())
        month_start = today.replace(day=1)
        days = [today - timedelta(days=i) for i in range(6, -1, -1)]
        per_day = {d: 0 for d in days}

        t_in = t_out = t_cr = t_cw = 0
        week = month = 0
        usd = 0.0
        unpriced = set()

        with self.lock:
            for day, model, i, o, cr, cw5m, cw1h in self.entries.values():
                total = i + o + cr + cw5m + cw1h
                if day in per_day:
                    per_day[day] += total
                if day >= month_start:
                    month += total
                if day >= week_start:
                    week += total
                if day != today:
                    continue
                t_in += i
                t_out += o
                t_cr += cr
                t_cw += cw5m + cw1h
                price = price_for(model)
                if price is None:
                    unpriced.add(model)
                    continue
                p_in, p_out, p_cr = price
                usd += (
                    i * p_in
                    + o * p_out
                    + cr * p_cr
                    + cw5m * p_in * CACHE_WRITE_5M
                    + cw1h * p_in * CACHE_WRITE_1H
                ) / 1_000_000

        return {
            "t": datetime.now().strftime("%H:%M"),
            "today": t_in + t_out + t_cr + t_cw,
            "in": t_in,
            "out": t_out,
            "cr": t_cr,
            "cw": t_cw,
            "week": week,
            "month": month,
            "usd": round(usd, 2),
            "days": [per_day[d] for d in days],
            "dl": "".join(WEEKDAYS[d.weekday()] for d in days),
            "unpriced": sorted(unpriced),
        }


class Handler(BaseHTTPRequestHandler):
    store: UsageStore
    min_interval = 10.0
    _last_refresh = 0.0

    def do_GET(self):  # noqa: N802
        if self.path.split("?")[0] not in ("/", "/usage"):
            self.send_error(404)
            return
        now = time.monotonic()
        if now - Handler._last_refresh >= self.min_interval:
            self.store.refresh()
            Handler._last_refresh = now
        body = json.dumps(self.store.summary(), separators=(",", ":")).encode()
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(body)))
        self.send_header("Connection", "close")
        self.end_headers()
        self.wfile.write(body)

    def log_message(self, fmt, *args):
        print("%s %s" % (self.address_string(), fmt % args))


def local_ips() -> list[str]:
    """IPv4-Adressen dieses Rechners (ohne Loopback/Link-local)."""
    try:
        infos = socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET)
    except OSError:
        return []
    ips = {info[4][0] for info in infos}
    return sorted(ip for ip in ips if not ip.startswith(("127.", "169.254.")))


def main() -> None:
    ap = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    ap.add_argument("--bind", default="0.0.0.0", help="Adresse (Standard: alle)")
    ap.add_argument("--port", type=int, default=8765)
    ap.add_argument("--once", action="store_true", help="einmal ausgeben und beenden")
    args = ap.parse_args()

    store = UsageStore(projects_dir())
    t0 = time.monotonic()
    store.refresh()
    print(
        "%d Antworten aus %d Dateien in %.1fs gelesen (%s)"
        % (len(store.entries), len(store.offsets), time.monotonic() - t0, store.root)
    )
    if args.once:
        print(json.dumps(store.summary(), indent=2))
        return

    Handler.store = store
    Handler._last_refresh = time.monotonic()
    server = ThreadingHTTPServer((args.bind, args.port), Handler)
    if args.bind in ("0.0.0.0", ""):
        hosts = ["localhost"] + local_ips()
    else:
        hosts = [args.bind]
    print("Bridge laeuft. Erreichbar unter:")
    for host in hosts:
        print("  http://%s:%d/usage" % (host, args.port))
    print("Fuer config.py BRIDGE_HOST die IP aus dem WLAN des SmallTV nehmen.")
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        pass


if __name__ == "__main__":
    main()

Für einen ersten Test lässt sich die Auswertung einmalig starten. Führe den folgenden Befehl in PowerShell im Ordner mit dem Skript aus:

python usage_bridge.py --once

Das Skript gibt zunächst die Anzahl der eingelesenen Antworten und Dateien aus. Anschließend folgt die Zusammenfassung als JSON. Damit kannst du prüfen, ob die Bridge deine Claude-Code-Protokolle findet, bevor das Display ins Spiel kommt.

Den HTTP-Server startest du mit:

python usage_bridge.py

Standardmäßig verwendet die Bridge Port 8765. Auf demselben PC kannst du die JSON-Antwort im Browser unter http://localhost:8765/usage aufrufen.

Für den SmallTV brauchst du später die lokale IP-Adresse des PCs. Die Bridge gibt beim Start mögliche Adressen aus. Verwende die Adresse des Netzwerkadapters, über den der PC im selben lokalen Netz wie der SmallTV erreichbar ist. localhost würde auf dem SmallTV das Gerät selbst bezeichnen.

Die Bridge lauscht standardmäßig auf allen IPv4-Netzwerkschnittstellen. Falls die Windows-Firewall den Zugriff blockiert, muss die Verbindung für das verwendete private Netzwerk zugelassen werden. Der einfache HTTP-Server besitzt keine Anmeldung; eine Portfreigabe ins Internet ist für diesen Aufbau nicht vorgesehen.

Welche Daten erhält das Display?

Die Antwort enthält bewusst kurze Feldnamen, die das MicroPython-Programm auslesen kann:

JSON-FeldBedeutung
tAktuelle Uhrzeit des PCs
todayGesamte Tokenzahl für heute
in, outHeutige Eingabe- und Ausgabetoken
cr, cwHeutige Cache-Read- und Cache-Write-Token
weekTokenzahl seit Montag
monthTokenzahl seit Monatsbeginn
usdGeschätzter API-Vergleichswert für heute
daysTokenzahlen der letzten sieben Tage, ältester Tag zuerst
dlPassende Wochentagskürzel für das Diagramm
unpricedHeute verwendete Modelle ohne passenden Preiseintrag

Der als „API-Wert“ angezeigte Betrag wird anhand einer fest im Skript hinterlegten Preistabelle berechnet. Er ist ein rechnerischer Vergleichswert und keine Abrechnung deines Claude-Abonnements. Wie gut die Schätzung passt, hängt von den hinterlegten Modellpreisen ab; diese müssen bei Preisänderungen angepasst werden. Modelle ohne passenden Preiseintrag zählen weiterhin zur Tokenmenge, fehlen aber in dieser Kostenschätzung und erscheinen unter unpriced.

Sobald die JSON-Antwort am PC erreichbar ist, steht die Datengrundlage für das Display. Im nächsten Schritt verbinden wir den ESP8266 mit dem WLAN und lassen ihn die Werte von der Bridge abrufen.

Den Claude-Tokenmonitor auf dem GeekMagic SmallTV Ultra einrichten

Nachdem die Bridge die Verbrauchsdaten bereitstellt, übernimmt der SmallTV die Anzeige. Das MicroPython-Programm verbindet sich mit dem WLAN, ruft die JSON-Antwort vom PC ab und zeichnet daraus das Dashboard. Neben dem heutigen Tokenverbrauch zeigt es Wochen- und Monatswerte, den geschätzten API-Vergleichswert und ein Balkendiagramm für die letzten sieben Tage.

Die Dateien findest du im GitHub-Verzeichnis 03_ClaudeAI-Tokenmonitor. Der Unterordner bridge enthält das PC-Skript. Unter device liegen das MicroPython-Programm, eine Konfigurationsvorlage und die benötigten Grafikdateien.

WLAN und Verbindung zur Bridge konfigurieren

Damit das Programm unverändert bleiben kann, stehen die persönlichen Einstellungen in einer separaten Datei. Kopiere dafür device/config.example.py als config.py und passe sie an deinen Aufbau an:

WIFI_SSID = "MeinWLAN"
WIFI_PASSWORD = "DEIN_WLAN_PASSWORT"

BRIDGE_HOST = "192.168.178.20"
BRIDGE_PORT = 8765

POLL_SECONDS = 60
DAILY_GOAL = 20000000
SPI_BAUD = 10000000

Bei BRIDGE_HOST trägst du die lokale IP-Adresse des PCs ein, auf dem die Bridge läuft. Verwende nur die Adresse, ohne http:// und ohne /usage. Den Pfad ergänzt das Programm beim Abruf selbst. Der Port muss mit dem gestarteten Bridge-Server übereinstimmen.

POLL_SECONDS legt die Pause zwischen den Abrufversuchen fest. Mit 60 wartet das Programm nach jedem Durchlauf eine Minute. Der tatsächliche Abstand kann durch Verbindungsaufbau und Datenübertragung etwas länger sein.

Der Wert DAILY_GOAL bestimmt den Bezugswert für den Fortschrittsbalken. Hier sind das 20 Millionen Token einschließlich Cache-Token. Dieser Wert ist frei gewählt und kein von Claude gemeldetes Nutzungslimit. Mit 0 deaktivierst du den Balken.

SPI_BAUD stellt die Übertragungsgeschwindigkeit zum Display ein. Für meinen Aufbau verwende ich 10 MHz.

Programm, Schriftdateien und Logo übertragen

Das Dashboard benötigt neben main.py mehrere vorbereitete Grafikdateien. Die Schriftzeichen und das Logo werden aus diesen Dateien gelesen und auf das Display gezeichnet. Übertrage deshalb auch den vollständigen Ordner assets.

Datei im RepositoryZiel auf dem SmallTV
device/main.py/main.py
Deine angepasste config.py/config.py
device/assets/big.fnt/assets/big.fnt
device/assets/val.fnt/assets/val.fnt
device/assets/lbl.fnt/assets/lbl.fnt
device/assets/logo.bin/assets/logo.bin
lib/st7789py.py aus dem Repository-Hauptverzeichnis/lib/st7789py.py

Die Ordner device und bridge dienen der Strukturierung im Repository. Auf dem SmallTV liegen main.py und config.py direkt im Hauptverzeichnis. Auch assets und lib werden dort angelegt.

Sichere eine vorhandene main.py, beispielsweise vom vorherigen Displaytest, bevor du sie ersetzt. Verwende außerdem die im Repository enthaltene Treiberdatei, damit Programm und Treiberschnittstelle zusammenpassen.

Vom JSON zum Dashboard

Das Programm fragt die Bridge über HTTP unter /usage ab. Nach einer erfolgreichen Antwort liest es die JSON-Felder aus und aktualisiert die Anzeige.

Große Tokenzahlen werden für das kleine Display gekürzt: Aus Millionenwerten wird beispielsweise eine Anzeige wie 9,9M. Darunter stehen die Werte für die aktuelle Kalenderwoche, den Monat und der geschätzte API-Vergleichswert für heute.

Der Fortschrittsbalken zeigt den Tagesverbrauch im Verhältnis zu deinem eingestellten DAILY_GOAL. Unter 70 Prozent ist er türkis, ab 70 Prozent orange und ab Erreichen des Bezugswerts rot.

Das Diagramm zeigt die letzten sieben Tage. Seine Balkenhöhen orientieren sich am höchsten Wert dieses Zeitraums; der heutige Tag ist türkis hervorgehoben. Die Wochentagskürzel und die Uhrzeit stammen aus der Antwort der Bridge.

Um unnötiges Neuzeichnen zu vermeiden, merkt sich das Programm bereits dargestellte Werte und aktualisiert die betroffenen Bereiche bei Änderungen.

Erster Start und Verhalten bei Verbindungsproblemen

Starte zunächst die Bridge auf dem PC und anschließend /main.py über Thonny. Während des Verbindungsaufbaus zeigt der SmallTV einen Startbildschirm mit dem Hinweis „WLAN …“. Sobald die erste gültige Antwort vorliegt, erscheint das Dashboard.

Ein kleines Statusquadrat signalisiert das Ergebnis des letzten Abrufs: Grün bedeutet erfolgreich, Rot weist auf einen Fehler hin. Bricht die Verbindung nach einer erfolgreichen Anzeige ab, bleiben die zuletzt dargestellten Werte stehen. Sie werden erst nach einem weiteren erfolgreichen Abruf aktualisiert. Die angezeigte Uhrzeit läuft in dieser Zeit ebenfalls nicht weiter.

Claude Tokenmonitor - Startscreen
Claude Tokenmonitor – Startscreen

Fehler gibt das Programm zusätzlich in der MicroPython-Shell aus. Nach der eingestellten Pause versucht es den Abruf erneut.

Da das Programm als main.py auf dem Gerät liegt, startet es nach einem Neustart automatisch. Für aktuelle Verbrauchswerte müssen die Bridge und der PC weiterhin erreichbar sein.

Fazit: Mein Claude-Code-Verbrauch auf einen Blick

Aus meinem vorhandenen Krypto-Ticker ist eine Anzeige für den Claude-Code-Tokenverbrauch geworden. Ein Blick auf den GeekMagic SmallTV genügt, um den heutigen Verbrauch, die Wochen- und Monatswerte sowie die Entwicklung der letzten sieben Tage zu sehen.

Die Kombination aus PC-Bridge und MicroPython lässt sich dabei gut anpassen: Der Computer übernimmt die Auswertung der lokalen Protokolle, während sich der ESP8266 um die Darstellung kümmert. Tagesziel und Abfrageintervall kann ich über die Konfiguration verändern.

Die Grenzen gehören dazu: Erfasst werden die auf dem PC vorhandenen Claude-Code-Protokolle. Für aktuelle Werte müssen der Computer und die Bridge laufen. Der angezeigte API-Vergleichswert bleibt eine Schätzung anhand der hinterlegten Preise und entspricht keiner Abrechnung meines Claude-Abonnements.

Für mich zeigt das Projekt vor allem, wie sich ein kleines Schreibtischgadget mit eigener Software weiterverwenden lässt. Die Grundlage steht auch für weitere Anzeigen: Über eine angepasste Bridge könnten später zusätzliche Datenquellen hinzukommen.

Wenn du den Tokenmonitor nachbauen oder eigene Ideen umsetzen möchtest, findest du die Beispiele und Projektdateien in meinem GitHub-Repository GeekMagicSmallTV-MicroPython.

Quellen und weiterführende Links

Projektdateien und verwendeter Treiber

  • GeekMagicSmallTV-MicroPython auf GitHub: Beispielsammlung mit Quellcode und README-Anleitungen.
  • Claude-Code-Tokenmonitor: PC-Bridge, MicroPython-Programm, Konfigurationsvorlage und Grafikdateien für diesen Aufbau.
  • Im Projekt enthaltener ST7789-Treiber: Die zu den Beispielen gehörende Treiberdatei. Verwende diese Version, damit die Schnittstellen zusammenpassen.

Dokumentation und Herstellerangaben

  • MicroPython-Dokumentation für den ESP8266: Offizielle Referenz zu WLAN, SPI und GPIO. Wähle für versionsabhängige Details die Dokumentation deiner installierten Firmware.
  • GeekMagic SmallTV Ultra: Herstellerangaben zum ESP8266-Modell, zum Display und zur Stromversorgung.
  • GeekMagic SmallTV Pro: Herstellerangaben zum ESP32-Modell und zum Touch-Button; Grundlage für die Modellabgrenzung im Beitrag.

Vorbereitung des SmallTV

  • GeekMagic SmallTV umprogrammieren: Originalfirmware sichern und MicroPython installieren: Mein vorheriger Beitrag zum Firmware-Backup, zur Einrichtung und zu den ersten Displaytests.
Transparenzhinweis: Dieser Beitrag wurde mit Unterstützung künstlicher Intelligenz erstellt und redaktionell geprüft. Mehr zur Nutzung von KI

Letzte Aktualisierung am: 14. November 2026

Foto von Stefan Draeger
Über den Autor

Stefan Draeger — Entwickler & Tech-Blogger

Ich zeige praxisnah, wie du Projekte mit Arduino, ESP32 und Smarthome-Komponenten umsetzt – Schritt für Schritt, mit Code und Schaltplänen.

Mehr Artikel von Stefan →
Schlagwörter: Claude, ESP8266, GeekMagic SmallTV, micropython, Tokenmonitor, Tokenverbrauch

Schreibe einen Kommentar Antwort abbrechen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Kategorien

Kontakt & Hilfe

Fragen oder Feedback?

Du hast eine Idee, brauchst Hilfe oder möchtest Feedback loswerden? Erstelle einfach ein Support-Ticket.

Support-Ticket erstellen
Keine Beiträge verpassen

Newsletter abonnieren

Erhalte regelmäßig Updates zu neuen Projekten, Tutorials und Tipps rund um Arduino, ESP32, Smarthome und IoT direkt in dein Postfach.

Newsletter abonnieren
Videos & Tutorials

Draeger-IT auf YouTube

Entdecke meine Videos zu Arduino, ESP32, Raspberry Pi, Smarthome und spannenden Elektronikprojekten – mit Tutorials, Tests und Praxisbeispielen.

YouTube-Kanal besuchen
Freiwillige Unterstützung

Unterstütze meinen Blog

Wenn dir meine Inhalte gefallen, freue ich mich über deine Unterstützung auf Tipeee. So hilfst du dabei, den Blog am Leben zu halten und neue Beiträge zu ermöglichen.

Auf Tipeee unterstützen

Vielen Dank für deinen Support!
– Stefan Draeger

Kostenlose Online-Werkzeuge

Tools

Praktische Generatoren, Rechner und Hilfsmittel für deine Elektronik- und Entwicklungsprojekte.

Generatoren & Konverter

  • QR-Code Generator
  • Passwort Generator
  • PNG zu WebP konvertieren
  • Bilder online komprimieren
  • Code online formatieren

Rechner & Tabellen

  • Unix-Zeitstempel-Rechner
  • ASCII-Tabelle
  • ASCII Code umrechnen – Text, Dezimal, Hex & Binär
  • Spannung, Strom, Widerstand und Leistung berechnen
  • Widerstandsrechner

LED-Matrix

  • 8×8 LED Matrix Tool
  • 8×16 LED Matrix Modul von Keyestudio
  • 16×16 LED Matrix Generator
Kontakt

Anschrift & Kontaktdaten

Stefan Draeger

Königsberger Str. 13
38364 Schöningen

Telefon 01556 5432686

E-Mail info@draeger-it.blog

Blogverzeichnis Bloggerei.de TopBlogs.de das Original - Blogverzeichnis | Blog Top Liste Blogverzeichnis trusted-blogs.com
Social Media

Folge mir auf

Weitere Projekte, Videos und Neuigkeiten findest du auch auf meinen Social-Media-Kanälen.

  • f Facebook
  • in LinkedIn
  • ▶ YouTube
  • ♪ TikTok
  • P Pinterest
  • ◎ Instagram
Rechtliche Informationen

Rechtliches

  • Impressum
  • Datenschutzerklärung
  • Disclaimer
  • Cookie-Richtlinie (EU)
  • KI-Transparenz bei draeger-it.blog
©2026 Technik Blog | Built using WordPress and Responsive Blogily theme by Superb
Cookie-Zustimmung verwalten
Wir verwenden Technologien wie Cookies, um Geräteinformationen zu speichern und/oder darauf zuzugreifen. Wir tun dies, um das Surferlebnis zu verbessern und um personalisierte Werbung anzuzeigen. Wenn Sie diesen Technologien zustimmen, können wir Daten wie das Surfverhalten oder eindeutige IDs auf dieser Website verarbeiten. Wenn Sie Ihre Zustimmung nicht erteilen oder zurückziehen, können bestimmte Funktionen beeinträchtigt werden.
Funktional Immer aktiv
Die technische Speicherung oder der Zugang ist unbedingt erforderlich für den rechtmäßigen Zweck, die Nutzung eines bestimmten Dienstes zu ermöglichen, der vom Teilnehmer oder Nutzer ausdrücklich gewünscht wird, oder für den alleinigen Zweck, die Übertragung einer Nachricht über ein elektronisches Kommunikationsnetz durchzuführen.
Vorlieben
Die technische Speicherung oder der Zugriff ist für den rechtmäßigen Zweck der Speicherung von Präferenzen erforderlich, die nicht vom Abonnenten oder Benutzer angefordert wurden.
Statistiken
Die technische Speicherung oder der Zugriff, der ausschließlich zu statistischen Zwecken erfolgt. Die technische Speicherung oder der Zugriff, der ausschließlich zu anonymen statistischen Zwecken verwendet wird. Ohne eine Vorladung, die freiwillige Zustimmung deines Internetdienstanbieters oder zusätzliche Aufzeichnungen von Dritten können die zu diesem Zweck gespeicherten oder abgerufenen Informationen allein in der Regel nicht dazu verwendet werden, dich zu identifizieren.
Marketing
Die technische Speicherung oder der Zugriff ist erforderlich, um Nutzerprofile zu erstellen, um Werbung zu versenden oder um den Nutzer auf einer Website oder über mehrere Websites hinweg zu ähnlichen Marketingzwecken zu verfolgen.
  • Optionen verwalten
  • Dienste verwalten
  • Verwalten von {vendor_count}-Lieferanten
  • Lese mehr über diese Zwecke
Einstellungen anzeigen
  • {title}
  • {title}
  • {title}