Make-A-Wish
API DOCS

Übersicht

Mit den Schnittstellen kannst du auf Spenden, Spendenstände und Challenges reagieren. Die öffentlichen Schnittstellen stehen allen offen. Für weitere Funktionen brauchst du eine Registrierung. Am Ende findest du fertige Beispiele für OBS.

Öffentliche Schnittstellen

Auf diese Schnittstellen kannst du öffentlich ohne Registrierung zugreifen.

API-Endpunkte

Wenn sich der Inhalt geändert hat, ändert sich das Property hash. Das heißt du kannst diesen vergleichen um zu sehen ob sich die Daten geändert haben.

Wenn du Push-Benachrichtigen bekommen magst, statt den Endpunkt zu pollen (bitte Cache-Busting beim Pollen verwenden), kannst du Websocket-Events für eine Aktualisierung abonnieren.

Allgemeine Infos

Unter https://streamer.make-a-wish.at/projects/charityroyale2026/info.json findest du alle aktuellen Informationen (Spendenstände, Streamer, Wünsche, Spender, ...) zu Charity Royale 2026.

Infos für einen Streamer

Spendenstände und Wünsche für <Streamer>:

https://streamer.make-a-wish.at/projects/charityroyale2026/streamers/<streamer_slug>.json

Beträge sind in Cent. Ist die Datei noch nicht verfügbar (404), nach einigen Sekunden erneut abrufen.

Events (Websockets)

Wir verwenden Laravel Reverb um Events im Pusher-style zu übermitteln. Du kannst diese abonnieren um über wichtige Updates direkt informiert zu werden.

Verbindungsinformationen

APP_HOST="streamer.make-a-wish.at"
APP_KEY="mqfzsnt3n1tetbgezmfb"
WS_PORT=443
WSS_PORT=443

Info aktualisiert

Wenn sich die Informationen zum Projekt geändert haben wird ein App\\Events\\InfoJsonUpdated Event gesendet. Dies kann z.B. sein wenn ein Streamer hinzugefügt oder entfernt wird, wenn ein Wunsch hinzugefügt oder entfernt wird, wenn eine Spende aktualisiert (zB abgeschlossen) wird, wenn ein Wunsch erfüllt wurde, etc

Hier ist eine Beispielstruktur für die InfoJsonUpdated Daten, die über Websockets gesendet werden.

{
    "project_id": 8,
    "project_slug": "charityroyale2026",
    "hash": "09366221f02ef4b177e0daf7413b646709bf8fd0ee3d77b9d2122aea1d7f1dc4"
}

Spende abgeschlossen

Wird eine Spende erfolgreich abgeschlossen kommt ein App\\Events\\DonationCompleted event

Hier ist eine Beispielstruktur für die DonationCompleted Daten, die über Websockets oder Webhooks gesendet werden.

{
    'id' => 12345, // null on test events, numeric id on real donations
    'username' => null, // null if no username (Anonym)
    'amount' => 1055, // amount in cents (10€ plus fees here)
    'amount_net' => 1000, // amount in cents without fees that Make-A-Wish received,
    'message' => 'Let\'s go chat', // null if no message
    'streamer_slug' => '<streamer_slug>', // or any other streamer slug
    'wish_slug' => 'prinzessin01',
    'date' => 1794171651, // timestamp
    'metadata' => ['action' => 'my-action']  // null if no metadata (default)
};

Challenge-Status geändert

Auf den öffentlichen Channels challenges (alle Streamer) und challenges.{streamer_id} (ein Streamer) wird das Event App\Events\ChallengeStatusUpdated gesendet. Die numerische Streamer-ID findest du in den öffentlichen Projektdaten.

typechallenge.statusZeitpunkt
challenge.startedrunningDie Challenge wurde gestartet.
challenge.completedcompletedDas Ziel wurde rechtzeitig erreicht.
challenge.failedfailedDie Zeit ist abgelaufen, das Ziel wurde nicht erreicht.

