Subscribe to all camera events (SSE)

SDK generation note: marked x-fern-ignore: true because Server-Sent Events don’t map cleanly onto synchronous SDK methods. The TypeScript and Swift SDKs ship hand-written SSE clients that consume this endpoint and expose typed EventStream APIs.

---

Server-Sent Events stream for all connected cameras. The server sends a keepalive comment (: keepalive) every 30 seconds and immediately fires an initial connected event with the subscription’s camera ID payload (see the quirk note below).

Event Types

Event	SDK Callback	Payload	Description
connected	OnConnected (or initial handshake)	{cameraId, ...}	Camera connection established OR initial SSE handshake (see quirk)
disconnected	OnDisconnected	{cameraId, reason?}	Camera disconnected (real or synthetic — server emits one before clearing callbacks during a clean disconnect)
propertyChanged	OnPropertyChangedCodes	{cameraId, codes: [...]}	One or more property values changed on the camera
afStatus	OnWarning (CrWarningExt_AFStatus)	{state: "focused" | "unlocked" | "tracking", source?}	Autofocus state changed
downloadComplete	OnCompleteDownload	{cameraId, filename, savedPath}	Auto-transferred image saved to host (remote mode + matching still-image-store-destination)
transferProgress	OnNotifyRemoteTransferResult (or filesystem polling fallback)	{cameraId, contentId, fileId, percent, savedPath?}	Explicit file-pull progress (remote-transfer mode). On macOS V2.01 the SDK callback is unreliable; the server falls back to filesystem polling and emits synthetic events
contentsTransfer	OnContentsTransfer	{cameraId, files: [...]}	Contents-transfer mode file list update (printable-ASCII filenames only)
operationResult	OnCompleteOperation	{cameraId, operation, result}	Generic SDK operation completed (e.g. control codes, non-shutter commands)
error	OnError	{cameraId, code, message}	SDK error occurred

⚠ The dual connected event quirk

Two distinct conditions emit an event named connected:

1. Initial SSE handshake — fired immediately when the EventSource connects, with payload {"cameraId":"<subscription-id-or-*>"}. Use it to confirm the SSE channel is open. NOT a camera state change.
2. Real camera connect — fired when the SDK’s OnConnected callback fires for a camera, with the full camera info payload.

Discriminate by payload shape if you need to distinguish them. The cleanest pattern is to ignore the first connected event after opening the EventSource and treat any subsequent connected as a real camera-state change.

Example

const events = new EventSource("http://localhost:8080/api/events");
events.addEventListener("downloadComplete", (e) => {
  console.log("File saved:", JSON.parse(e.data).savedPath);
});
events.addEventListener("propertyChanged", (e) => {
  const { codes } = JSON.parse(e.data);
  // Refresh affected properties via getProperty / getAllProperties
});

GET /api/events

Subscribe to all camera events (SSE)

cURL

curl --request GET \
  --url http://{host}:{port}/api/events

import requests

url = "http://{host}:{port}/api/events"

response = requests.get(url)

print(response.text)

const options = {method: 'GET'};

fetch('http://{host}:{port}/api/events', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_PORT => "62437",
  CURLOPT_URL => "http://{host}:{port}/api/events",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$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 := "http://{host}:{port}/api/events"

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

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

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

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.get("http://{host}:{port}/api/events")
  .asString();

require 'uri'
require 'net/http'

url = URI("http://{host}:{port}/api/events")

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

request = Net::HTTP::Get.new(url)

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

200

"<string>"

Response

200 - text/event-stream

SSE event stream

Server-Sent Events stream. Each event uses the standard SSE framing: event: <name>\\ndata: <json>\\n\\n. See the description for the full event catalog and payload shapes.