Orgo - Cloud computers for AI agents

POST

templates

validate

Validate template

curl --request POST \
  --url https://www.orgo.ai/api/templates/validate \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/yaml' \
  --data '<string>'

import requests

url = "https://www.orgo.ai/api/templates/validate"

payload = "<string>"
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/yaml"
}

response = requests.post(url, data=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/yaml'},
  body: '<string>'
};

fetch('https://www.orgo.ai/api/templates/validate', 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/validate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "<string>",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/yaml"
  ],
]);

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

curl_close($curl);

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

package main

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

func main() {

	url := "https://www.orgo.ai/api/templates/validate"

	payload := strings.NewReader("<string>")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/yaml")

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

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

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://www.orgo.ai/api/templates/validate")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/yaml")
  .body("<string>")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://www.orgo.ai/api/templates/validate")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/yaml'
request.body = "<string>"

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

{
  "ok": true,
  "template": {
    "api_version": "orgo.ai/v1",
    "template": {
      "name": "claude-code",
      "version": "1.0.0",
      "description": "<string>"
    },
    "hardware": {},
    "secrets": [
      {}
    ],
    "vars": {},
    "env": {},
    "build": {},
    "files": "<array>",
    "apps": "<array>",
    "triggers": "<array>",
    "terminal": "<array>",
    "hooks": {},
    "telemetry": {},
    "egress_policy": {},
    "streaming": "<array>"
  },
  "errors": [
    {
      "field": "hardware.cpu",
      "code": "invalid_enum",
      "message": "<string>",
      "hint": "<string>"
    }
  ]
}

Validates a template against the orgo.ai/v1 schema and returns either the normalized document or a structured list of errors. This endpoint has no side effects. Nothing is written, so it is cheap enough to call on every keystroke in an editor. Validate is also the right way to check a sugar-form template: it desugars server-side, which the published JSON Schema cannot do.

Request body

The raw template document. Send Content-Type: application/yaml to parse it as YAML. The body is parsed as YAML whenever the content type contains yaml; anything else is parsed as JSON. An empty body returns 400.

Response

boolean

true if the template is valid.

object

The normalized template (sugar expanded into canonical form). Present when ok is true.

array

Present when ok is false, alongside a 422 status. Each entry pinpoints one problem.

Show error

string

Dotted path to the offending field, e.g. hardware.cpu or files[2].to.

string

Machine-readable code, one of: required, invalid_enum, invalid_format, invalid_value, unsafe_path, mutex_conflict, unknown_reference, duplicate, unknown_api_version.

string

Human-readable explanation.

string

Suggestion for fixing it. Present on some errors only.

Example

curl -X POST https://www.orgo.ai/api/templates/validate \
  -H "Authorization: Bearer $ORGO_API_KEY" \
  -H "Content-Type: application/yaml" \
  --data-binary @claude-code.yaml

import os, requests

r = requests.post(
    "https://www.orgo.ai/api/templates/validate",
    headers={
        "Authorization": f"Bearer {os.environ['ORGO_API_KEY']}",
        "Content-Type": "application/yaml",
    },
    data=open("claude-code.yaml").read(),
)
result = r.json()
if not result["ok"]:
    for e in result["errors"]:
        print(f"{e['field']}: {e['message']}")

import { readFileSync } from "node:fs";

const r = await fetch("https://www.orgo.ai/api/templates/validate", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.ORGO_API_KEY}`,
    "Content-Type": "application/yaml",
  },
  body: readFileSync("claude-code.yaml", "utf8"),
});
const result = await r.json();
if (!result.ok) console.error(result.errors);

Valid response

{
  "ok": true,
  "template": {
    "api_version": "orgo.ai/v1",
    "template": { "name": "claude-code", "version": "1.0.0" }
  }
}

Invalid response (`422`)

{
  "ok": false,
  "errors": [
    {
      "field": "hardware.cpu",
      "code": "invalid_enum",
      "message": "must be 1, 2, 4, 8, or 16"
    }
  ]
}

Errors

A validation failure is the 422 above: ok is false and the body carries errors, with no error field. Everything else is a transport-level failure.

Status	Body	Meaning
`400`	`{ "error": "request body required" }`	Empty body.
`400`	`{ "error": string }`	The body could not be parsed as a template: not valid YAML or JSON, or not a canonical, sugar, or `{namespace, name, version, template}` envelope document.
`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.
`403`	`{ "error": "This endpoint requires an account-wide credential (workspace_scope_mismatch).", "code": "workspace_scope_mismatch" }`	The key is workspace-scoped. Template endpoints need an account-wide key.
`422`	`{ "ok": false, "errors": [...] }`	The template is invalid.
`429`	`{ "error": string, "code": "validate_rate_limited" }`	Validate rate limit reached. Back off and retry.
`500`	`{ "error": string }`	Unexpected server error (`"internal error"`), or the validator host failed or timed out. Retry.
`503`	`{ "error": "Service temporarily unavailable. …" }`	Orgo could not verify the key because of a server-side fault. The key is fine. Retry. The response carries `Retry-After: 5`.
`503`	`{ "error": string }`	No fleet host is available to run the validator. Retry.

Authorizations

Authorization

string

header

required

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

Body

The body is of type string.

Response

Validation result

boolean

template

object

An orgo.ai/v1 template document. Only api_version and template are required. See the full JSON Schema at GET /template-schema, or the schema guide at https://docs.orgo.ai/guides/templates/schema.

Show child attributes

errors

object[]

Show child attributes

Validate template

curl --request POST \
  --url https://www.orgo.ai/api/templates/validate \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/yaml' \
  --data '<string>'

import requests

url = "https://www.orgo.ai/api/templates/validate"

payload = "<string>"
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/yaml"
}

response = requests.post(url, data=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/yaml'},
  body: '<string>'
};

fetch('https://www.orgo.ai/api/templates/validate', 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/validate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "<string>",
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/yaml"
  ],
]);

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

curl_close($curl);

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

package main

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

func main() {

	url := "https://www.orgo.ai/api/templates/validate"

	payload := strings.NewReader("<string>")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/yaml")

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

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

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://www.orgo.ai/api/templates/validate")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/yaml")
  .body("<string>")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://www.orgo.ai/api/templates/validate")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/yaml'
request.body = "<string>"

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

{
  "ok": true,
  "template": {
    "api_version": "orgo.ai/v1",
    "template": {
      "name": "claude-code",
      "version": "1.0.0",
      "description": "<string>"
    },
    "hardware": {},
    "secrets": [
      {}
    ],
    "vars": {},
    "env": {},
    "build": {},
    "files": "<array>",
    "apps": "<array>",
    "triggers": "<array>",
    "terminal": "<array>",
    "hooks": {},
    "telemetry": {},
    "egress_policy": {},
    "streaming": "<array>"
  },
  "errors": [
    {
      "field": "hardware.cpu",
      "code": "invalid_enum",
      "message": "<string>",
      "hint": "<string>"
    }
  ]
}

Overview

API keys

Support

Account

Agent accounts

Clients

Computer Use API

Workspaces

Computers

Computer Lifecycle

Computer Actions

Screens

Files

Templates

Validate template

Request body

Response

Example

Valid response

Invalid response (`422`)

Errors

Authorizations

Body

Response

​Request body

​Response

​Example

​Valid response

​Invalid response (422)

​Errors

Authorizations

Body

Response

Request body

Response

Example

Valid response

Invalid response (`422`)

Errors