Abonniere einen der beiden Channels. Mit dem Echo-Setup kannst du zum Beispiel so reagieren:

// 801 durch die numerische ID deines Streamers ersetzen.
const seen = new Set();
Echo.channel('challenges.801')
    .listen('.App\\Events\\ChallengeStatusUpdated', (event) => {
        if (!event.event_id || seen.has(event.event_id)) return;
        seen.add(event.event_id);
        switch (event.type) {
            case 'challenge.started':
                console.log('Gestartet:', event.challenge.title);
                break;
            case 'challenge.completed':
                console.log('Ziel erreicht:', event.challenge.current_count);
                break;
            case 'challenge.failed':
                console.log('Zeit abgelaufen:', event.challenge.current_count);
                break;
        }
    });

event.challenge enthält den Stand zum jeweiligen Statuswechsel. Für bestehende WebSocket-Integrationen bleiben Felder wie id, status und current_amount_net zusätzlich auf der obersten Ebene erhalten. Ein Start-Event enthält auch bei verzögerter Zustellung den Stand zum Startzeitpunkt.

Den aktuellen Stand bekommst du unter GET /storage/catalogs/projects/charityroyale2026/challenges.json. Nach einer Info-Aktualisierung erneut abrufen; laufender Fortschritt erzeugt kein zusätzliches Challenge-Status-Event. Nicht gestartete Streamer-Challenges bleiben privat.

Beispielcode

Download Beispielcode

Dies ist ein schneller Beispielcode. Wir sind keine Java-Programmierer. Daher bitte entsprechend überprüfen und gerne Feedback geben.


    /*
     * This source file was generated by the Gradle 'init' task
     */
    package org.example;


    import com.pusher.client.Pusher;
    import com.pusher.client.channel.Channel;
    import com.pusher.client.channel.SubscriptionEventListener;
    import com.pusher.client.connection.ConnectionEventListener;
    import com.pusher.client.connection.ConnectionState;
    import com.pusher.client.PusherOptions;
    import com.pusher.client.channel.PusherEvent;
    import com.pusher.client.connection.ConnectionStateChange;


    public class App {
        public String getGreeting() {
            return "Hello World!";
        }

        public static void main(String[] args) {
            System.out.println(new App().getGreeting());
            String YOUR_APP_KEY="mqfzsnt3n1tetbgezmfb";
            String YOUR_APP_HOST="streamer.make-a-wish.at";

            // Create a new Pusher instance
            PusherOptions options = new PusherOptions();
            options.setHost(YOUR_APP_HOST);
            options.setActivityTimeout((long)10000L);


            Pusher pusher = new Pusher(YOUR_APP_KEY, options);

            pusher.connect(new ConnectionEventListener() {
                @Override
                public void onConnectionStateChange(ConnectionStateChange change) {
                    System.out.println("State changed to " + change.getCurrentState() +
                                       " from " + change.getPreviousState());
                }

                @Override
                public void onError(String message, String code, Exception e) {
                    System.out.println("There was a problem connecting!");
                    System.out.println(message);
                    System.out.println(code);
                    System.out.println(e);
                }
            }, ConnectionState.ALL);

            // Subscribe to a channel
            Channel channel = pusher.subscribe("donations");

            // Bind to listen for events called "my-event" sent to "my-channel"
            channel.bind("App\\Events\\DonationCompleted", new SubscriptionEventListener() {
                @Override
                public void onEvent(PusherEvent event) {
                    System.out.println("Received event with data: " + event.toString());
                }
            });

            // Disconnect from the service
            pusher.disconnect();

            // Reconnect, with all channel subscriptions and event bindings automatically recreated
            pusher.connect();
            // The state change listener is notified when the connection has been re-established,
            // the subscription to "my-channel" and binding on "my-event" still exist.

            try
            {
                Thread.sleep(1000 * 60);
            }
            catch(InterruptedException e)
            {
                 // this part is executed when an exception (in this example InterruptedException) occurs
            }
            //delay(5000);

            System.out.println("The end");

        }
    }
                        

