Owncast Plugin APIs

Die Owncast-Plugin-Laufzeit stellt eine globale Funktion owncast zur Verfügung, mit den Host-Funktionen, die Ihr Plugin aufrufen kann. Most methods require the matching permission in your manifest. A call without it never reaches Owncast: the host logs the denial and the call does nothing. What your plugin sees depends on the method. Mutating calls that report an outcome raise an error (moderation, users.register, auth.grantSession, kv.set, videoConfig.write, actions.add, actions.clear, and every sql method), readers return an empty or zero value, and calls that return nothing become silent no-ops. fs.write, fs.delete, and storage.upload are the exceptions: they report failure in their return value rather than raising. A few methods are ambient and need no permission: logging, timers, reading bundled assets, and owncast.config.get.

Plugin APIs require Owncast v0.3.0

Plugins require Owncast 0.3.0 or later.

Aufrufe werden für beide SDKs angezeigt, wählen Sie Ihre Sprache über die Registerkarten. Siehe JavaScript oder Python für die Einrichtung. (JavaScript-Methode-Namen sind camelCase, Python verwendet snake_case, sodass sendAction zu send_action wird, und so weiter.)

Logging

`owncast.log.info(message)`, `.warning(message)`, and `.error(message)`

Write an operator-visible entry to Owncast's server log. Owncast records the calling plugin's slug and the matching info, warning, or error severity. It replaces control characters with spaces so each entry stays on one line, then truncates messages longer than 4 KiB.

JavaScript
Python

owncast.log.info('sync started');
owncast.log.warning('provider response is incomplete');
owncast.log.error('sync failed');

owncast.log.info("sync started")
owncast.log.warning("provider response is incomplete")
owncast.log.error("sync failed")

Ambient: keine Berechtigung erforderlich. See the paired chat-logger examples for JavaScript and Python.

Chat

Bauen Sie einen Chatbot, ein Moderationstool oder einen Filter? Beginnen Sie mit Chat-Plugins.

`owncast.chat.send(text)`

Posten Sie eine Chat-Nachricht. Gesendet als die Identität des Bots Ihres Plugins (Anzeigename von bot.displayName oder name in Ihrem Manifest).

JavaScript
Python

owncast.chat.send('hello chat');

owncast.chat.send("hello chat")

Benötigt chat.send.

`owncast.chat.sendAction(text)`

Posten Sie eine Aktionsstil-Nachricht ("/me").

JavaScript
Python

owncast.chat.sendAction('is now live');

owncast.chat.send_action("is now live")

Benötigt chat.send.

`owncast.chat.system(body)`

Posten Sie eine Serverankündigungsnachricht. Keine Bot-Identität angehängt. Der Text wird inline als HTML gerendert, verwenden Sie dies für kurze, serverzugeordnete Hinweise wie "Der Stream beginnt in 5 Minuten". Behandeln Sie den Text als unsicheren HTML-Ausgabe: interpolieren Sie keine Benutzereingaben, ohne sie zu maskieren.

Requires chat.send.

`owncast.chat.sendTo(clientId, text)`

Senden Sie eine private Nachricht an einen einzelnen verbundenen Client.

Requires chat.send.

`owncast.chat.replyTo(msg, text)`

Flüstern Sie eine Antwort an den Absender einer Chat-Nachricht zurück. Übergeben Sie die Chat-Nachricht von onChatMessage/filterChatMessage (oder einer einfachen Client-ID). Gibt false zurück, wenn die Verbindung des Absenders unbekannt ist (keine Client-ID), sodass Sie auf ein öffentliches send zurückgreifen können. Zucker über sendTo(clientId, text).

JavaScript
Python

onChatMessage(msg) {
  if (!owncast.chat.replyTo(msg, "got it")) {
    owncast.chat.send("got it");
  }
}

@plugin.on_chat_message
def handle(msg):
    if not owncast.chat.reply_to(msg, "got it"):
        owncast.chat.send("got it")

Benötigt chat.send.

`owncast.chat.history(limit?)`

Gibt die neuesten Chat-Nachrichten zurück, jede mit id, user, body und timestamp. limit beträgt standardmäßig 50.

Benötigt chat.history.

`owncast.chat.clients()`

Return the list of currently-connected chat clients, each with id, userId?, displayName?, connectedAt?, userAgent?, ipAddress?, and messageCount. id ist die Client-ID für jede Verbindung, die von chat.kick verwendet wird.

Benötigt chat.history.

`owncast.chat.deleteMessage(messageId)`

Blenden Sie eine Chat-Nachricht vor den Zuschauern aus.

Requires chat.moderate.

`owncast.chat.kick(clientId)`

