Owncast Plugin APIs

L'exécution du plugin Owncast expose un global unique, owncast, avec les fonctions hôtes que votre plugin peut appeler. 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.

Les appels sont montrés pour les deux SDK, choisissez votre langue avec les onglets. Voir JavaScript ou Python pour la configuration. (Les noms de méthode JavaScript sont en camelCase, Python utilise snake_case, donc sendAction devient send_action, et ainsi de suite.)

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

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

Python

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

Ambiant : aucune autorisation requise. See the paired chat-logger examples for JavaScript and Python.

Chat

Créer un bot de chat, un outil de modération ou un filtre ? Commencez par plugins de chat.

owncast.chat.send(text)

Envoyer un message de chat. Envoyé en tant qu'identité bot de votre plugin (nom d'affichage provenant de bot.displayName ou name dans votre manifeste).

JavaScript

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

Python

owncast.chat.send("hello chat")

Nécessite chat.send.

owncast.chat.sendAction(text)

Envoyer un message de type action ("/me").

JavaScript

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

Python

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

Nécessite chat.send.

owncast.chat.system(body)

Envoyer un message d'annonce serveur. Aucune identité de bot attachée. Le corps s'affiche en ligne en tant que HTML, utilisez ceci pour des avis courts, attribués au serveur comme "le flux commence dans 5 minutes". Traitez le corps comme une sortie HTML non fiable : n'interpoliez pas l'entrée utilisateur sans l'échapper.

Requires chat.send.

owncast.chat.sendTo(clientId, text)

Envoyer un message privé à un seul client connecté.

Requires chat.send.

owncast.chat.replyTo(msg, text)

Chuchoter une réponse à celui qui a envoyé un message de chat. Passer le message de chat depuis onChatMessage/filterChatMessage (ou un ID de client nu). Retourne false si la connexion de l'expéditeur est inconnue (pas d'ID de client), donc vous pouvez revenir à un send public. Sugar sur sendTo(clientId, text).

JavaScript

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

Python

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

Nécessite chat.send.

owncast.chat.history(limit?)

Retourner les messages de chat les plus récents, chacun avec id, user, body, et timestamp. limit par défaut à 50.

Nécessite chat.history.

owncast.chat.clients()

Return the list of currently-connected chat clients, each with id, userId?, displayName?, connectedAt?, userAgent?, ipAddress?, and messageCount. id est l'ID de client par connexion utilisé par chat.kick.

Nécessite chat.history.

owncast.chat.deleteMessage(messageId)

Masquer un message de chat des spectateurs.

Requires chat.moderate.

owncast.chat.kick(clientId)

Déconnecter un client de chat.

Requires chat.moderate.

Identité de chat

Chaque plugin a exactement une identité de chat, le bot qu'Owncast fournit lorsque votre plugin est installé. Le nom d'affichage est le bot.displayName de votre manifeste s'il est défini, sinon son name, avec IsBot: true. Les deux send et sendAction postent sous cette identité, via le pipeline de chat normal d'Owncast (filtres, limites de taux, modération). Les plugins ne peuvent pas poster sous des noms arbitraires ou usurper l'identité des vrais utilisateurs.

L'utilisateur bot est associé au slug du plugin, donc l'identité survit aux modifications du manifeste sur name ou bot.displayName. Si vous avez besoin de plusieurs personnalités de chat, expédiez plusieurs plugins.

Utilisateurs

owncast.users.list() et owncast.users.get(id)

Lire la liste des utilisateurs du chat ou un enregistrement utilisateur unique.

JavaScript

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

Python

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

Nécessite users.read.

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

Activer ou désactiver un utilisateur de chat.

JavaScript

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

Python

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

Nécessite users.moderate.

owncast.users.banIP(ip)

Bannir une IP pour rejoindre le chat.

JavaScript

owncast.users.banIP('203.0.113.42');

Python

owncast.users.ban_ip("203.0.113.42")

Nécessite 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

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

Python

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

Nécessite users.register.

Authentification

Cela alimente une porte d'authentification des spectateurs. grantSession et endSession ne fonctionnent que dans un gestionnaire onHttpRequest, car l'hôte attache le cookie de session à la réponse HTTP en vol.

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