Schau die auch die Dokumentation für Laravel Echo / Broadcasting an.

1. Installation
npm install --save-dev laravel-echo pusher-js
2. Setup

    import Echo from 'laravel-echo';

    import Pusher from 'pusher-js';
    window.Pusher = Pusher;

    window.Echo = new Echo({
        broadcaster: 'reverb',
        key: 'mqfzsnt3n1tetbgezmfb',
        wsHost: 'streamer.make-a-wish.at',
        wsPort: 443,
        wssPort: 443,
        forceTLS: !0,
        enabledTransports: ['ws', 'wss'],
    });
                            
3. Events lauschen

Die Daten im donation event sind die gleichen wie oben im POST-Request


    Echo.channel('donations')
        .listen('DonationCompleted', (donation) => {
        console.log('Donation retrieved');
        console.log(donation);
    }).listen('DonationCompletedTest', (donation) => {
        console.log('TestDonation retrieved');
        console.log(donation);
    });
                            

Danke an Cyber, der uns folgendes Codeschnipsel zur Verfügung gestellt hat:

Code
import io.ktor.client.HttpClient
import io.ktor.client.engine.cio.CIO
import io.ktor.client.plugins.websocket.WebSockets
import io.ktor.client.plugins.websocket.webSocket
import io.ktor.http.HttpMethod
import io.ktor.http.URLProtocol
import io.ktor.websocket.Frame
import io.ktor.websocket.readText
import kotlinx.coroutines.delay
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.contentOrNull
import kotlinx.serialization.json.jsonPrimitive


//JSON Vorlagen
@Serializable
data class BaseEvent(
    val event: String,
    val data: JsonElement? = null
)

@Serializable
data class DonationCompleted(
    val username: String? = null,
    val amount: Int,
    val amount_net: Int,
    val streamer_slug: String,
    val message: String? = null,
    val metadata: JsonElement? = null
)

object Eventhandler {

    val json = Json { ignoreUnknownKeys = true }
    val client = HttpClient(CIO) { install(WebSockets) }

    suspend fun schedule() {
        while (true) {
            try {
                //Verbindung aufbauen
                client.webSocket(
                    method = HttpMethod.Get,
                    host = "streamer.make-a-wish.at",
                    path = "/app/mqfzsnt3n1tetbgezmfb?protocol=7&client=ktor&version=1.0",
                    request = { url.protocol = URLProtocol.WSS }
                ) {

                    //Websocket auslesen
                    for (frame in incoming) {

                        //JSON überprüfen
                        if (frame is Frame.Text) {


                            handle(frame.readText())

                            //Pusher Notification
                            if (frame.readText().contains("pusher:connection_established")) {

                                //Pusher Kanal abonnieren = nur gewisse Events abhören (z.B. 'donations')
                                val subscribe = """{"event":"pusher:subscribe","data":{"channel":"donations"}}"""
                                send(Frame.Text(subscribe))

                            }
                        }
                    }

                }

            } catch (e: Exception) {
                //Delay vor einem Reconnect
                delay(5000)
            }
        }
    }

    fun handle(text: String){

        //JSON String umwandeln
        val base = json.decodeFromString(text)

        //Keine Donation = Pusher notification etc.
        if (!base.event.contains("DonationCompleted")){
            return
        }

        //Informationen holen
        val inner = base.data?.jsonPrimitive?.contentOrNull ?: return
        val data = json.decodeFromString(inner)

        //hier z.B. data.streamer_slug überprüfen etc.
    }
}
Ausführen
kotlinx.coroutines.GlobalScope.launch {
    Eventhandler.schedule()
}

Schnittstellen nach Registrierung

Individualisierung, Webhooks und Testevents für deinen Stream.

Registrierung

Mit Twitch anmelden

Moderator:innen freischalten

Melde dich mit deinem eigenen Twitch-Konto an. Wenn du auf Twitch Moderator:in eines teilnehmenden Streams bist, erhältst du automatisch Zugriff auf dessen Streamer-Tools. Andernfalls kannst du nach der Anmeldung den Stream auswählen und Zugriff bei unserer Orga anfragen. Nach der Freigabe geht es ohne erneute Anmeldung weiter.

