> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.athenaintel.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.athenaintel.com/_mcp/server.

# Read a computer's live state

GET https://api.athenaintel.com/api/v0/computer/{asset_id}/status

Read an existing computer's live runtime state and whether it is ready, without starting, waking, or repairing it. Works for every computer, including those created before durable initialization (`get_initialization` reports creation-time progress only). Requires membership in the computer's workspace and VIEW access. This read does not count as activity, so polling it does not keep the computer awake.

**Waiting for a computer.** Call `start_computer`, then poll this endpoint every few seconds until `ready` is true; stop polling when `not_ready_reason` is `launcher_outdated`. `start_computer` waits for the computer, but a proxy in front of the API can end a long request (about 60 seconds on Athena's ingress) while the start continues on the server. The server waits up to 210 seconds by default for the computer's runtime to boot before it reports a failure, and Athena alerts its operators when the 90th percentile of starts goes above 3 minutes.

**Auto-stop.** A computer stops after its `auto_stop_minutes` of inactivity (60 minutes unless the computer or the deployment sets another value; 0 means it never stops on its own). Activity is work inside the computer — commands, terminal and SSH sessions, file operations — and requests to its deployed URLs. Status reads are not activity.

**The asset record's `status`.** The computer's `status` in `GET /assets/{asset_id}` records the last lifecycle change Athena recorded (create, Start, Stop); it is not a live read. It can read `running` while the computer is stopped, for example after an idle auto-stop, or `stopped` after something woke it. Use this endpoint for the live state.

Returns 403 when the caller is not a member of the computer's workspace, 409 while the computer is still being created or when its creation failed, 404 when the asset does not exist or its runtime is gone for good (stop polling), and 502 when the runtime could not be read (retry).

Reference: https://docs.athenaintel.com/api-reference/computer/get-status

## Authentication

- `X-API-KEY` header (required) — API Key authentication via header

## Request

### Path parameters

- `asset_id` (string, required)

## Response

### 200

Successful Response

- `asset_id` (string, required) — The computer asset id.
- `ready` (boolean, required) — Whether the computer serves work now: `state` is `started` and the guest answers ready (its workspace attached and its environment applied). Only then do commands, SSH sessions and deployed URLs reach the computer without first waiting for a start. `started` alone can come a few seconds before `ready`.
- `state` (string, required) — The runtime's current state: `started` (running; check `ready`), `stopped` (suspended — by idle auto-stop or by Stop; files are kept), `restoring` (a start is in progress), `error` (the runtime failed; start or restart it), or `unknown` (the state could not be read this time; retry). `started`, `stopped` and `error` hold until something changes them; `restoring` and `unknown` are transient.
- `explicit_stop` (enum, optional, nullable) — Set when someone stopped the computer with Stop. While it is `stopping`, `stopped` or `uncertain`, implicit wakes are refused: minting SSH access answers 409 and an SSH connection does not start it. Call `start_computer` to clear it. `null` or `cleared` means no explicit stop is in force.
  - Allowed values: `stopping`, `stopped`, `uncertain`, `cleared`
- `not_ready_reason` (enum, optional, nullable) — Why `ready` is false; `null` when it is true. `not_started`: the computer is not running — call `start_computer`. `starting`: it is running and its guest is still coming up — keep polling. `unobservable`: readiness could not be read this time — keep polling. `launcher_outdated`: the computer runs an outdated runtime component that polling will not change — stop it and start it again to update it.
  - Allowed values: `not_started`, `starting`, `launcher_outdated`, `unobservable`
- `provider` (string, optional, nullable) — The computer's runtime provider (e.g. `talos_v2`).

## Errors

### 401 Unauthorized Error

Unauthorized

- `message` (string, required)

### 403 Forbidden Error

Forbidden

- `map from string to any`

### 404 Not Found Error

Not Found

- `message` (string, required)

### 409 Conflict Error

Conflict

- `map from string to any`

### 422 Unprocessable Entity Error

Validation Error

- `detail` (list of ValidationError, optional)

### 502 Bad Gateway Error

Bad Gateway

- `map from string to any`

## Types

### ValidationError

- `loc` (list of ValidationErrorLocItems, required)
- `msg` (string, required)
- `type` (string, required)
- `ctx` (ValidationErrorCtx, optional)
- `input` (any, optional)

### ValidationErrorLocItems

- string
- integer

### ValidationErrorCtx

## Examples

**Response**

```json
{
  "asset_id": "asset_9249292-d118-42d3-95b4-00eccfe0754f",
  "ready": true,
  "state": "started",
  "provider": "talos_v2"
}
```

**SDK Code**

```python
import requests

url = "https://api.athenaintel.com/api/v0/computer/asset_id/status"

headers = {"X-API-KEY": "<apiKey>"}

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

print(response.json())
```

```javascript
const url = 'https://api.athenaintel.com/api/v0/computer/asset_id/status';
const options = {method: 'GET', headers: {'X-API-KEY': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

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

func main() {

	url := "https://api.athenaintel.com/api/v0/computer/asset_id/status"

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

	req.Header.Add("X-API-KEY", "<apiKey>")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.athenaintel.com/api/v0/computer/asset_id/status")

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

request = Net::HTTP::Get.new(url)
request["X-API-KEY"] = '<apiKey>'

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

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.athenaintel.com/api/v0/computer/asset_id/status")
  .header("X-API-KEY", "<apiKey>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.athenaintel.com/api/v0/computer/asset_id/status', [
  'headers' => [
    'X-API-KEY' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.athenaintel.com/api/v0/computer/asset_id/status");
var request = new RestRequest(Method.GET);
request.AddHeader("X-API-KEY", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["X-API-KEY": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.athenaintel.com/api/v0/computer/asset_id/status")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```