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

# Trace a conversation

GET https://api.runtype.com/v1/logs/trace/conversation/{conversationId}

Returns trace data for all executions within a conversation.

Reference: https://docs.runtype.com/api-reference/runtype-api/logs/trace-a-conversation

## Authentication

- `Authorization` header (bearer token, required) — API key or Clerk session token

## Servers

- `https://api.runtype.com` (Production, default)
- `https://api.runtype-staging.com` (Staging)

## Request

### Path parameters

- `conversationId` (string, required) — Conversation ID to trace

## Response

### 200

Conversation trace returned

- `data` (ConversationTrace, required)
- `success` (boolean, required)

## Errors

### 400 Bad Request Error

Invalid request

- `error` (string, required)
- `code` (string, optional) — Stable error code. `insufficient_scope` marks an API key that lacks a scope this request needs.
- `details` (list of ErrorDetailsItems, optional)
- `requiredScopes` (list of string, optional) — On `insufficient_scope`: every API key scope this request needs.

### 401 Unauthorized Error

Unauthorized

- `error` (string, required)
- `code` (string, optional) — Stable error code. `insufficient_scope` marks an API key that lacks a scope this request needs.
- `details` (list of ErrorDetailsItems, optional)
- `requiredScopes` (list of string, optional) — On `insufficient_scope`: every API key scope this request needs.

### 403 Forbidden Error

API key lacks a read scope (FLOWS:READ, AGENTS:READ or ANALYTICS:READ)

- `error` (string, required)
- `code` (string, optional) — Stable error code. `insufficient_scope` marks an API key that lacks a scope this request needs.
- `details` (list of ErrorDetailsItems, optional)
- `requiredScopes` (list of string, optional) — On `insufficient_scope`: every API key scope this request needs.

### 500 Internal Server Error

Internal server error

- `error` (string, required)
- `code` (string, optional) — Stable error code. `insufficient_scope` marks an API key that lacks a scope this request needs.
- `details` (list of ErrorDetailsItems, optional)
- `requiredScopes` (list of string, optional) — On `insufficient_scope`: every API key scope this request needs.

## Types

### ConversationTrace

- `conversationId` (string, required)
- `executions` (list of ConversationTraceExecutionsItems, required)
- `totalExecutions` (double, required)
- `producedBy` (ConversationTraceProducedBy, optional) — What authored the conversation as a whole; absent when unresolved.
- `signals` (ConversationTraceSignals, optional) — Conversation-level signals: the union of what fired across the turns. Each turn also carries its own block on its tree. Omitted until the organization binds a signal set.
- `truncation` (ConversationTraceTruncation, optional)

### ErrorDetailsItems

- `message` (string, required)
- `code` (string, optional) — Stable Runtype validation code (e.g. MISSING_REQUIRED_FIELD, INVALID_ENUM).
- `path` (string, optional) — Dotted JSON path to the offending field.
- `suggestion` (string, optional) — Actionable hint (allowed values, accepted range, …).

### ConversationTraceExecutionsItems

- `executionId` (string, required)
- `timestamp` (string, required)
- `tree` (TraceTree, required)

### ConversationTraceProducedBy

What authored the conversation as a whole; absent when unresolved.

- `source` (enum, required)
  - Allowed values: `native`, `external`
- `adapterName` (string, optional, nullable)
- `adapterVersion` (string, optional, nullable)
- `agentId` (string, optional, nullable)
- `agentName` (string, optional, nullable)
- `agentVersionId` (string, optional, nullable)
- `agentVersionLabel` (string, optional, nullable)
- `callable` (boolean, optional)
- `fidelityTier` (string, optional, nullable)
- `flowId` (string, optional, nullable)
- `flowName` (string, optional, nullable)
- `flowVersionId` (string, optional, nullable)
- `productId` (string, optional, nullable)
- `productName` (string, optional, nullable)
- `surfaceType` (string, optional, nullable)

### ConversationTraceSignals

Conversation-level signals: the union of what fired across the turns. Each turn also carries its own block on its tree. Omitted until the organization binds a signal set.