Als Koordination wählst du unter „Nach Streamer“ einen Kanal oder unter „Nach Benutzer:in“ ein Konto. Die Zuweisungen werden direkt nach der Auswahl geladen.

Melde dich mit dem Twitch-Konto deines Streams an und öffne im Backend „Streamer → Moderator:innen“. Trage dort den Twitch-Benutzernamen deiner Moderatorin oder deines Moderators ein und wähle „Moderator:in hinzufügen“.

Die Person kann sich danach mit ihrem eigenen Twitch-Konto anmelden, auch wenn sie selbst nicht als Streamer:in teilnimmt. Sie erhält Zugriff auf Individualisierung, Webhooks und Testevents deines Streams. Du kannst den Zugriff dort jederzeit entfernen. Du als Streamer:in, unsere Streamer-Koordination und die Administration können diese Zugänge vergeben; Moderator:innen können keine weiteren Personen freischalten.

Die Freigabe gilt für das Backend. Discord-Mitgliedschaft allein gibt keinen Zugriff. Die Orga prüft offene Anfragen unter „Streamer → Zugriffsanfragen“.

Individualisierung

Ergänze dein Spendenformular um Aktionsbuttons und Auswahllisten.

Buttons und Listen

  • Buttons stehen für Aktionen mit einem Mindestbetrag und können ein Icon und eine Beschreibung haben.
  • Listen bieten eine Auswahl, zum Beispiel ein Team oder einen Spieler.

Probiere die Auswahl aus. Diese Metadaten erhält deine Integration bei einer bestätigten Spende:

{"metadata": {}}

Konfigurationen wechseln

Eine Konfiguration enthält die Buttons und Listen für einen Spielmodus. Du kannst mehrere Konfigurationen vorbereiten und während des Streams zwischen ihnen wechseln, zum Beispiel beim Wechsel zu einem anderen Spielmodus.

Neue Spendenseiten starten ohne Zusatzfelder. Der Assistent führt dich durch Buttons und Listen und zeigt deine Änderungen direkt in der Vorschau. Technische IDs findest du bei Bedarf unter „Erweitert“.

Verwaltest du mehrere Streams, kannst du eine gespeicherte Konfiguration eines anderen Streams als Quelle verwenden. Änderungen an dieser Konfiguration gelten dann für alle Streams, die sie verwenden. Beide Streams müssen weiterhin von der Person verwaltet werden, die die Quelle eingerichtet hat.

Extern verwalten

Deine Anwendung kann den vollständigen Satz aus Buttons und Listen über eine HTTPS-URL bereitstellen oder an unsere API senden. Beide Wege verwenden dasselbe JSON-Format:

{
  "actions": [
    {"id": "drumroll", "label": "Trommelwirbel", "minimum_amount_cents": 200},
    {"id": "fan", "label": "Ventilator an", "minimum_amount_cents": 1000},
    {"id": "kill", "label": "Instant kill", "minimum_amount_cents": 10000}
  ],
  "fields": [
    {
      "id": "team",
      "label": "Team",
      "type": "select",
      "required": false,
      "options": [
        {"id": "red", "label": "Rot"},
        {"id": "blue", "label": "Blau"}
      ]
    },
    {
      "id": "player",
      "label": "Spieler",
      "type": "select",
      "required": false,
      "options": [
        {"id": "alex", "label": "Alex"},
        {"id": "sam", "label": "Sam"}
      ]
    }
  ]
}

minimum_amount_cents ist ein Centbetrag: 1251 entspricht 12,51 €. Buttons unterstützen zusätzlich description, icon_svg und enabled. Listen-IDs beginnen mit einem Buchstaben; Buchstaben, Ziffern, Unterstrich und Bindestrich sind erlaubt. Feste Metadaten-Namen wie action und challenge_id sind reserviert.