Trennen Sie einen Chat-Client.

Requires chat.moderate.

Chat-Identität

Jedes Plugin hat genau eine Chat-Identität, den Bot, den Owncast bereitstellt, wenn Ihr Plugin installiert wird. Der Anzeigename ist der bot.displayName Ihres Manifests, falls gesetzt, andernfalls dessen name, mit IsBot: true. Sowohl send als auch sendAction posten als diese Identität über den normalen Chat-Pipeline von Owncast (Filter, Ratenbegrenzungen, Moderation). Plugins können nicht unter beliebigen Namen posten oder echte Benutzer nachahmen.

Der Botbenutzer wird anhand des slug des Plugins zugeordnet, damit die Identität nach Bearbeitungen des Manifests zu name oder bot.displayName erhalten bleibt. Wenn Sie mehrere Chat-Personas benötigen, liefern Sie mehrere Plugins aus.

Benutzer

`owncast.users.list()` und `owncast.users.get(id)`

Lesen Sie die Chat-Benutzerliste oder einen einzelnen Benutzer-Datensatz.

JavaScript
Python

const users = owncast.users.list();
const alice = owncast.users.get('u-alice');

users = owncast.users.list()
alice = owncast.users.get("u-alice")

Benötigt users.read.

`owncast.users.setEnabled(id, enabled, reason?)`

Aktivieren oder Deaktivieren eines Chat-Benutzers.

JavaScript
Python

owncast.users.setEnabled('u-spammer', false, 'spam');

owncast.users.set_enabled("u-spammer", False, "spam")

Benötigt users.moderate.

`owncast.users.banIP(ip)`

Sperren Sie eine IP, um dem Chat beizutreten.

JavaScript
Python

owncast.users.banIP('203.0.113.42');

owncast.users.ban_ip("203.0.113.42")

Benötigt users.moderate.

`owncast.users.register({ authId, displayName?, scopes?, profileUrl?, handle?, public? })`

Find or create an authenticated Owncast user for an external identity and return { userId }. Pass the provider's stable authId without adding your plugin slug. The host stores the slug separately as the identity provider, so plugins cannot collide with or spoof each other's users. displayName seeds a new user's name and is optional: omit it, or pass null, and Owncast generates a display name the same way it does for anonymous viewers. Non-empty scopes such as ["MODERATOR"] are applied on each call.

The optional profileUrl, handle, and public fields describe a verified external identity. profileUrl must be empty or an absolute HTTP(S) URL. handle is the provider's verified label, such as a GitHub login or fediverse handle. Set public to true only after the viewer opts into public display. It defaults to false. These profile fields are captured when the identity is first registered. Later calls with the same authId return the existing user but do not change the stored profile fields.

JavaScript
Python

const { userId } = owncast.users.register({
  authId: 'github:583231',
  displayName: 'octocat',
  profileUrl: 'https://github.com/octocat',
  handle: 'octocat',
  public: false, // Set true only after the viewer opts in.
});

result = owncast.users.register(
    "github:583231",
    display_name="octocat",
    profile_url="https://github.com/octocat",
    handle="octocat",
    public=False,  # Set true only after the viewer opts in.
)
user_id = result.user_id

Benötigt users.register.

Authentifizierung

Diese ermöglichen ein Viewer-Authentifizierungs-Gateway. grantSession und endSession funktionieren nur innerhalb eines onHttpRequest Handlers, da der Host das Sitzungscookie an die in-flight HTTP-Antwort anhängt.

`owncast.auth.grantSession({ userId, ttl? })`

Geben Sie eine signierte Sitzung für einen bereits registrierten Benutzer aus (der userId von owncast.users.register). Der Host mint, signiert und hängt das Sitzungscookie an die aktuelle Antwort; Ihr Plugin sieht das Token niemals, sodass es es nicht fälschen oder leaken kann. ttl ist eine optionale Lebensdauer in Sekunden (0/weggelassen verwendet den Standard des Hosts von 24 Stunden).

JavaScript
Python

const { userId } = owncast.users.register({ authId: 'shared', displayName: 'Guest' });
owncast.auth.grantSession({ userId });
return { status: 302, headers: { Location: returnTo } };

result = owncast.users.register("shared", display_name="Guest")
owncast.auth.grant_session(result.user_id)
return {"status": 302, "headers": {"Location": return_to}}

Benötigt auth.gate.

`owncast.auth.endSession()`

Löschen Sie das Sitzungscookie des aktuellen Zuschauers in dieser Antwort, um sie auszuloggen. Ihr Plugin kontrolliert weiterhin die Umleitung (und kann auf die Abmeldung des Anbieters umleiten).