- `fired` (list of string, required)
- `results` (list of SignalResult, required)
- `status` (enum, required)
  - Allowed values: `complete`, `pending`, `partial`, `none`, `unavailable`

### ConversationTraceTruncation

- `limit` (double, required)
- `message` (string, required)
- `reason` (enum, required)
  - Allowed values: `record_limit`

### TraceTree

- `nodeCount` (double, required)
- `root` (TraceNode, required, nullable)
- `totalCost` (double, required, nullable)
- `totalDuration` (double, required, nullable)
- `totalTokens` (double, required, nullable)
- `availability` (TraceTreeAvailability, optional)
- `childTruncation` (TraceTreeChildTruncation, optional) — Present only when the child-run read hit its per-parent ceiling, so later child runs are not grafted and their tool-call spans carry no `childExecutionId`. Absent otherwise.
- `contentUnavailable` (boolean, optional) — A span with spilled content could not be read back; those spans carry previews.
- `failedCount` (double, optional)
- `producedBy` (TraceProducedBy, optional)
- `runFailed` (boolean, optional) — The run itself failed, as opposed to a span inside a run that completed.
- `signals` (SignalsBlock, optional) — Typed signals read from this trace by the signal sets bound to its agent. Omitted entirely until the organization binds a signal set; once it has, `status` is `none` on a trace no binding matched.
- `source` (enum, optional)
  - Allowed values: `logs`, `records`, `logs+records`
- `startedAt` (string, optional, nullable)
- `toolTimeMs` (double, optional, nullable)
- `toolTimeOverlapped` (boolean, optional)
- `totalsSource` (enum, optional)
  - Allowed values: `execution`, `partial`
- `truncation` (TraceTreeTruncation, optional)

### SignalResult

- `answers` (map from string to SignalAnswer, required)
- `bindingId` (string, required)
- `computedAt` (string, required)
- `fired` (list of string, required)
- `sample` (enum, required)
  - Allowed values: `uniform`, `filtered`
- `signalSet` (SignalResultSignalSet, required)
- `status` (enum, required)
  - Allowed values: `complete`, `failed`, `skipped_budget`, `skipped_policy`, `skipped_billing`
- `target` (SignalResultTarget, required)
- `unit` (enum, required)
  - Allowed values: `turn`, `conversation`, `run`
- `values` (map from string to any, required)
- `error` (string, optional)

### TraceNode

- `children` (list of TraceNode, required)
- `depth` (double, required)
- `entry` (TraceLogEntry, required)
- `nodeType` (enum, required)
  - Allowed values: `root`, `iteration`, `model`, `tool`, `step`, `system`
- `childExecutionId` (string, optional, nullable)
- `endOffsetMs` (double, optional, nullable)
- `endedAt` (string, optional, nullable)
- `failed` (boolean, optional)
- `lifecycle` (enum, optional)
  - Allowed values: `single`, `paired`, `start-only`, `complete-only`
- `recorded` (boolean, optional)
- `signals` (TraceNodeSignals, optional) — Signal results that target this span. Omitted until the organization binds a signal set.
- `startEntry` (TraceLogEntry, optional)
- `startOffsetMs` (double, optional, nullable)
- `startedAt` (string, optional, nullable)
- `synthetic` (boolean, optional)

### TraceTreeAvailability

- `available` (boolean, required)
- `message` (string, required)
- `reason` (enum, required)
  - Allowed values: `json_ingest_compatibility_path`

### TraceTreeChildTruncation

Present only when the child-run read hit its per-parent ceiling, so later child runs are not grafted and their tool-call spans carry no `childExecutionId`. Absent otherwise.

- `limit` (double, required)
- `message` (string, required)
- `reason` (enum, required)
  - Allowed values: `child_limit`

### TraceProducedBy

- `source` (enum, required)
  - Allowed values: `native`, `external`