Du kannst bis zu 100 Buttons und fünf Listen mit jeweils 100 Optionen übermitteln. Insgesamt sind 64 KB möglich, davon höchstens 8 KB je SVG-Icon. Ein leeres actions-Array bedeutet keine Buttons, ein leeres fields-Array keine Listen.

Von deiner URL abrufen

Wir rufen deine HTTPS-URL zentral alle zehn Sekunden ab, solange sie als Datenquelle eingerichtet ist.

An unsere API senden

Speichere das JSON zum Beispiel als konfiguration.json und sende es bei einer Änderung vollständig:

curl --request PUT "https://streamer.make-a-wish.at/api/streamers/<streamer_slug>/actions" \
  --header "Authorization: Bearer DEIN_ZUGANGSSCHLUESSEL" \
  --header "Content-Type: application/json" \
  --data-binary @konfiguration.json

HTTP 200 bestätigt die Übernahme. Bei HTTP 422 ist das Format ungültig und die vorherige Konfiguration bleibt bestehen.

Auswahl in Webhooks und Events

action enthält die ID des gewählten Buttons. Die gewählten Listenwerte stehen direkt unter ihrer Listen-ID in metadata. Die Auswahl „Team: Rot“ wird zum Beispiel als "team": "red" übermittelt:

{
  "metadata": {
    "action": "drumroll",
    "team": "red",
    "player": "sam"
  }
}

Ohne gewählten Button entfällt action. Nicht ausgefüllte optionale Listen werden weggelassen.

Challenges

Setze deiner Community ein Spendenziel oder sammle eine bestimmte Anzahl passender Spenden innerhalb eines Zeitlimits.

Einrichten und zählen

Öffne im Backend „Streamer → Challenges“, wähle dein aktives Projekt und lege Titel, Beschreibung, Ziel und Dauer fest. Du und die für deinen Stream freigeschalteten Moderator:innen können die Challenges verwalten.

  • Spendenbetrag sammeln: Die passenden abgeschlossenen Spenden zählen mit ihrem Nettobetrag zum Ziel. API-Beträge sind in Cent.
  • Spenden zählen: Jede passende abgeschlossene Spende zählt einmal. Eine höhere Summe löst keine zusätzlichen Zählschritte aus.
  • Aktion und Listen: Wähle einen deiner aktiven Buttons und optional Werte deiner Listen, zum Beispiel „Instant kill“ und „Team: Blau“. Alle gewählten Bedingungen müssen passen. Ohne Filter zählen alle Spenden deines Streams im Projekt und Zeitfenster.

Mit „Speichern und starten“ beginnt das Zeitfenster. Die Zählweise und Filter bleiben danach fest; Ziel und Dauer lassen sich während der laufenden Challenge ändern. Beendete Challenges bleiben im Verlauf. Entwürfe werden noch nicht veröffentlicht.

Beispiele ausprobieren

Diese Browser-Demo verwendet Beispieldaten und sendet weder Spenden noch Webhooks. Eine simulierte Spende erfüllt die im Beispiel angezeigte Auswahl. Die Demozeit ist angehalten; „Zeit ablaufen lassen“ simuliert das Ende des Zeitfensters.

Aktuelle Beispieldaten anzeigen

Ereignisdaten

Beim Start, beim Erreichen des Ziels und beim Ablauf ohne Zielerreichung entsteht eine eigene Meldung. WebSockets und der konfigurierte Streamer-Webhook verwenden dieselbe event_id und denselben Status-Snapshot. Die beiden Endzustände unten zeigen alternative Ausgänge einer Challenge.

