API-Dokumentation

Archivarix Tube Search bietet eine REST-API für programmatischen Zugriff auf archivierte YouTube-Video-Metadaten, Untertitel und KI-Zusammenfassungen. Diese Seite ist die vollständige API-Referenz.

Der API-Zugriff erfordert das Abonnement MCP + API. Siehe Preise für Details.

Authentifizierung

API-Schlüssel werden in Ihrem Profil → API-Tab erstellt. Fügen Sie den Schlüssel in jede Anfrage mit einem dieser Header ein:

X-API-Key: tsk_IHR_SCHLUESSEL

oder

Authorization: Bearer tsk_IHR_SCHLUESSEL

Schlüssel verwenden das Präfix tsk_. Halten Sie Ihren Schlüssel geheim — er gewährt vollen API-Zugriff auf Ihr Konto.

Endpunkte

Suche (Kanalsuche via SSE)

Die Kanalsuche ist ein zweistufiger Prozess: Erstellen einer Suchsitzung, dann Empfang der Ergebnisse über Server-Sent Events.

POST /api/search

Neue Kanalsuche starten.

Anfragekörper (JSON):

{
  "query": "@Handle oder Kanal-URL oder Video-URL/ID"
}

Antwort:

{
  "data": {
    "searchSessionId": "uuid",
    "sseEndpointUrl": "/api/search/uuid/stream",
    "channelId": "UCxxxxxx",
    "channelTitle": "Kanalname"
  }
}

GET /api/search/:sessionId/stream

Verbinden Sie sich mit dem SSE-Stream, um Ergebnisse in Echtzeit zu empfangen. Setzen Sie den Header Accept: text/event-stream. Siehe Abschnitt SSE-Protokoll für Ereignistypen.

POST /api/search/:sessionId/continue

Paginierte Suche fortsetzen — nächste Seite der Archivergebnisse laden.

GET /api/search/background-status/:channelId

Prüfen, ob eine Kanalsuche im Hintergrund läuft.

Antwort:

{
  "data": {
    "running": true,
    "searchSessionId": "uuid"
  }
}

Volltextsuche

GET /api/fts

Suche über alle indexierten Videotitel und -beschreibungen.

Abfrageparameter:

Untertitel

GET /api/subtitles/:videoId

Untertitel für ein Video herunterladen.

Abfrageparameter:

POST /api/subtitles/:videoId/fetch

Untertitel bei Bedarf über yt-dlp oder Wayback Machine abrufen. Startet eine Hintergrundaufgabe, wenn Untertitel noch nicht verfügbar sind.

POST /api/subtitles/bulk-download

Untertitel für mehrere Videos gleichzeitig herunterladen.

Anfragekörper (JSON):

{
  "videoIds": ["dQw4w9WgXcQ", "jNQXAC9IVRw"],
  "query": "optionale Hervorhebungsabfrage"
}

KI-Zusammenfassungen

POST /api/summary/generate

KI-Zusammenfassung für ein Video generieren. Erfordert verfügbare Untertitel.

Anfragekörper (JSON):

{
  "videoId": "dQw4w9WgXcQ",
  "private": false
}

Antwort (202 Accepted):

{
  "data": {
    "status": "generating",
    "videoId": "dQw4w9WgXcQ"
  }
}

GET /api/summary/:videoId

KI-Zusammenfassung für ein bestimmtes Video abrufen.

DELETE /api/summary/:videoId

Zusammenfassung löschen. Nur für Administratoren.

GET /api/summary/browse

Zusammenfassungen mit Filtern durchsuchen.

Abfrageparameter:

GET /api/summary/latest

Die zuletzt generierten Zusammenfassungen abrufen.

GET /api/summary/tags

Beliebte Tags über alle Zusammenfassungen abrufen.

GET /api/summary/languages

Verfügbare Sprachen für Zusammenfassungen mit Anzahl abrufen.

GET /api/summary/channels

Kanäle mit Zusammenfassungen abrufen.

Videostatus

GET /api/videos/:videoId/status-history

Statusänderungsverlauf eines Videos abrufen (z.B. live → deleted → re-uploaded).

System

GET /api/health

Endpunkt zur Statusprüfung. Gibt den Serverstatus zurück.

GET /api/features

Feature-Flags und Limits für den aktuellen Benutzer/Tarif abrufen.

GET /api/tiers

Tarifvergleichsdaten abrufen (Limits und Funktionen pro Stufe).

SSE-Protokoll

Der Kanalsuche-Stream sendet Server-Sent Events. Jedes Ereignis hat einen Typ und JSON-Daten:

Ratenlimits

API-Anfragen (MCP + API-Tarif) haben folgende Ratenlimits:

Bei Überschreitung eines Limits gibt die API HTTP 429 mit dem Fehlercode RATE_LIMITED zurück.

Fehlercodes

Alle Fehler geben JSON mit einem Fehlerobjekt zurück:

{"error": {"code": "RATE_LIMITED", "message": "Rate limit exceeded"}}

Beispiele

curl

# Kanalsuche starten
curl -X POST https://tube.archivarix.net/api/search \
  -H "X-API-Key: tsk_IHR_SCHLUESSEL" \
  -H "Content-Type: application/json" \
  -d '{"query": "@MrBeast"}'