- `adapterName` (string, optional, nullable)
- `adapterVersion` (string, optional, nullable)
- `agentId` (string, optional, nullable)
- `agentName` (string, optional, nullable)
- `agentVersionId` (string, optional, nullable)
- `agentVersionLabel` (string, optional, nullable)
- `callable` (boolean, optional)
- `fidelityTier` (string, optional, nullable)
- `flowId` (string, optional, nullable)
- `flowName` (string, optional, nullable)
- `flowVersionId` (string, optional, nullable)
- `productId` (string, optional, nullable)
- `productName` (string, optional, nullable)
- `surfaceType` (string, optional, nullable)

### SignalsBlock

Typed signals read from this trace by the signal sets bound to its agent. Omitted entirely until the organization binds a signal set; once it has, `status` is `none` on a trace no binding matched.

- `fired` (list of string, required)
- `results` (list of SignalResult, required)
- `status` (enum, required)
  - Allowed values: `complete`, `pending`, `partial`, `none`, `unavailable`

### TraceTreeTruncation

- `limit` (double, required)
- `message` (string, required)
- `reason` (enum, required)
  - Allowed values: `record_limit`

### SignalAnswer

- `band` (enum, required)
  - Allowed values: `act`, `review`, `low`
- `confidence` (double, optional)
- `distribution` (map from string to double, optional)
- `fired` (boolean, optional)
- `pNull` (double, optional)
- `refused` (boolean, optional)
- `source` (SignalSource, optional)
- `sources` (list of SignalSource, optional)
- `value` (any, optional)

### SignalResultSignalSet

- `id` (string, required)
- `name` (string, required)
- `version` (integer, required)

### SignalResultTarget

- `executionId` (string, required)
- `spanId` (string, required, nullable)
- `turnIndex` (integer, required, nullable)

### TraceLogEntry

- `id` (string, required)
- `level` (enum, required)
  - Allowed values: `debug`, `info`, `warn`, `error`
- `status` (enum, required)
  - Allowed values: `running`, `completed`, `failed`, `queued`, `cancelled`, `unknown`
- `timestamp` (string, required)
- `title` (string, required)
- `type` (enum, required)
  - Allowed values: `flow`, `step`, `tool`, `batch`, `system`, `agent`, `model`, `schedule`, `audit`
- `agentId` (string, optional, nullable)
- `agentName` (string, optional, nullable)
- `batchExecutionId` (string, optional, nullable)
- `cacheReadTokens` (double, optional, nullable)
- `cacheWriteTokens` (double, optional, nullable)
- `completionTokens` (double, optional, nullable)
- `configuredModel` (string, optional, nullable)
- `conversationId` (string, optional, nullable)
- `description` (string, optional)
- `durationMs` (double, optional, nullable)
- `error` (string, optional, nullable)
- `errorStack` (string, optional, nullable)
- `estimatedContextBreakdown` (TraceLogEntryEstimatedContextBreakdown, optional, nullable)
- `estimatedCost` (TraceLogEntryEstimatedCost, optional, nullable) — Observed cost. Absent or null means unknown, never zero.
- `eventName` (string, optional, nullable)
- `executionSessionId` (string, optional, nullable)
- `fallbackModel` (string, optional, nullable)
- `flowId` (string, optional, nullable)
- `flowName` (string, optional, nullable)
- `input` (any, optional) — Arbitrary JSON; shape varies by producer.
- `inputSummary` (string, optional, nullable)
- `isStreaming` (boolean, optional)
- `iteration` (double, optional, nullable)
- `loggingPolicy` (enum, optional)
  - Allowed values: `off`
- `metadata` (map from string to any, optional) — Producer bag. Span-store reads carry spanKind, completeness, logicalParentId, otlpAttributes, otlpSpanEvents, systemInstructions, artifacts and state here.
- `modelUsed` (string, optional, nullable)
- `otlpIncompleteActivity` (enum, optional)
  - Allowed values: `invoke_agent`, `chat`, `execute_tool`
- `otlpInstrumentationWarning` (enum, optional)
  - Allowed values: `span_not_ended`