{
    "event_id": "00000000-0000-4000-8000-000000000123",
    "type": "challenge.started",
    "occurred_at": "2026-11-08T21:55:51+01:00",
    "project_slug": "example-project",
    "challenge": {
        "id": 123,
        "title": "10 Kills in 10 Minuten",
        "description": "Zehn abgeschlossene Spenden für Instant kill und Team Blau.",
        "start": 1794171351,
        "max_time": 10,
        "status": "running",
        "amount": 0,
        "current_amount_net": 0,
        "streamers": [
            "example-streamer"
        ],
        "automatic": true,
        "requires_selection": false,
        "goal_type": "count",
        "target_count": 10,
        "current_count": 0,
        "filters": {
            "metadata_format": "standard",
            "action": {
                "id": "kill",
                "label": "Instant kill"
            },
            "fields": {
                "team": {
                    "id": "blue",
                    "label": "Blau",
                    "field_label": "Team"
                }
            }
        },
        "end": 1794171951
    },
    "streamer_slug": "example-streamer"
}

{
    "event_id": "00000000-0000-4000-8000-000000000124",
    "type": "challenge.completed",
    "occurred_at": "2026-11-08T22:05:51+01:00",
    "project_slug": "example-project",
    "challenge": {
        "id": 123,
        "title": "10 Kills in 10 Minuten",
        "description": "Zehn abgeschlossene Spenden für Instant kill und Team Blau.",
        "start": 1794171351,
        "max_time": 10,
        "status": "completed",
        "amount": 0,
        "current_amount_net": 10000,
        "streamers": [
            "example-streamer"
        ],
        "automatic": true,
        "requires_selection": false,
        "goal_type": "count",
        "target_count": 10,
        "current_count": 10,
        "filters": {
            "metadata_format": "standard",
            "action": {
                "id": "kill",
                "label": "Instant kill"
            },
            "fields": {
                "team": {
                    "id": "blue",
                    "label": "Blau",
                    "field_label": "Team"
                }
            }
        },
        "end": 1794171951
    },
    "streamer_slug": "example-streamer"
}

{
    "event_id": "00000000-0000-4000-8000-000000000125",
    "type": "challenge.failed",
    "occurred_at": "2026-11-08T22:05:51+01:00",
    "project_slug": "example-project",
    "challenge": {
        "id": 123,
        "title": "10 Kills in 10 Minuten",
        "description": "Zehn abgeschlossene Spenden für Instant kill und Team Blau.",
        "start": 1794171351,
        "max_time": 10,
        "status": "failed",
        "amount": 0,
        "current_amount_net": 6000,
        "streamers": [
            "example-streamer"
        ],
        "automatic": true,
        "requires_selection": false,
        "goal_type": "count",
        "target_count": 10,
        "current_count": 6,
        "filters": {
            "metadata_format": "standard",
            "action": {
                "id": "kill",
                "label": "Instant kill"
            },
            "fields": {
                "team": {
                    "id": "blue",
                    "label": "Blau",
                    "field_label": "Team"
                }
            }
        },
        "end": 1794171951
    },
    "streamer_slug": "example-streamer"
}

goal_type ist count oder amount. Bei Zählzielen verwendest du target_count und current_count, bei Geldzielen amount und current_amount_net. filters beschreibt die Aktion und Listenauswahl. automatic bedeutet, dass Spender:innen die Challenge nicht separat auswählen müssen.

Challenge-Webhooks tragen zusätzlich X-Event-Id und die üblichen RSA-SHA256-Signaturheader. Bestätige mit HTTP 200 oder 204, speichere bereits verarbeitete Event-IDs dauerhaft und ignoriere Duplikate. Spendenmeldungen behalten ihr bestehendes Format.

Webhooks

Ein konfigurierter Webhook erhält POST-Requests für abgeschlossene Spenden und für gestartete, erreichte oder abgelaufene Challenges.

Spenden verwenden weiterhin das JSON-Objekt des DonationCompleted Events. Challenge-Meldungen haben ein eigenes Format mit type, event_id und challenge. Prüfe zuerst type, bevor du eine Challenge-Meldung verarbeitest.

Fehlgeschlagene Spendenmeldungen kannst du im Backend erneut senden. Challenge-Meldungen werden automatisch erneut versucht, mit derselben event_id: bis zu acht Zustellversuche insgesamt, Wiederherstellung offener Meldungen für sieben Tage. Verarbeite jede event_id nur einmal; die Reihenfolge der Zustellung ist nicht garantiert.