JavaScript
Python

owncast.auth.endSession();
return { status: 302, headers: { Location: '/' } };

owncast.auth.end_session()
return {"status": 302, "headers": {"Location": "/"}}

Benötigt auth.gate.

Speicher

`owncast.kv.get(key)` und `owncast.kv.set(key, value)`

Pro-Plugin Schlüssel/Wert-Speicher, namespaced durch den slug Ihres Plugins. Die Werte sind Zeichenfolgen.

Für reichhaltigere Typen verwenden Sie die JSON-Helfer (getJSON / setJSON, get_json / set_json in Python) anstelle von Parsing und Serialisierung selbst. Der JSON-Getter gibt den Fallback zurück, wenn der Schlüssel nicht gesetzt ist oder ungültiges JSON enthält. Plugins können die Schlüssel anderer Plugins nicht lesen.

JavaScript
Python

owncast.kv.set('count', '1');
const n = Number(owncast.kv.get('count') ?? '0');

owncast.kv.setJSON('prefs', { theme: 'dark' });
const prefs = owncast.kv.getJSON('prefs', {});

owncast.kv.set("count", "1")
n = int(owncast.kv.get("count") or "0")

owncast.kv.set_json("prefs", {"theme": "dark"})
prefs = owncast.kv.get_json("prefs", {})

Benötigt storage.kv.

`owncast.storage.upload(name, data)`

Laden Sie eine Datei in den öffentlichen Dateiordner von Owncast hoch. JavaScript accepts a Uint8Array or string. Python accepts bytes or str. Raw bytes are preserved, while strings are encoded as UTF-8. JavaScript returns { url } or null. Python returns a dict accessed as result["url"], or None.

Benötigt storage.upload.

`owncast.fs.*`

A private, sandboxed filesystem at data/plugin-storage/\<your-slug>/files/. Im Gegensatz zu owncast.storage.upload bleiben diese Dateien serverseitig: sie werden niemals über HTTP bereitgestellt. Die Pfade sind relativ zu Ihrem Sandbox-Root. Der Host beschränkt jeden Pfad auf Ihr eigenes Verzeichnis (ein Plugin kann keine Dateien eines anderen Plugins lesen, und ../ oder absolute Pfade collapsen zurück innerhalb der Sandbox). Übergeordnete Verzeichnisse werden nach Bedarf beim Schreiben erstellt.

JavaScript	Python	Gibt zurück
`fs.read(pfad)`	`fs.read(path)`	`Uint8Array` / `bytes`, or `null` / `None` if missing
`fs.readText(pfad)`	`fs.read_text(path)`	UTF-8 `string` / `str`, or `null` / `None` if missing
`fs.write(pfad, daten)`	`fs.write(path, data)`	`{ error? }`
`fs.list(verzeichnis)`	`fs.list(dir)`	Eintragsnamen (ein fehlendes Verzeichnis ist leer)
`fs.delete(pfad)`	`fs.delete(path)`	`{ error? }` for a file or empty directory
`fs.exists(pfad)`	`fs.exists(path)`	boolesch

fs.read preserves the original bytes. fs.readText and fs.read_text decode UTF-8. Python replaces malformed byte sequences when decoding. fs.write preserves a JavaScript Uint8Array or Python bytes, and UTF-8 encodes strings. fs.write and fs.delete return {} on success. If the host rejects the operation, they return { error } with the reason.

JavaScript
Python

owncast.fs.write('notes/log.txt', 'hello');
const text = owncast.fs.readText('notes/log.txt');

const data = new Uint8Array([0xff, 0x00, 0x80]);
owncast.fs.write('cache/data.bin', data);
const stored = owncast.fs.read('cache/data.bin');
if (stored) owncast.storage.upload('data.bin', stored);

owncast.fs.write("notes/log.txt", "hello")
text = owncast.fs.read_text("notes/log.txt")

data = bytes((0xFF, 0x00, 0x80))
owncast.fs.write("cache/data.bin", data)
stored = owncast.fs.read("cache/data.bin")
if stored is not None:
    owncast.storage.upload("data.bin", stored)

Benötigt storage.fs.

`owncast.sql.*`

One private SQLite database per plugin, at data/plugin-storage/\<your-slug>/db/plugin.db, separate from Owncast's own database and from the storage.fs sandbox. The sandbox is rooted at files/, so db/ is not a path owncast.fs.* refuses but one it cannot express, and the filesystem quota walk covers files/ only, so the two quotas stay independent. Reach for this over storage.kv when you need to sort, filter, or aggregate rather than just remember a value.