- `otlpOperationName` (string, optional, nullable)
- `otlpParentSpanId` (string, optional, nullable)
- `otlpRecordHash` (string, optional, nullable)
- `otlpRecordKind` (enum, optional)
  - Allowed values: `span`, `span_event`, `log_record`
- `otlpRetentionScope` (string, optional, nullable)
- `otlpSpanEventIndex` (double, optional, nullable)
- `otlpSpanId` (string, optional, nullable)
- `output` (any, optional) — Arbitrary JSON; shape varies by producer.
- `outputSummary` (string, optional, nullable)
- `promptTokens` (double, optional, nullable)
- `providerErrorClass` (string, optional, nullable)
- `providerHost` (string, optional, nullable)
- `providerHttpMethod` (string, optional, nullable)
- `providerHttpStatus` (double, optional, nullable)
- `providerRateLimitHeaders` (map from string to string, optional, nullable)
- `reasoningTokens` (double, optional, nullable)
- `recordId` (string, optional, nullable)
- `recordName` (string, optional, nullable)
- `requestId` (string, optional, nullable)
- `resolvedModel` (string, optional, nullable)
- `seq` (double, optional)
- `stepId` (string, optional, nullable)
- `stepName` (string, optional, nullable)
- `stepType` (string, optional, nullable)
- `stopReason` (string, optional, nullable)
- `streamContent` (string, optional)
- `subtitle` (string, optional)
- `surfaceId` (string, optional, nullable)
- `surfaceType` (string, optional, nullable)
- `toolCallId` (string, optional, nullable)
- `toolName` (string, optional, nullable)
- `toolType` (string, optional, nullable)
- `totalTokens` (double, optional, nullable)
- `turnId` (string, optional, nullable)
- `usedFallback` (boolean, optional, nullable)

### TraceNodeSignals

Signal results that target this span. Omitted until the organization binds a signal set.

- `fired` (list of string, required)
- `results` (list of SignalResult, required)

### SignalSource

- `end` (integer, required)
- `field` (string, required)
- `spanId` (string, required)
- `start` (integer, required)

### TraceLogEntryEstimatedContextBreakdown

- `categories` (map from string to TraceLogEntryEstimatedContextBreakdownCategories, required)
- `estimatedTotalTokens` (double, required)
- `contextWindowSize` (double, optional)
- `estimatedUtilizationPercent` (double, optional)

### TraceLogEntryEstimatedCost

Observed cost. Absent or null means unknown, never zero.

- double
- string

### TraceLogEntryEstimatedContextBreakdownCategories

- `chars` (double, required)
- `estimatedTokens` (double, required)

## Examples

**Response**