Émettre une session signée pour un utilisateur déjà enregistré (l'userId de owncast.users.register). L'hôte crée, signe et attache le cookie de session à la réponse actuelle ; votre plugin ne voit jamais le jeton, donc il ne peut pas le forger ou le fuir. ttl est une durée de vie facultative en secondes (0/omis utilise la valeur par défaut de l'hôte de 24 heures).

JavaScript

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

Python

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

Nécessite auth.gate.

owncast.auth.endSession()

Effacer le cookie de session actuel du spectateur sur cette réponse pour le déconnecter. Votre plugin contrôle toujours la redirection (et peut rediriger vers la déconnexion propre du fournisseur).

JavaScript

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

Python

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

Nécessite auth.gate.

Stockage

owncast.kv.get(key) et owncast.kv.set(key, value)

Magasin de clés/valeurs par plugin, nommé par le slug de votre plugin. Les valeurs sont des chaînes.

Pour des types plus riches, utilisez les helpers JSON (getJSON / setJSON, get_json / set_json en Python) au lieu de parser et de sérialiser vous-même. Le getter JSON retourne la valeur par défaut lorsque la clé est non définie ou contient un JSON invalide. Les plugins ne peuvent pas lire les clés des autres.

JavaScript

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', {});

Python

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", {})

Nécessite storage.kv.

owncast.storage.upload(name, data)

Télécharger un fichier dans la zone publique de fichiers d'Owncast. 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.

Nécessite storage.upload.

owncast.fs.*

A private, sandboxed filesystem at data/plugin-storage/\<your-slug>/files/. Contrairement à owncast.storage.upload, ces fichiers restent côté serveur : ils ne sont jamais servis sur HTTP. Les chemins sont relatifs à votre racine de sandbox. L'hôte limite chaque chemin à votre propre répertoire (un plugin ne peut pas lire les fichiers d'un autre plugin, et ../ ou des chemins absolus se replient à l'intérieur du sandbox). Les répertoires parents sont créés si nécessaire lors de l'écriture.

JavaScript	Python	Retourne
fs.read(path)	fs.read(path)	Uint8Array / bytes, or null / None if missing
fs.readText(path)	fs.read_text(path)	UTF-8 string / str, or null / None if missing
fs.write(path, data)	fs.write(path, data)	{ error? }
fs.list(dir)	fs.list(dir)	noms d'entrée (un répertoire manquant est vide)
fs.delete(path)	fs.delete(path)	{ error? } for a file or empty directory
fs.exists(path)	fs.exists(path)	booléen

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

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

Python

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)

Nécessite 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

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]);

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],
)

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.

Configuration

owncast.config.get(key, fallback?)

Lisez l'un des paramètres config déclarés dans le manifeste de votre pluginmanifest-declared config. Renvoie la valeur définie par l'administrateur lorsque présente, sinon la valeur par défaut déclarée, déjà analysée selon son type déclaré. Pour une clé inconnue (ou une clé sans valeur), elle renvoie fallback.

JavaScript

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

Python

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

Ambient: no permission required. Préférez cela à la création d'une page de paramètres sur mesure et d'une plomberie clé/valeur pour des commandes simples. (La clé de configuration est ce que vous l'avez nommée dans le manifeste, et elle n'est pas traduite par langue.)

Réseau

owncast.http.fetch(url, opts?)

Requête HTTP sortante synchrone. opts contient method, headers et body. Le résultat est { status, headers, body }. Seuls les hôtes listés dans network.allowedHosts de votre manifeste sont accessibles. Tout le reste renvoie une erreur.

JavaScript

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

Python

import json

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