Method	Returns
`sql.exec(sql, params?)`	`{ rowsAffected, lastInsertId }`
`sql.query(sql, params?)`	rows as objects keyed by column name
`sql.queryRow(sql, params?)`	the first row object, or `null` when nothing matched

In Python queryRow is query_row, rows come back as dicts, and query_row returns None when nothing matched. An error throws in JavaScript and raises RuntimeError in Python. Parameters are null/None, booleans, numbers, or strings. Anything else is refused.

JavaScript
Python

owncast.sql.exec(`CREATE TABLE IF NOT EXISTS chatters (
  user_id  TEXT PRIMARY KEY,
  messages INTEGER NOT NULL DEFAULT 0
)`);

owncast.sql.exec(
  `INSERT INTO chatters (user_id, messages) VALUES (?, 1)
   ON CONFLICT (user_id) DO UPDATE SET messages = messages + 1`,
  [msg.user.id],
);

const top = owncast.sql.query(
  'SELECT user_id, messages FROM chatters ORDER BY messages DESC LIMIT ?',
  [5],
);
const mine = owncast.sql.queryRow('SELECT messages FROM chatters WHERE user_id = ?', [msg.user.id]);

owncast.sql.exec("""
    CREATE TABLE IF NOT EXISTS chatters (
      user_id  TEXT PRIMARY KEY,
      messages INTEGER NOT NULL DEFAULT 0
    )
""")

owncast.sql.exec(
    """
    INSERT INTO chatters (user_id, messages) VALUES (?, 1)
    ON CONFLICT (user_id) DO UPDATE SET messages = messages + 1
    """,
    [msg.user.id],
)

top = owncast.sql.query(
    "SELECT user_id, messages FROM chatters ORDER BY messages DESC LIMIT ?",
    [5],
)
mine = owncast.sql.query_row("SELECT messages FROM chatters WHERE user_id = ?", [msg.user.id])

Each exec call runs as one host-owned transaction. A multi-statement batch commits whole or leaves the database untouched, so a schema migration can't half-apply. A plugin cannot leave a transaction open across calls, so there's nothing to clean up either.

query never hands back a silently short result. A query that overruns the row cap or the result budget is an error telling you to add a LIMIT, so write the bound you actually want when a table grows with your audience. queryRow reads a single row, which keeps it cheap on a table query is too big for.

Limit	Value
Encoded request	64 KiB total JSON
Bound parameters	64 per call
Returned column value	1 MiB
Encoded query result	1 MiB
Rows returned	10000
Call duration	2 seconds
Database size	128 MiB

Ordinary SQL is unaffected: DDL, DML, indexes, views, triggers, ORDER BY, recursive CTEs, subqueries, UNION, and the json1 functions all work. Refused in every host: ATTACH, DETACH, every PRAGMA (reads included), temporary-schema DDL both as keywords (CREATE TEMP TABLE / INDEX / TRIGGER / VIEW) and schema-qualified (CREATE TABLE temp.x), load_extension(), VACUUM and VACUUM INTO, and transaction controls (BEGIN, COMMIT, END, ROLLBACK, SAVEPOINT, and RELEASE). exec already owns the transaction around the whole batch.

Owncat cautions youJavaScript loses precision above 2^53

Parameters and results cross the host boundary as JSON. Python can bind and read exact 64-bit SQLite integers. JavaScript loses unsafe integers before JSON.stringify on writes and during JSON.parse on reads. Store values above Number.MAX_SAFE_INTEGER (2^53 - 1) as TEXT when a JavaScript plugin needs them to remain exact.

Requires storage.sql. For a worked example, the chat-leaderboard plugin covers schema creation in one atomic exec, an ON CONFLICT upsert, a bounded ranked query, and a single-row read, in both JavaScript and Python. It contrasts with message-counter, which keeps the same counts in storage.kv and cannot rank.

Konfiguration

`owncast.config.get(schlüssel, fallback?)`

Lese eine der von deinem Plugin deklarierten manifest-„config“-Einstellungen. Gibt den vom Administrator festgelegten Wert zurück, wenn vorhanden, andernfalls den deklarierten Standard, der bereits auf den deklarierten Typ geparst wurde. Für einen unbekannten Schlüssel (oder einen ohne Wert) gibt es fallback zurück.

JavaScript
Python

const cooldownMs = owncast.config.get('cooldownMs', 2000);

cooldown_ms = owncast.config.get("cooldownMs", 2000)

Ambient: no permission required. Bevorzuge dies gegenüber der Erstellung einer individuellen Einstellungsseite und der Zuordnung von Schlüssel/Wert für einfache Knöpfe. (Der Konfigurationsschlüssel ist das, was du im Manifest benannt hast, und er ist nicht sprachabhängig.)

