Listen to Chat Events (SSE)

Listen to Chat Messages (SSE)

curl --request GET \
  --url https://app.splox.io/api/v1/chat-internal-messages/{chatId}/listen \
  --header 'Authorization: Bearer <token>'

import requests

url = "https://app.splox.io/api/v1/chat-internal-messages/{chatId}/listen"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.text)

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://app.splox.io/api/v1/chat-internal-messages/{chatId}/listen', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://app.splox.io/api/v1/chat-internal-messages/{chatId}/listen",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://app.splox.io/api/v1/chat-internal-messages/{chatId}/listen"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://app.splox.io/api/v1/chat-internal-messages/{chatId}/listen")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

"<string>"

GET

chat-internal-messages

{chatId}

listen

Listen to Chat Messages (SSE)

curl --request GET \
  --url https://app.splox.io/api/v1/chat-internal-messages/{chatId}/listen \
  --header 'Authorization: Bearer <token>'

import requests

url = "https://app.splox.io/api/v1/chat-internal-messages/{chatId}/listen"

headers = {"Authorization": "Bearer <token>"}

response = requests.get(url, headers=headers)

print(response.text)

const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

fetch('https://app.splox.io/api/v1/chat-internal-messages/{chatId}/listen', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://app.splox.io/api/v1/chat-internal-messages/{chatId}/listen",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://app.splox.io/api/v1/chat-internal-messages/{chatId}/listen"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "Bearer <token>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://app.splox.io/api/v1/chat-internal-messages/{chatId}/listen")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

response = http.request(request)
puts response.read_body

"<string>"

Streams real-time events for a chat session via Server-Sent Events (SSE). This is the recommended way to receive live updates when running a workflow through a chat.

Usage

curl -N -H "Authorization: Bearer YOUR_TOKEN" \
  https://app.splox.io/api/v1/chat-internal-messages/{chat_id}/listen

from splox import SploxClient

client = SploxClient(api_key="YOUR_API_KEY")

for event in client.chats.listen("CHAT_ID"):
    if event.is_keepalive:
        continue
    if event.node_execution:
        print(f"[{event.node_execution.status}] {event.node_execution.node_id}")
    if event.workflow_request and event.workflow_request.status == "completed":
        print("Done!")
        break

import Splox from "splox";

const client = new Splox("YOUR_API_KEY");

const stream = await client.chats.listen("CHAT_ID");
for await (const event of stream) {
  if (event.isKeepalive) continue;
  if (event.node_execution) {
    console.log(`[${event.node_execution.status}] ${event.node_execution.node_id}`);
  }
  if (event.workflow_request?.status === "completed") {
    console.log("Done!");
    break;
  }
}

client := splox.NewClient("YOUR_API_KEY")
iter, err := client.Chats.Listen(ctx, "CHAT_ID")
if err != nil {
    log.Fatal(err)
}
defer iter.Close()

for iter.Next() {
    ev := iter.Event()
    if ev.IsKeepalive {
        continue
    }
    if ev.NodeExecution != nil {
        fmt.Printf("[%s] %s\n", ev.NodeExecution.Status, ev.NodeExecution.NodeID)
    }
    if ev.WorkflowRequest != nil && ev.WorkflowRequest.Status == "completed" {
        fmt.Println("Done!")
        break
    }
}

How It Works

Subscribes to the chat’s Redis PubSub channel
Streams workflow request status updates and node execution events
Sends keepalive messages every 3 seconds
Checks workflow status every 5 seconds
Connection times out after 30 minutes

Response Format

Standard SSE format. Events contain workflow request and node execution updates:

data: {"workflow_request":{"id":"...","status":"in_progress",...},"node_execution":{"id":"...","status":"completed",...}}

data: keepalive

data: {"is_active":false,"type":"workflow_status"}

Event Types

Event	Description
Workflow + Node update	Contains `workflow_request` and/or `node_execution` fields with current status and data
Keepalive	Literal string `keepalive` sent every 3 seconds
Workflow status	`{"is_active":false,"type":"workflow_status"}` when a workflow stops

Notes

Authentication required: Users can only listen to their own chats.

Connection timeout: SSE connections timeout after 30 minutes. Reconnect if needed.

The keepalive messages every 3 seconds prevent connection drops from proxies and load balancers.

Authorizations

Authorization

string

header

required

API token generated from your Splox account settings. Create tokens at https://app.splox.io/account?tab=settings

Path Parameters

chatId

string<uuid>

required

Chat ID

Response

200 - text/event-stream

SSE stream of chat events. Includes workflow request status updates and node execution events for the chat session.

The response is of type string.

Getting Started

Workflows

Workflow Execution

MCP

Chats

Memory

Events

Billing

Listen to Chat Events (SSE)

Usage

How It Works

Response Format

Event Types

Notes

Authorizations

Path Parameters

Response

​Usage

​How It Works

​Response Format

​Event Types

​Notes

Authorizations

Path Parameters

Response

Usage

How It Works

Response Format

Event Types

Notes