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

# The caller's work queue

GET https://api.cloudraker.com/me/work

Everything waiting on the caller across all runs they can see, in four kinds: pending `approval`s (any space member with access may decide), ready `human_task`s assigned to them or unassigned (anyone in the space may complete those; claiming is optional), `run_attention` — a run **they started** that failed, or that parked on a person with nobody watching (an overnight automation or a channel message) — and `connector`, a connection in a space they can read whose authorization broke and needs re-auth. A run that already has an approval or task row never also gets a `run_attention` row. Grouped by run, newest run first, cursor-paginated via `starting_after` (up to 20 runs per page); `connector` items ride one extra group with `runId: null`. Reads best-effort projections — `asOf` (response) and per-run `asOf` mark staleness; a decision made seconds ago may still appear until the projection catches up, and clients poll this route (there is no push), so the badge can lag the thread you are looking at by up to 30 seconds. Both scans are capped at 200 rows, so `totalCount` — the badge number: all pending items for the caller across all pages — saturates there. Authorization: any authenticated member; non-admins see only spaces they hold `space:read` on.

Reference: https://docs.cloudraker.com/workspace/api/me/get-my-work

## Authentication

- `Authorization` header (bearer token, required)

## Response

### 200

The work queue, grouped by run.

- `data` (list of object, required)
  - `runId` (string, required, nullable)
  - `spaceId` (string, required, nullable)
  - `playbookName` (string, required, nullable)
  - `runCreatedAt` (datetime, required, nullable)
  - `asOf` (datetime, required, nullable)
  - `items` (list of object, required)
    - `kind` (enum, required)
      - Allowed values: `approval`, `human_task`, `run_attention`, `connector`
    - `runId` (string, required, nullable)
    - `spaceId` (string, required)
    - `threadId` (string, required, nullable)
    - `playbookName` (string, required, nullable)
    - `itemId` (string, required)
    - `title` (string, required)
    - `approvalKind` (enum, required, nullable)
      - Allowed values: `pre`, `post`
    - `assignee` (string, required, nullable)
    - `status` (string, required, nullable)
    - `requestedAt` (datetime, required, nullable)
    - `attention` (enum, required, nullable)
      - Allowed values: `waiting`, `failed`
    - `unattended` (boolean, required, nullable)
    - `origin` (enum, required, nullable)
      - Allowed values: `automation`, `channel`, `api`
    - `originId` (string, required, nullable)
    - `reauthUrl` (string, required, nullable)
    - `brokenCode` (string, required, nullable)
- `totalCount` (integer, required)
- `nextCursor` (string, required, nullable)
- `asOf` (datetime, required)

## Examples

**Response**

```json
{
  "data": [
    {
      "runId": "string",
      "spaceId": "string",
      "playbookName": "string",
      "runCreatedAt": "2024-01-15T09:30:00Z",
      "asOf": "2024-01-15T09:30:00Z",
      "items": [
        {
          "kind": "approval",
          "runId": "string",
          "spaceId": "string",
          "threadId": "string",
          "playbookName": "string",
          "itemId": "string",
          "title": "string",
          "approvalKind": "pre",
          "assignee": "string",
          "status": "string",
          "requestedAt": "2024-01-15T09:30:00Z",
          "attention": "waiting",
          "unattended": true,
          "origin": "automation",
          "originId": "string",
          "reauthUrl": "string",
          "brokenCode": "string"
        }
      ]
    }
  ],
  "totalCount": 1,
  "nextCursor": "string",
  "asOf": "2024-01-15T09:30:00Z"
}
```

**SDK Code**

```python
import requests

url = "https://api.cloudraker.com/me/work"

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

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

print(response.json())
```

```javascript
const url = 'https://api.cloudraker.com/me/work';
const options = {method: 'GET', headers: {Authorization: 'Bearer <token>'}};

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.cloudraker.com/me/work"

	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(res)
	fmt.Println(string(body))

}
```

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

url = URI("https://api.cloudraker.com/me/work")

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
```

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

HttpResponse<String> response = Unirest.get("https://api.cloudraker.com/me/work")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.cloudraker.com/me/work', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.cloudraker.com/me/work");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.cloudraker.com/me/work")! 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()
```