Der Webhook sollte einen Code 200 oder Code 204 im Erfolgsfall zurückliefern.

Webhook-Signatur

Der Webhook wird mit dem Algorithmus RSA-SHA256 signiert und erhält einen X-Signature header.
Der public key für die Überprüfung lautet:

-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0DnF7m6D7V41CMrnGpTM
RqfMtWw8amaIkfmjF8Ljwa2MkzLd/EEbZpZlMuMz9BIj7zmlBYX2HPKZ5hUQi2aD
vddgL5CtcVV3sSGa8yQxsSVjg+R4yYFseByy6OSrV+1MlXRbOrg8qlXfZYnV+z1M
XAx36STb7EP199n54TTRRP9MOHPp+t+894P0cxnw8o/UEN6EqMKbsHGaJQ7zN+S7
7MVV6ViQpKZLjnhOPmblJ2u1Anp+SJ6H0Q94T2I38ghdjcj9q9SZIbd6gqgmVxNz
0T20cHbGVYL2rr0mT896hVZifvGwqyb9D7Kdji9ffzd9qr9apllYL4VmNtAwiYAZ
kwIDAQAB
-----END PUBLIC KEY-----

Webhook-Signatur überprüfen

$publicKey = openssl_pkey_get_public('-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0DnF7m6D7V41CMrnGpTM\nRqfMtWw8amaIkfmjF8Ljwa2MkzLd/EEbZpZlMuMz9BIj7zmlBYX2HPKZ5hUQi2aD\nvddgL5CtcVV3sSGa8yQxsSVjg+R4yYFseByy6OSrV+1MlXRbOrg8qlXfZYnV+z1M\nXAx36STb7EP199n54TTRRP9MOHPp+t+894P0cxnw8o/UEN6EqMKbsHGaJQ7zN+S7\n7MVV6ViQpKZLjnhOPmblJ2u1Anp+SJ6H0Q94T2I38ghdjcj9q9SZIbd6gqgmVxNz\n0T20cHbGVYL2rr0mT896hVZifvGwqyb9D7Kdji9ffzd9qr9apllYL4VmNtAwiYAZ\nkwIDAQAB\n-----END PUBLIC KEY-----');

if (! $publicKey) {
    abort(500, 'Could not load public key');
}

$rawBody   = $request->getContent();             // exact body that was signed
$signature = $request->header('X-Signature');    // The signature header

if (! $signature) {
    abort(400, 'Missing signature');
}

$decodedSignature = base64_decode($signature, true);
if ($decodedSignature === false) {
    abort(400, 'Invalid signature encoding');
}

$verified = openssl_verify(
    $rawBody,
    $decodedSignature,
    $publicKey,
    OPENSSL_ALGO_SHA256
);

if ($verified !== 1) {
    abort(401, 'Invalid signature');
}

// Now you can trust the data and process it