```json
{
  "data": {
    "conversationId": "string",
    "executions": [
      {
        "executionId": "string",
        "timestamp": "string",
        "tree": {
          "nodeCount": 1.1,
          "root": {
            "children": [
              null
            ],
            "depth": 1.1,
            "entry": {
              "id": "string",
              "level": "debug",
              "status": "running",
              "timestamp": "string",
              "title": "string",
              "type": "flow",
              "agentId": "string",
              "agentName": "string",
              "batchExecutionId": "string",
              "cacheReadTokens": 1.1,
              "cacheWriteTokens": 1.1,
              "completionTokens": 1.1,
              "configuredModel": "string",
              "conversationId": "string",
              "description": "string",
              "durationMs": 1.1,
              "error": "string",
              "errorStack": "string",
              "estimatedContextBreakdown": {
                "categories": {},
                "estimatedTotalTokens": 1.1,
                "contextWindowSize": 1.1,
                "estimatedUtilizationPercent": 1.1
              },
              "estimatedCost": 1.1,
              "eventName": "string",
              "executionSessionId": "string",
              "fallbackModel": "string",
              "flowId": "string",
              "flowName": "string",
              "input": null,
              "inputSummary": "string",
              "isStreaming": true,
              "iteration": 1.1,
              "loggingPolicy": "off",
              "metadata": {},
              "modelUsed": "string",
              "otlpIncompleteActivity": "invoke_agent",
              "otlpInstrumentationWarning": "span_not_ended",
              "otlpOperationName": "string",
              "otlpParentSpanId": "string",
              "otlpRecordHash": "string",
              "otlpRecordKind": "span",
              "otlpRetentionScope": "string",
              "otlpSpanEventIndex": 1.1,
              "otlpSpanId": "string",
              "output": null,
              "outputSummary": "string",
              "promptTokens": 1.1,
              "providerErrorClass": "string",
              "providerHost": "string",
              "providerHttpMethod": "string",
              "providerHttpStatus": 1.1,
              "providerRateLimitHeaders": {},
              "reasoningTokens": 1.1,
              "recordId": "string",
              "recordName": "string",
              "requestId": "string",
              "resolvedModel": "string",
              "seq": 1.1,
              "stepId": "string",
              "stepName": "string",
              "stepType": "string",
              "stopReason": "string",
              "streamContent": "string",
              "subtitle": "string",
              "surfaceId": "string",
              "surfaceType": "string",
              "toolCallId": "string",
              "toolName": "string",
              "toolType": "string",
              "totalTokens": 1.1,
              "turnId": "string",
              "usedFallback": true
            },
            "nodeType": "root",
            "childExecutionId": "string",
            "endOffsetMs": 1.1,
            "endedAt": "string",
            "failed": true,
            "lifecycle": "single",
            "recorded": true,
            "signals": {
              "fired": [
                "string"
              ],
              "results": [
                {
                  "answers": {},
                  "bindingId": "string",
                  "computedAt": "string",
                  "fired": [
                    "string"
                  ],
                  "sample": "uniform",
                  "signalSet": {
                    "id": "string",
                    "name": "string",
                    "version": 1
                  },
                  "status": "complete",
                  "target": {
                    "executionId": "string",
                    "spanId": "string",
                    "turnIndex": 1
                  },
                  "unit": "turn",
                  "values": {},
                  "error": "string"
                }
              ]
            },
            "startEntry": {
              "id": "string",
              "level": "debug",
              "status": "running",
              "timestamp": "string",
              "title": "string",
              "type": "flow",
              "agentId": "string",
              "agentName": "string",
              "batchExecutionId": "string",
              "cacheReadTokens": 1.1,
              "cacheWriteTokens": 1.1,
              "completionTokens": 1.1,
              "configuredModel": "string",
              "conversationId": "string",
              "description": "string",
              "durationMs": 1.1,
              "error": "string",
              "errorStack": "string",
              "estimatedContextBreakdown": {
                "categories": {},
                "estimatedTotalTokens": 1.1,
                "contextWindowSize": 1.1,
                "estimatedUtilizationPercent": 1.1
              },
              "estimatedCost": 1.1,
              "eventName": "string",
              "executionSessionId": "string",
              "fallbackModel": "string",
              "flowId": "string",
              "flowName": "string",
              "input": null,
              "inputSummary": "string",
              "isStreaming": true,
              "iteration": 1.1,
              "loggingPolicy": "off",
              "metadata": {},
              "modelUsed": "string",
              "otlpIncompleteActivity": "invoke_agent",
              "otlpInstrumentationWarning": "span_not_ended",
              "otlpOperationName": "string",
              "otlpParentSpanId": "string",
              "otlpRecordHash": "string",
              "otlpRecordKind": "span",
              "otlpRetentionScope": "string",
              "otlpSpanEventIndex": 1.1,
              "otlpSpanId": "string",
              "output": null,
              "outputSummary": "string",
              "promptTokens": 1.1,
              "providerErrorClass": "string",
              "providerHost": "string",
              "providerHttpMethod": "string",
              "providerHttpStatus": 1.1,
              "providerRateLimitHeaders": {},
              "reasoningTokens": 1.1,
              "recordId": "string",
              "recordName": "string",
              "requestId": "string",
              "resolvedModel": "string",
              "seq": 1.1,
              "stepId": "string",
              "stepName": "string",
              "stepType": "string",
              "stopReason": "string",
              "streamContent": "string",
              "subtitle": "string",
              "surfaceId": "string",
              "surfaceType": "string",
              "toolCallId": "string",
              "toolName": "string",
              "toolType": "string",
              "totalTokens": 1.1,
              "turnId": "string",
              "usedFallback": true
            },
            "startOffsetMs": 1.1,
            "startedAt": "string",
            "synthetic": true
          },
          "totalCost": 1.1,
          "totalDuration": 1.1,
          "totalTokens": 1.1,
          "availability": {
            "available": true,
            "message": "string",
            "reason": "json_ingest_compatibility_path"
          },
          "childTruncation": {
            "limit": 1.1,
            "message": "string",
            "reason": "child_limit"
          },
          "contentUnavailable": true,
          "failedCount": 1.1,
          "producedBy": {
            "source": "native",
            "adapterName": "string",
            "adapterVersion": "string",
            "agentId": "string",
            "agentName": "string",
            "agentVersionId": "string",
            "agentVersionLabel": "string",
            "callable": true,
            "fidelityTier": "string",
            "flowId": "string",
            "flowName": "string",
            "flowVersionId": "string",
            "productId": "string",
            "productName": "string",
            "surfaceType": "string"
          },
          "runFailed": true,
          "signals": {
            "fired": [
              "string"
            ],
            "results": [
              {
                "answers": {},
                "bindingId": "string",
                "computedAt": "string",
                "fired": [
                  "string"
                ],
                "sample": "uniform",
                "signalSet": {
                  "id": "string",
                  "name": "string",
                  "version": 1
                },
                "status": "complete",
                "target": {
                  "executionId": "string",
                  "spanId": "string",
                  "turnIndex": 1
                },
                "unit": "turn",
                "values": {},
                "error": "string"
              }
            ],
            "status": "complete"
          },
          "source": "logs",
          "startedAt": "string",
          "toolTimeMs": 1.1,
          "toolTimeOverlapped": true,
          "totalsSource": "execution",
          "truncation": {
            "limit": 1.1,
            "message": "string",
            "reason": "record_limit"
          }
        }
      }
    ],
    "totalExecutions": 1.1,
    "producedBy": {
      "source": "native",
      "adapterName": "string",
      "adapterVersion": "string",
      "agentId": "string",
      "agentName": "string",
      "agentVersionId": "string",
      "agentVersionLabel": "string",
      "callable": true,
      "fidelityTier": "string",
      "flowId": "string",
      "flowName": "string",
      "flowVersionId": "string",
      "productId": "string",
      "productName": "string",
      "surfaceType": "string"
    },
    "signals": {
      "fired": [
        "string"
      ],
      "results": [
        {
          "answers": {},
          "bindingId": "string",
          "computedAt": "string",
          "fired": [
            "string"
          ],
          "sample": "uniform",
          "signalSet": {
            "id": "string",
            "name": "string",
            "version": 1
          },
          "status": "complete",
          "target": {
            "executionId": "string",
            "spanId": "string",
            "turnIndex": 1
          },
          "unit": "turn",
          "values": {},
          "error": "string"
        }
      ],
      "status": "complete"
    },
    "truncation": {
      "limit": 1.1,
      "message": "string",
      "reason": "record_limit"
    }
  },
  "success": true
}
```

**SDK Code**

```python
import requests

url = "https://api.runtype.com/v1/logs/trace/conversation/conversationId"

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

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

print(response.json())
```

```javascript
const url = 'https://api.runtype.com/v1/logs/trace/conversation/conversationId';
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.runtype.com/v1/logs/trace/conversation/conversationId"

	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.runtype.com/v1/logs/trace/conversation/conversationId")

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.runtype.com/v1/logs/trace/conversation/conversationId")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.runtype.com/v1/logs/trace/conversation/conversationId', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.runtype.com/v1/logs/trace/conversation/conversationId");
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.runtype.com/v1/logs/trace/conversation/conversationId")! 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()
```