Nécessite network.fetch et une entrée correspondante dans network.allowedHosts. Utilisez ceci pour HTTP sortant plutôt que le client HTTP propre à votre langue (en Python, n'utilisez pas requests : il ne se compiles pas en tant que plugin).

Voir Référence de manifeste : réseau pour la syntaxe de la liste autorisée.

Événements entre plugins

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

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

Python

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

Nécessite events.emit.

État du flux et du serveur

owncast.stream.current()

L'état du flux en direct actuel : { online, title?, summary?, viewers, startedAt?, latencyLevel? }.

Requires server.read.

owncast.stream.broadcaster()

Télémétrie d'encodage entrante pour la connexion actuelle : { remoteAddr?, codecs?, resolution?, framerate?, bitrates? }. En lecture seule, et à valeur zéro lorsqu'aucune diffusion n'est connectée. Pour changer la sortie vidéo, voir le groupe configuration vidéo ci-dessous.

Nécessite server.read.

owncast.server.info()

Informations serveur statiques : { name?, url?, summary?, welcomeMessage?, version? }.

JavaScript

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

Python

name = owncast.server.info().name

Nécessite server.read.

owncast.server.socials()

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

Requires server.read.

owncast.server.emotes()

Les émoticônes de discussion personnalisées du serveur : le même ensemble que le point de terminaison public /api/emoji, chacun { name, url }. Utile pour le rendu ou le filtrage des émoticônes :code: côté serveur.

Nécessite 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.

Nécessite server.read.

owncast.server.tags()

Les tags configurés du streamer, sous forme de liste de chaînes.

Nécessite server.read.

Configuration vidéo et transcoding

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

const cfg = owncast.videoConfig.read();

Python

cfg = owncast.video_config.read()

Nécessite videoconfig.read.

owncast.videoConfig.write(partial)

Update any of the VideoConfig fields above. Passez un objet partiel. Seuls les champs que vous incluez sont modifiés. Les changements s'appliquent au prochain démarrage du flux : l'hôte ne redémarre pas une diffusion active.

JavaScript

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

Python

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

Nécessite videoconfig.write. C'est une confiance élevée. Les administrateurs devraient accorder cela avec parcimonie.

Notifications

owncast.notifications.discord(text)

Envoyer une notification Discord via le webhook configuré du streamer.

Nécessite notifications.send.

owncast.notifications.browserPush({ title, body, url? })

Envoyez aux navigateurs abonnés.

JavaScript

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

Python

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

Nécessite notifications.send.

owncast.notifications.fediverse({ type, body, image?, link? })

Envoyer une notification formatée pour le fediverse (se rend sous forme de publication aux abonnés).

Nécessite notifications.send.

Fediverse

owncast.fediverse.post(text)

Faire une publication publique dans le fediverse depuis le compte Owncast.

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.

Nécessite fediverse.post. Confiance élevée : une publication fediverse est faite sous le nom de l'utilisateur du streamer et ne peut pas être révoquée en silence. Les administrateurs devraient accorder cela avec parcimonie.

Boutons d'action (runtime)

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

Ajouter un ou plusieurs boutons d'action à l'ensemble de manifeste de votre plugin sans le recharger. Chaque bouton prend les mêmes champs qu'une entrée manifest.actions (title, plus url/openExternally ou inline html). L'hôte valide chaque entrée selon les mêmes règles que manifest.actions et conserve le résultat pour que les ajouts survivent à un rechargement. 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

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

Python

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

Nécessite ui.modify.

owncast.actions.clear()

Supprimer tous les boutons d'action ajoutés à l'exécution. Les actions déclarées dans le manifeste restent.

Nécessite ui.modify.

Couverture complète dans UI : Boutons d'action.

Push en temps réel (Server-Sent Events)

owncast.sse.send(channel, event, data)

Envoyer un événement Server-Sent à chaque navigateur connecté à l'endpoint /_sse/\<channel> de votre plugin.

• channel : quel flux pousser. Utilisez "" pour le canal par défaut.
• event : le nom de l'événement que le navigateur écoute. Utilisez "" pour l'événement message par défaut.
• data : charge utile. Les chaînes sont envoyées telles quelles. Tout le reste est codé en JSON pour vous.

JavaScript

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

Python

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

Feu et oublie. L'appel retourne immédiatement et ne bloque jamais. Les clients lents perdent des images plutôt que de bloquer votre plugin.

Nécessite http.sse.

Couverture complète dans Serveur HTTP: Mises à jour en temps réel.

Gestionnaires de temporisation

Planifier le travail différé et répétitif. Les timers sont environnementaux, aucune autorisation requise, et sont effacés automatiquement lorsque votre plugin est désactivé. (Python: set_timeout, set_interval, clear.)

owncast.timer.setTimeout(fn, ms)

Exécute fn une fois après ms millisecondes. Retourne un id.

owncast.timer.setInterval(fn, ms)

Exécute fn de manière répétée toutes les ms millisecondes. Retourne un id.

owncast.timer.clear(id)

Annule un timeout ou un intervalle en attente par l'id retourné par l'appel.

Actifs regroupés

Lisez les fichiers que vous avez expédiés dans le répertoire assets/ de votre plugin. Environnemental: aucune autorisation requise. (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

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

Python

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

Référence API complète

Les noms de méthodes ci-dessous sont sous forme JavaScript (camelCase). Les équivalents Python sont snake_case (sendAction → send_action, banIP → ban_ip, videoConfig → video_config, etc.).

API	Autorisation
owncast.log.info / .warning / .error	aucun (environnemental)
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	aucun (environnemental)
owncast.assets.read / .readText	aucun (environnemental)
owncast.config.get	none (ambient)
owncast.sse.send	http.sse