# Ergebnisse empfangen (SSE)
curl -N https://tube.archivarix.net/api/search/SESSION_ID/stream \
  -H "X-API-Key: tsk_IHR_SCHLUESSEL" \
  -H "Accept: text/event-stream"

# Paginierte Suche fortsetzen
curl -X POST https://tube.archivarix.net/api/search/SESSION_ID/continue \
  -H "X-API-Key: tsk_IHR_SCHLUESSEL"

# Volltextsuche
curl "https://tube.archivarix.net/api/fts?q=geloeschtes+video&pageSize=20&sort=relevance" \
  -H "X-API-Key: tsk_IHR_SCHLUESSEL"

# Untertitel herunterladen (SRT)
curl https://tube.archivarix.net/api/subtitles/dQw4w9WgXcQ \
  -H "X-API-Key: tsk_IHR_SCHLUESSEL"

# Untertitel bei Bedarf abrufen
curl -X POST https://tube.archivarix.net/api/subtitles/dQw4w9WgXcQ/fetch \
  -H "X-API-Key: tsk_IHR_SCHLUESSEL"

# KI-Zusammenfassung generieren
curl -X POST https://tube.archivarix.net/api/summary/generate \
  -H "X-API-Key: tsk_IHR_SCHLUESSEL" \
  -H "Content-Type: application/json" \
  -d '{"videoId": "dQw4w9WgXcQ"}'

# Zusammenfassung abrufen
curl https://tube.archivarix.net/api/summary/dQw4w9WgXcQ \
  -H "X-API-Key: tsk_IHR_SCHLUESSEL"

# Zusammenfassungen nach Tag durchsuchen
curl "https://tube.archivarix.net/api/summary/browse?tag=music&limit=10" \
  -H "X-API-Key: tsk_IHR_SCHLUESSEL"

# Statusprüfung
curl https://tube.archivarix.net/api/health

Python

import requests

API_KEY = "tsk_IHR_SCHLUESSEL"
BASE = "https://tube.archivarix.net"
headers = {"X-API-Key": API_KEY}

# --- Kanalsuche ---
resp = requests.post(f"{BASE}/api/search",
    headers=headers,
    json={"query": "@MrBeast"})
session = resp.json()["data"]
search_id = session["searchSessionId"]

# Ergebnisse empfangen (SSE)
with requests.get(f"{BASE}/api/search/{search_id}/stream",
    headers={**headers, "Accept": "text/event-stream"},
    stream=True) as r:
    for line in r.iter_lines(decode_unicode=True):
        if line.startswith("data:"):
            print(line[5:])

# --- Volltextsuche ---
resp = requests.get(f"{BASE}/api/fts",
    headers=headers,
    params={"q": "geloeschtes Video", "pageSize": 20, "sort": "relevance"})
print(resp.json())

# --- Untertitel herunterladen ---
resp = requests.get(f"{BASE}/api/subtitles/dQw4w9WgXcQ",
    headers=headers,
    params={"format": "srt"})
with open("subtitles.srt", "w") as f:
    f.write(resp.text)

# --- KI-Zusammenfassung generieren ---
resp = requests.post(f"{BASE}/api/summary/generate",
    headers=headers,
    json={"videoId": "dQw4w9WgXcQ"})
print(resp.json())  # {"data": {"status": "generating", ...}}

# --- Zusammenfassung abrufen ---
resp = requests.get(f"{BASE}/api/summary/dQw4w9WgXcQ",
    headers=headers)
summary = resp.json()["data"]
print(summary["title"], summary["tags"])

JavaScript (Node.js / Browser)

const API_KEY = "tsk_IHR_SCHLUESSEL";
const BASE = "https://tube.archivarix.net";
const headers = { "X-API-Key": API_KEY };

// --- Kanalsuche ---
const searchResp = await fetch(`${BASE}/api/search`, {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({ query: "@MrBeast" }),
});
const { data: { searchSessionId } } = await searchResp.json();

// Ergebnisse empfangen (SSE)
const es = new EventSource(
  `${BASE}/api/search/${searchSessionId}/stream`
);
es.addEventListener("search:video", (e) => {
  const video = JSON.parse(e.data);
  console.log(video.title, video.videoId);
});
es.addEventListener("search:complete", () => es.close());

// --- Volltextsuche ---
const ftsResp = await fetch(
  `${BASE}/api/fts?q=geloeschtes+video&pageSize=20`,
  { headers }
);
const results = await ftsResp.json();

// --- Untertitel herunterladen ---
const subResp = await fetch(
  `${BASE}/api/subtitles/dQw4w9WgXcQ?format=srt`,
  { headers }
);
const srtText = await subResp.text();

// --- KI-Zusammenfassung generieren ---
const sumResp = await fetch(`${BASE}/api/summary/generate`, {
  method: "POST",
  headers: { ...headers, "Content-Type": "application/json" },
  body: JSON.stringify({ videoId: "dQw4w9WgXcQ" }),
});
console.log(await sumResp.json());

// --- Zusammenfassungen durchsuchen ---
const browseResp = await fetch(
  `${BASE}/api/summary/browse?tag=music&limit=10`,
  { headers }
);
console.log(await browseResp.json());