import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.PublicKey;
import java.security.Signature;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class WebhookVerifier {

    private static final String PUBLIC_KEY_PEM = "-----BEGIN PUBLIC KEY-----\n
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0DnF7m6D7V41CMrnGpTM\n
RqfMtWw8amaIkfmjF8Ljwa2MkzLd/EEbZpZlMuMz9BIj7zmlBYX2HPKZ5hUQi2aD\n
vddgL5CtcVV3sSGa8yQxsSVjg+R4yYFseByy6OSrV+1MlXRbOrg8qlXfZYnV+z1M\n
XAx36STb7EP199n54TTRRP9MOHPp+t+894P0cxnw8o/UEN6EqMKbsHGaJQ7zN+S7\n
7MVV6ViQpKZLjnhOPmblJ2u1Anp+SJ6H0Q94T2I38ghdjcj9q9SZIbd6gqgmVxNz\n
0T20cHbGVYL2rr0mT896hVZifvGwqyb9D7Kdji9ffzd9qr9apllYL4VmNtAwiYAZ\n
kwIDAQAB\n
-----END PUBLIC KEY-----";

    public static boolean verify(String rawBody, String signatureHeader) {
        try {
            // 1: Check if signature header is present
            if (signatureHeader == null || signatureHeader.isEmpty()) {
                return false;
            }

            // 2: Generate PublicKey from PEM String
            PublicKey publicKey = loadPublicKeyFromPem(PUBLIC_KEY_PEM);

            // 3: Decode signature from Base64
            byte[] signatureBytes = Base64.getDecoder().decode(signatureHeader);

            // 4: Get raw-body as UTF-8 bytes
            byte[] data = rawBody.getBytes(StandardCharsets.UTF_8);

            // 5: SHA256withRSA = OPENSSL_ALGO_SHA256
            Signature verifier = Signature.getInstance("SHA256withRSA");
            verifier.initVerify(publicKey);
            verifier.update(data);

            return verifier.verify(signatureBytes);
        } catch (Exception e) {
            // Return false on any error
            e.printStackTrace();
            return false;
        }
    }

    private static PublicKey loadPublicKeyFromPem(String pem) throws Exception {
        String cleaned = pem
                .replace("-----BEGIN PUBLIC KEY-----", "")
                .replace("-----END PUBLIC KEY-----", "")
                .replaceAll("\\s", ""); // remove all whitespaces incl. \n

        byte[] der = Base64.getDecoder().decode(cleaned);
        X509EncodedKeySpec spec = new X509EncodedKeySpec(der);
        KeyFactory kf = KeyFactory.getInstance("RSA");
        return kf.generatePublic(spec);
    }
}

// Example usage in a controller
String rawBody = /* Read Request-Body as string */;
String signatureHeader = /* Read HTTP-Header "X-Signature"  */;

boolean verified = WebhookVerifier.verify(rawBody, signatureHeader);

if (!verified) {
    // return HTTP 401 / 400 (signature failed)
} else {
    // Now you can trust the data and process it
}

Testmöglichkeiten

Du kannst Testevents senden und prüfen, ob deine Integration sie verarbeitet.

Beispiele: OBS-Effekte

Wähle einen Auslöser und probiere die Effekte aus. Deine Einstellungen stecken anschließend in der HTML-Datei für OBS.

1 / 13

Vorschau wird geladen …

Das Rad zieht eine Aufgabe aus deiner Liste.

In OBS einrichten
  1. HTML herunterladen und auf deinem Computer ablegen.
  2. In OBS eine Browser-Quelle hinzufügen, Lokale Datei aktivieren und die HTML-Datei wählen.
  3. Breite und Höhe auf deine Stream-Auflösung setzen, etwa 1920 × 1080. Für Sounds Audio über OBS steuern aktivieren.

Lass „Quelle herunterfahren, wenn sie nicht sichtbar ist“ und „Browser aktualisieren, wenn Szene aktiv wird“ deaktiviert. Die Datei braucht Internet für neue Events. Verpasste Events werden nicht nachgeholt.

Nebel und Schnee verdecken das Bild im Stream. Dein eigenes Spielfenster bleibt frei. Der Mindestbetrag bezieht sich auf amount_net, ohne Gebührenzuschlag; genau der eingestellte Betrag zählt bereits.

Zum späteren Ändern öffnest du die HTML-Datei im Browser und speicherst sie erneut.

Einstellungen im Code

Der Download enthält diese Werte im Abschnitt effect-settings. Du kannst sie auch später in der Datei ändern.

Weitere Ideen für deinen Stream

Ein Adventsbild Stück für Stück zeigen, bei einem Community-Ziel ein Geschenk öffnen oder im November Regen über die Kamera legen: Die Beispiele oben lassen sich mit jedem der vier Auslöser verbinden.

Mit Webhooks kannst du auch Home Assistant oder Shelly anbinden und etwa eine Lampe einschalten. Für Minecraft wären ein gemeinsamer Boss, ein Bauziel oder eine Aktion auf deinem Server denkbar. Dafür brauchst du eine passende Automation oder ein Server-Plugin.