Orgo - Cloud computers for AI agents

POST

computers

{id}

wait

Wait

curl --request POST \
  --url https://www.orgo.ai/api/computers/{id}/wait \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "seconds": 2
}'

import requests

url = "https://www.orgo.ai/api/computers/{id}/wait"

payload = { "seconds": 2 }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({seconds: 2})
};

fetch('https://www.orgo.ai/api/computers/{id}/wait', 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/computers/{id}/wait",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'seconds' => 2
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

$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/computers/{id}/wait"

	payload := strings.NewReader("{\n  \"seconds\": 2\n}")

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

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

	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/computers/{id}/wait")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"seconds\": 2\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://www.orgo.ai/api/computers/{id}/wait")

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/json'
request.body = "{\n  \"seconds\": 2\n}"

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

{
  "success": true,
  "action": "wait",
  "details": {
    "seconds": 2
  },
  "error": null,
  "error_type": null
}

Pauses on the computer for the given duration. The request blocks until the wait completes, so the round trip is at least as long as the pause you asked for.

Path parameters

string

required

Computer ID (UUID). An instance_id is not accepted here and fails with 500.

Body parameters

number

required

How long to pause, in seconds. Must be greater than 0 and no more than 60. Fractional values are allowed. Omitting it is the same as sending 0 and returns 400. There is no default.

number

deprecated

Deprecated alias for seconds, accepted for backwards compatibility. It is read only when seconds is absent; if you send both, seconds wins and duration is discarded. Same range and same validation.

Windows computers do not support wait. Their agent has no wait endpoint, so the request returns 404 with upstream_status: 404. Pause on your side instead.

wait takes no ?screen= parameter. Unlike the pointer and keyboard actions, sending one here is silently ignored rather than rejected. The pause is not tied to a screen.

Response

boolean

Always true on a 200.

string

Always wait.

object

Carries seconds, an echo of the duration that was waited.

Example

curl -X POST https://www.orgo.ai/api/computers/$COMPUTER_ID/wait \
  -H "Authorization: Bearer $ORGO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"seconds": 2.0}'

import requests

# Wait 2 seconds
requests.post(
    f"https://www.orgo.ai/api/computers/{computer_id}/wait",
    headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
    json={"seconds": 2.0}
)

// Wait 2 seconds
await fetch(`https://www.orgo.ai/api/computers/${computerId}/wait`, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ seconds: 2.0 })
});

Response

{
  "success": true,
  "action": "wait",
  "details": { "seconds": 2 },
  "error": null,
  "error_type": null
}

Use waits sparingly. Prefer polling for the condition you actually care about, such as window focus or a file change, over fixed delays.

Errors

Status	Meaning
`400`	`seconds` is missing, `0`, or negative: `{"error": "wait duration must be positive"}`. Over 60 seconds returns `{"error": "wait duration 1m5s exceeds maximum of 1m0s"}`. Also returned when the computer has no VM attached (`{"error": "Desktop instance not available"}`), and by the computer agent when a body field has the wrong JSON type, such as `seconds` sent as a string rather than a number.
`401`	Invalid API key: `{"error": "Invalid API key"}`. A request with no `Authorization` header returns `{"error": "Authentication required"}`. Access failures also return `401` on this endpoint, not `403`: `{"error": "You do not have access to this workspace."}` when you are neither the owner nor a member of the computer’s workspace, `{"error": "This workspace is view-only. Ask the owner for write access (workspace_read_only)."}` for a view-only member, and `{"error": "This API key cannot access this workspace (workspace_scope_mismatch)."}` for a workspace-scoped key used outside its workspace. A server-side fault while verifying the credential also returns `401` here, with `{"error": "Service temporarily unavailable. …"}`. Retry that one; the key is fine.
`402`	The computer was created as a free trial that is no longer active: `{"error": "Choose a plan to continue."}`.
`404`	No computer with this id: `{"error": "Desktop not found"}`. A Windows computer also returns `404` for every wait, with `upstream_status: 404`.
`500`	The request body is not valid JSON, or the request failed for a reason the API could not classify.
`503`	The computer could not be reached: `{"error": "Could not reach the desktop. Try again in a moment.", "code": "ECONNREFUSED"}`. Safe to retry. A computer that never finished provisioning also returns `503`, with `{"error": "Computer not ready"}`.

Every failure raised after the request leaves the API layer also carries a request_id. Quote it in support requests. When the computer agent itself answered non-2xx, the body additionally carries upstream_status.

{
  "error": "wait duration must be positive",
  "request_id": "9f2b7c3d-4e5f-6a7b-8c9d-0e1f2a3b4c5d",
  "upstream_status": 400
}

Authorizations

Authorization

string

header

required

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

Path Parameters

string

required

Computer ID

Body

application/json

seconds

number

required

How long to pause, in seconds. Must be greater than 0 and no more than 60; fractions are allowed. Missing, 0, negative, or over 60 returns 400.

Required range: x <= 60

duration

number

deprecated

Deprecated alias for seconds. Read only when seconds is absent.

Required range: x <= 60

Response

Wait completed

success

boolean

Always true on a 200. A failed action is an error status.

Example:

true

action

string

The action performed: click, mouse_move, drag, type, key_press, scroll, or wait.

details

object

Echo of what was performed. Its fields depend on the action.

error

null

Always null on a 200.

error_type

null

Always null on a 200.

Wait

curl --request POST \
  --url https://www.orgo.ai/api/computers/{id}/wait \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '{
  "seconds": 2
}'

import requests

url = "https://www.orgo.ai/api/computers/{id}/wait"

payload = { "seconds": 2 }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({seconds: 2})
};

fetch('https://www.orgo.ai/api/computers/{id}/wait', 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/computers/{id}/wait",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'seconds' => 2
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

$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/computers/{id}/wait"

	payload := strings.NewReader("{\n  \"seconds\": 2\n}")

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

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

	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/computers/{id}/wait")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"seconds\": 2\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://www.orgo.ai/api/computers/{id}/wait")

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/json'
request.body = "{\n  \"seconds\": 2\n}"

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

{
  "success": true,
  "action": "wait",
  "details": {
    "seconds": 2
  },
  "error": null,
  "error_type": null
}

Overview

Account

Clients

Computer Use API

Workspaces

Computers

Computer Lifecycle

Computer Actions

Screens

Files

Templates

Wait

Path parameters

Body parameters

Response

Example

Response

Errors

Authorizations

Path Parameters

Body

Response

​Path parameters

​Body parameters

​Response

​Example

​Response

​Errors

Authorizations

Path Parameters

Body

Response

Path parameters

Body parameters

Response

Example

Response

Errors