Netzwerk

`owncast.http.fetch(url, opts?)`

Synchroner ausgehender HTTP-Anruf. opts enthält methode, header und körper. Das Ergebnis ist { status, header, body }. Nur Hosts, die in network.allowedHosts deines Manifests aufgeführt sind, sind erreichbar. Alles andere gibt einen Fehler zurück.

JavaScript
Python

const res = owncast.http.fetch('https://api.example.com/status');
if (res.status === 200) {
  const data = JSON.parse(res.body);
}

import json

res = owncast.http.fetch("https://api.example.com/status")
if res.status == 200:
    data = json.loads(res.body)

Benötigt network.fetch und einen passenden Eintrag in network.allowedHosts. Verwende dies für ausgehendes HTTP, anstatt den eigenen HTTP-Client deiner Sprache (in Python, verwende nicht requests: es wird nicht in ein Plugin kompiliert).

Siehe Manifestverweis: Netzwerk für die Erlauben-Syntax.

Plugin-zu-Plugin-Ereignisse

`owncast.events.emit(eventType, payload)`

Emit to a custom hook owned by another plugin. eventType is the fully qualified \<recipient-slug>.\<hook> target. The host dispatches that exact name and does not add the emitter's slug. The receiving plugin declares only its local hook name. See the handlers reference.

JavaScript
Python

owncast.events.emit('announcer.announcement.broadcast', { text: 'We are live' });

owncast.events.emit("announcer.announcement.broadcast", {"text": "We are live"})

Benötigt events.emit.

Stream- und Serverstatus

`owncast.stream.current()`

Der aktuelle Status des Livestreams: { online, title?, zusammenfassung?, zuschauer, startedAt?, latencyLevel? }`.

Requires server.read.

`owncast.stream.broadcaster()`

Eingehende Encode-Telemetrie für die aktuelle Verbindung: { remoteAddr?, codecs?, auflösungen?, bildfrequenzen?, bitrates? }`. Schreibgeschützt und nullwertig, wenn keine Übertragung verbunden ist. Um die Videoausgabe zu ändern, siehe die Gruppe Video-Konfiguration unten.

Benötigt server.read.

`owncast.server.info()`

