Orgo - Cloud computers for AI agents

GET

templates

{namespace}

{name}

{version}

build

events

Stream build logs

curl --request GET \
  --url https://www.orgo.ai/api/templates/{namespace}/{name}/{version}/build/events \
  --header 'Authorization: Bearer <token>'

import requests

url = "https://www.orgo.ai/api/templates/{namespace}/{name}/{version}/build/events"

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

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

print(response.text)

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

fetch('https://www.orgo.ai/api/templates/{namespace}/{name}/{version}/build/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_URL => "https://www.orgo.ai/api/templates/{namespace}/{name}/{version}/build/events",
  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://www.orgo.ai/api/templates/{namespace}/{name}/{version}/build/events"

	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://www.orgo.ai/api/templates/{namespace}/{name}/{version}/build/events")

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

{
  "ts": "2023-11-07T05:31:56Z",
  "level": "info",
  "phase": "queue",
  "source": "<string>",
  "line": "<string>"
}

Streams the build log as Server-Sent Events. Use it to render a live, Docker-style build console. The stream stays open for the duration of the build. When the build ends (succeeds, fails, or is cancelled), it sends a final event: end frame whose data is {}, then closes. Closing the connection tears down the upstream subscription.

The stream only carries a build that runs on the template registry host. Builds started with Build template or POST /templates?auto_build=true are queued for a dedicated build runner, which does not publish to this stream, so for those the call returns 404 with { "error": "no build in progress for this template" }. Poll Get build status instead.

The stream is scoped to your own templates, so a curated (system/…) ref returns 404.

Each data: frame is a JSON object:

string

Event timestamp (ISO 8601).

string

info, success, warn, or error.

string

Build phase, e.g. compile, boot, install, snapshot, record, archive, or ready.

string

Origin of the line, e.g. vm, orgo-init, or builder. Optional.

string

A single line of build output.

Path parameters

string

required

Template namespace.

string

required

Template name.

string

required

Version (semver).

Example

curl -N https://www.orgo.ai/api/templates/default/claude-code/1.0.0/build/events \
  -H "Authorization: Bearer $ORGO_API_KEY"

import os, json, requests

with requests.get(
    "https://www.orgo.ai/api/templates/default/claude-code/1.0.0/build/events",
    headers={"Authorization": f"Bearer {os.environ['ORGO_API_KEY']}"},
    stream=True,
) as r:
    for raw in r.iter_lines():
        if raw and raw.startswith(b"data: "):
            event = json.loads(raw[6:])
            if "line" in event:  # the final `event: end` frame carries {}
                print(f"[{event['phase']}] {event['line']}")

// Browser: EventSource doesn't send Authorization headers, so stream with fetch.
const r = await fetch(
  "https://www.orgo.ai/api/templates/default/claude-code/1.0.0/build/events",
  { headers: { Authorization: `Bearer ${process.env.ORGO_API_KEY}` } },
);
const reader = r.body.getReader();
const decoder = new TextDecoder();
for (;;) {
  const { value, done } = await reader.read();
  if (done) break;
  for (const line of decoder.decode(value).split("\n")) {
    if (line.startsWith("data: ")) {
      const e = JSON.parse(line.slice(6));
      if ("line" in e) console.log(`[${e.phase}] ${e.line}`); // skip the final {} frame
    }
  }
}

Stream

data: {"ts":"2026-06-08T17:00:01Z","level":"info","phase":"boot","source":"vm","line":"copying base rootfs"}

data: {"ts":"2026-06-08T17:00:14Z","level":"info","phase":"install","source":"app-install","line":"npm install -g @anthropic-ai/claude-code"}

data: {"ts":"2026-06-08T17:01:50Z","level":"success","phase":"snapshot","source":"vm","line":"snapshot captured"}

data: {"ts":"2026-06-08T17:01:58Z","level":"success","phase":"ready","line":"build complete in 118420ms"}

event: end
data: {}

Errors

Errors arrive as a JSON body with the status below, not as an event frame. A 200 always carries Content-Type: text/event-stream.

Status	Body	Meaning
`401`	`{ "error": "Invalid API key" }`	The Bearer token starts with `sk_` but is not a known Orgo key.
`401`	`{ "error": "Authentication required" }`	No `Authorization` header, or a Bearer token that is not an `sk_` key.
`401`	`{ "error": "This endpoint requires an account-wide credential (workspace_scope_mismatch)." }`	The key is workspace-scoped. Template endpoints need an account-wide key. This route answers with `401`, not `403`.
`401`	`{ "error": "Service temporarily unavailable. …" }`	Orgo could not verify the key because of a server-side fault. The key is fine. Retry.
`404`	`{ "error": string }`	No such template version in your namespaces, or no build of it is running on the registry host (`"no build in progress for this template"`). Forwarded from the build host.
`502`	`{ "error": "upstream fetch failed: …" }`	The build host could not be reached. Retry.
`503`	`{ "error": string }`	No fleet host is available to serve the stream. Retry.

Authorizations

Authorization

string

header

required

API key authentication. Get your key at orgo.ai/workspaces

Path Parameters

namespace

string

required

name

string

required

version

string

required

Response

SSE stream of BuildEvent frames

One frame of the build-events SSE stream.

string<date-time>

level

enum<string>

Available options:

info,

success,

warn,

error

phase

enum<string>

Available options:

queue,

publish,

compile,

boot,

settle,

install,

build,

snapshot,

record,

archive,

ready,

cancel,

timeout

source

string

Origin of the line, e.g. apt, pip, npm, builder.

line

string

A single line of build output.

Stream build logs

curl --request GET \
  --url https://www.orgo.ai/api/templates/{namespace}/{name}/{version}/build/events \
  --header 'Authorization: Bearer <token>'

import requests

url = "https://www.orgo.ai/api/templates/{namespace}/{name}/{version}/build/events"

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

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

print(response.text)

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

fetch('https://www.orgo.ai/api/templates/{namespace}/{name}/{version}/build/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_URL => "https://www.orgo.ai/api/templates/{namespace}/{name}/{version}/build/events",
  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://www.orgo.ai/api/templates/{namespace}/{name}/{version}/build/events"

	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://www.orgo.ai/api/templates/{namespace}/{name}/{version}/build/events")

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

{
  "ts": "2023-11-07T05:31:56Z",
  "level": "info",
  "phase": "queue",
  "source": "<string>",
  "line": "<string>"
}

Overview

Account

Clients

Computer Use API

Workspaces

Computers

Computer Lifecycle

Computer Actions

Screens

Files

Templates

Stream build logs

Path parameters

Example

Stream

Errors

Authorizations

Path Parameters

Response

​Path parameters

​Example

​Stream

​Errors

Authorizations

Path Parameters

Response

Path parameters

Example

Stream

Errors