Statische Serverinfo: { name?, url?, zusammenfassung?, wilkommensnachricht?, version? }`.

JavaScript
Python

const name = owncast.server.info().name;

name = owncast.server.info().name

Benötigt server.read.

`owncast.server.socials()`

The streamer's configured social links, each { platform, url, icon? }.

Requires server.read.

`owncast.server.emotes()`

Die benutzerdefinierten Chat-Emotes des Servers: derselbe Satz, den der öffentliche /api/emoji-Endpunkt bereitstellt, jeder { name, url }. Nützlich zum Rendern oder Filtern von :code:-Emotes auf Serverseite.

Benötigt server.read.

`owncast.server.federation()`

Whether fediverse federation is enabled and under what handle: { enabled, username?, isPrivate? }. username is omitted when unset, and isPrivate is present only when true.

Benötigt server.read.

`owncast.server.tags()`

Die konfigurierten Tags des Streamers, als Liste von Strings.

Benötigt server.read.

Video- und Transcodierungsconfigurierung

`owncast.videoConfig.read()`

Returns the current VideoConfig.

Field	Type	Values
`latencyLevel`	number	`0` through `4`
`codec`	string	Configured ffmpeg encoder name
`autoplay`	string	`off`, `always`, or `sound-only`
`variants`	`StreamVariant[]`	Configured output renditions

codec reads can report a legacy value or an encoder added by a newer host. Writes accept libx264, h264_omx, h264_vaapi, h264_qsv, h264_nvenc, h264_v4l2m2m, or h264_videotoolbox. Hardware codecs require the matching encoder in the host's ffmpeg build.

Autoplay off requires the viewer to press play. always starts automatically and may fall back to muted playback. sound-only starts automatically only when the browser allows sound.

Each StreamVariant has these fields:

Field	Type	Description
`width`	number	Scaled output width
`height`	number	Scaled output height
`framerate`	number	Output frames per second
`videoBitrate`	number	Video bitrate in kbps
`cpuUsageLevel`	number	Processing usage from `0` (lowest) through `4` (highest)
`isPassthrough`	boolean	Pass video through without transcoding

Audio settings are not exposed to plugins. Owncast preserves the existing audio configuration for each variant a plugin updates.

JavaScript
Python

const cfg = owncast.videoConfig.read();

cfg = owncast.video_config.read()

Benötigt videoconfig.read.

`owncast.videoConfig.write(partial)`

Update any of the VideoConfig fields above. Übergebe ein Teilobjekt. Nur die Felder, die du einfügst, werden geändert. Änderungen treten beim nächsten Streamstart in Kraft: der Host startet eine aktive Übertragung nicht neu.

JavaScript
Python

owncast.videoConfig.write({ latencyLevel: 2, autoplay: "sound-only" });

owncast.video_config.write({"latencyLevel": 2, "autoplay": "sound-only"})

Benötigt videoconfig.write. Dies ist hochriskant. Administratoren sollten dies sparsam gewähren.

Benachrichtigungen

`owncast.notifications.discord(text)`

Sende eine Discord-Benachrichtigung über den konfigurierten Webhook des Streamers.

Benötigt notifications.send.

`owncast.notifications.browserPush({ titel, körper, url?` })`

Push an abonnierte Browser.

JavaScript
Python

owncast.notifications.browserPush({ title: 'Live now', body: 'Come say hi', url: '/' });

owncast.notifications.browser_push({"title": "Live now", "body": "Come say hi", "url": "/"})

Benötigt notifications.send.

`owncast.notifications.fediverse({ typ, körper, bild?, link?` })`

Sende eine im Fediverse formatierte Benachrichtigung (wird als Beitrag an Follower gerendert).

Benötigt notifications.send.

Fediverse

`owncast.fediverse.post(text)`

Mache einen öffentlichen Post an das Fediverse vom Owncast-Konto.

Returns { url } on success (currently with an empty url: Owncast publishes the note but does not yet return its URL), or null when the host rejects the call.

Benötigt fediverse.post. Hohe Vertrauenswürdigkeit: Ein Fediverse-Post wird unter dem eigenen Handle des Streamers veröffentlicht und kann nicht stillschweigend widerrufen werden. Administratoren sollten dies sparsam gewähren.

Aktionsschaltflächen (Zur Laufzeit)

`owncast.actions.add(button | buttons[])`

Füge eine oder mehrere Aktionsknöpfe zu dem Manifest deines Plugins hinzu, ohne einen Neustart. Jeder Knopf nimmt dieselben Felder wie ein Eintrag in manifest.actions an (titel, plus url/openExternally oder inline html). Der Host validiert jeden Eintrag mit denselben Regeln wie manifest.actions und speichert das Ergebnis, sodass Änderungen einen Neustart überstehen. A rejected entry throws an error naming the entry and the rule it broke, and the whole batch is rejected, so nothing is added when any entry is invalid.

JavaScript
Python

owncast.actions.add({ title: 'Donate', url: '/plugins/my-plugin/donate', openExternally: true });

owncast.actions.add({"title": "Donate", "url": "/plugins/my-plugin/donate", "openExternally": True})

Benötigt ui.modify.

`owncast.actions.clear()`

Lösche jede zur Laufzeit hinzugefügte Aktionsschaltfläche. Die im Manifest deklarierten Aktionen bleiben erhalten.

Benötigt ui.modify.

Vollständige Abdeckung in UI: Aktionsschaltflächen.

Echtzeit-Push (Server-Sent Events)

`owncast.sse.send(kanaal, event, data)`

Push ein Server-Sent-Event an jeden Browser, der mit deinem Plugin verbunden ist /_sse/\<channel> Endpunkt.

kanaal: welchen Stream zu pushen. Verwende "" für den Standardkanal.
ereignis: der Ereignisname, auf den der Browser lauscht. Verwende "" für das Standard-message-Ereignis.
daten: Nutzlast. Strings werden unverändert gesendet. Alles andere wird für dich als JSON kodiert.

JavaScript
Python

owncast.sse.send('alerts', 'donation', { from: 'alice', amount: 5 });

owncast.sse.send("alerts", "donation", {"from": "alice", "amount": 5})

Feuer-und-Vergessen. Der Aufruf gibt sofort zurück und blockiert niemals. Langsame Clients lassen Frames fallen, anstatt Ihr Plugin anzuhalten.

Benötigt http.sse.

Vollständige Abdeckung in Serving HTTP: Realtime updates.

Timer

Geplante verzögerte und sich wiederholende Aufgaben. Timer sind ambient, es ist keine Berechtigung erforderlich, und sie werden automatisch gelöscht, wenn Ihr Plugin deaktiviert wird. (Python: set_timeout, set_interval, clear.)

`owncast.timer.setTimeout(fn, ms)`

Führen Sie fn einmal nach ms Millisekunden aus. Gibt eine ID zurück.

`owncast.timer.setInterval(fn, ms)`

Führen Sie fn wiederholt alle ms Millisekunden aus. Gibt eine ID zurück.

`owncast.timer.clear(id)`

Stornieren Sie einen ausstehenden Timeout oder ein Intervall mithilfe der von der ID zurückgegebenen Aufrufe.

Bundled Assets

Lesen Sie Dateien, die Sie im assets/-Verzeichnis Ihres Plugins bereitgestellt haben. Ambient: keine Berechtigung erforderlich. (Python: read, read_text.)

`owncast.assets.read(path)` and `owncast.assets.readText(path)`

Read a file bundled under assets/, relative to that directory. read returns the original bytes as a JavaScript Uint8Array or Python bytes. readText and Python's read_text decode the bytes as UTF-8. Python replaces malformed byte sequences when decoding. Missing files return null in JavaScript or None in Python.

JavaScript
Python

const image = owncast.assets.read('badge.png');
const template = owncast.assets.readText('template.html');

image = owncast.assets.read("badge.png")
template = owncast.assets.read_text("template.html")

Vollständige API-Referenz

Methodennamen sind hier in der JavaScript (camelCase) Form. Die entsprechenden Python-Begriffe sind snake_case (sendAction → send_action, banIP → ban_ip, videoConfig → video_config usw.).

API	Erlaubnis
`owncast.log.info` / `.warning` / `.error`	keine (ambient)
`owncast.chat.send`	`chat.send`
`owncast.chat.sendAction`	`chat.send`
`owncast.chat.sendTo`	`chat.send`
`owncast.chat.system`	`chat.send`
`owncast.chat.replyTo`	`chat.send`
`owncast.chat.history`	`chat.history`
`owncast.chat.clients`	`chat.history`
`owncast.chat.deleteMessage`	`chat.moderate`
`owncast.chat.kick`	`chat.moderate`
`owncast.users.list` / `.get`	`users.read`
`owncast.users.setEnabled` / `.banIP`	`users.moderate`
`owncast.users.register`	`users.register`
`owncast.auth.grantSession` / `.endSession`	`auth.gate`
`owncast.kv.get` / `.set` / `.getJSON` / `.setJSON`	`storage.kv`
`owncast.storage.upload`	`storage.upload`
`owncast.fs.read` / `.readText` / `.write` / `.list` / `.delete` / `.exists`	`storage.fs`
`owncast.sql.exec` / `.query` / `.queryRow`	`storage.sql`
`owncast.http.fetch`	`network.fetch`
`owncast.events.emit`	`events.emit`
`owncast.stream.current`	`server.read`
`owncast.stream.broadcaster`	`server.read`
`owncast.server.info` / `.socials` / `.emotes` / `.federation` / `.tags`	`server.read`
`owncast.videoConfig.read`	`videoconfig.read`
`owncast.videoConfig.write`	`videoconfig.write`
`owncast.notifications.discord` / `.browserPush` / `.fediverse`	`notifications.send`
`owncast.fediverse.post`	`fediverse.post`
`owncast.actions.add` / `.clear`	`ui.modify`
`owncast.timer.setTimeout` / `.setInterval` / `.clear`	keine (ambient)
`owncast.assets.read` / `.readText`	keine (ambient)
`owncast.config.get`	none (ambient)
`owncast.sse.send`	`http.sse`

Improve this page

See something missing or incorrect? Edit the English version of this page or help improve translations.

Contributors to this documentation

Gabe Kangas

Owncast

Logging
- owncast.log.info(message), .warning(message), and .error(message)
Chat
Benutzer
Authentifizierung
- owncast.auth.grantSession({ userId, ttl? })
- owncast.auth.endSession()
Speicher
Konfiguration
- owncast.config.get(schlüssel, fallback?)
Netzwerk
- owncast.http.fetch(url, opts?)
Plugin-zu-Plugin-Ereignisse
- owncast.events.emit(eventType, payload)
Stream- und Serverstatus
Video- und Transcodierungsconfigurierung
- owncast.videoConfig.read()
- owncast.videoConfig.write(partial)
Benachrichtigungen
Fediverse
- owncast.fediverse.post(text)
Aktionsschaltflächen (Zur Laufzeit)
- owncast.actions.add(button | buttons[])
- owncast.actions.clear()
Echtzeit-Push (Server-Sent Events)
- owncast.sse.send(kanaal, event, data)
Timer
Bundled Assets
- owncast.assets.read(path) and owncast.assets.readText(path)
Vollständige API-Referenz

Logging​

owncast.log.info(message), .warning(message), and .error(message)​

Chat​

owncast.chat.send(text)​

owncast.chat.sendAction(text)​

owncast.chat.system(body)​

owncast.chat.sendTo(clientId, text)​

owncast.chat.replyTo(msg, text)​

owncast.chat.history(limit?)​

owncast.chat.clients()​

owncast.chat.deleteMessage(messageId)​

owncast.chat.kick(clientId)​

Chat-Identität​

Benutzer​

owncast.users.list() und owncast.users.get(id)​

owncast.users.setEnabled(id, enabled, reason?)​

owncast.users.banIP(ip)​

owncast.users.register({ authId, displayName?, scopes?, profileUrl?, handle?, public? })​

Authentifizierung​

owncast.auth.grantSession({ userId, ttl? })​

owncast.auth.endSession()​

Speicher​

owncast.kv.get(key) und owncast.kv.set(key, value)​

owncast.storage.upload(name, data)​

owncast.fs.*​

owncast.sql.*​

Konfiguration​

owncast.config.get(schlüssel, fallback?)​

Netzwerk​

owncast.http.fetch(url, opts?)​

Plugin-zu-Plugin-Ereignisse​

owncast.events.emit(eventType, payload)​

Stream- und Serverstatus​

owncast.stream.current()​

owncast.stream.broadcaster()​

owncast.server.info()​

owncast.server.socials()​

owncast.server.emotes()​

owncast.server.federation()​

owncast.server.tags()​

Video- und Transcodierungsconfigurierung​

owncast.videoConfig.read()​

owncast.videoConfig.write(partial)​

Benachrichtigungen​

owncast.notifications.discord(text)​

owncast.notifications.browserPush({ titel, körper, url? })`​

owncast.notifications.fediverse({ typ, körper, bild?, link? })`​

Fediverse​

owncast.fediverse.post(text)​

Aktionsschaltflächen (Zur Laufzeit)​

owncast.actions.add(button | buttons[])​

owncast.actions.clear()​

Echtzeit-Push (Server-Sent Events)​

owncast.sse.send(kanaal, event, data)​

Timer​

owncast.timer.setTimeout(fn, ms)​

owncast.timer.setInterval(fn, ms)​

owncast.timer.clear(id)​

Bundled Assets​

owncast.assets.read(path) and owncast.assets.readText(path)​

Vollständige API-Referenz​

Improve this page

Logging

`owncast.log.info(message)`, `.warning(message)`, and `.error(message)`

Chat

`owncast.chat.send(text)`

`owncast.chat.sendAction(text)`

`owncast.chat.system(body)`

`owncast.chat.sendTo(clientId, text)`

`owncast.chat.replyTo(msg, text)`

`owncast.chat.history(limit?)`

`owncast.chat.clients()`

`owncast.chat.deleteMessage(messageId)`

`owncast.chat.kick(clientId)`

Chat-Identität

Benutzer

`owncast.users.list()` und `owncast.users.get(id)`

`owncast.users.setEnabled(id, enabled, reason?)`

`owncast.users.banIP(ip)`

`owncast.users.register({ authId, displayName?, scopes?, profileUrl?, handle?, public? })`

Authentifizierung

`owncast.auth.grantSession({ userId, ttl? })`

`owncast.auth.endSession()`

Speicher

`owncast.kv.get(key)` und `owncast.kv.set(key, value)`

`owncast.storage.upload(name, data)`

`owncast.fs.*`

`owncast.sql.*`

Konfiguration

`owncast.config.get(schlüssel, fallback?)`

Netzwerk

`owncast.http.fetch(url, opts?)`

Plugin-zu-Plugin-Ereignisse

`owncast.events.emit(eventType, payload)`

Stream- und Serverstatus

`owncast.stream.current()`

`owncast.stream.broadcaster()`

`owncast.server.info()`

`owncast.server.socials()`

`owncast.server.emotes()`

`owncast.server.federation()`

`owncast.server.tags()`

Video- und Transcodierungsconfigurierung

`owncast.videoConfig.read()`

`owncast.videoConfig.write(partial)`

Benachrichtigungen

`owncast.notifications.discord(text)`

`owncast.notifications.browserPush({ titel, körper, url?` })`

`owncast.notifications.fediverse({ typ, körper, bild?, link?` })`

Fediverse

`owncast.fediverse.post(text)`

Aktionsschaltflächen (Zur Laufzeit)

`owncast.actions.add(button | buttons[])`

`owncast.actions.clear()`

Echtzeit-Push (Server-Sent Events)

`owncast.sse.send(kanaal, event, data)`

Timer

`owncast.timer.setTimeout(fn, ms)`

`owncast.timer.setInterval(fn, ms)`

`owncast.timer.clear(id)`

Bundled Assets

`owncast.assets.read(path)` and `owncast.assets.readText(path)`

Vollständige API-Referenz