> This page is for Paperwork API, version v1 (default).
> For other versions, use one of these documentation indexes:
> - v1 (default): https://docs.cloudraker.com/paperwork/v1/llms.txt

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

# Get a run in a space

GET https://api.cloudraker.com/v1/spaces/{spaceId}/runs/{id}

Returns a run created in this space. Identical to `GET /v1/runs/{id}`, except that a run belonging to another space — or to no space — answers `404`.

**Learn more:** [Spaces](https://docs.cloudraker.com/developers/spaces)

Reference: https://docs.cloudraker.com/paperwork/api/spaces/space-get-run

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Path parameters

- `spaceId` (string, required)
- `id` (string, required)

### Query parameters

- `output` (enum, optional, default: urls) — Return parsed source inline for parse/extract runs when the combined source is at most 1 MiB; otherwise retain signed URLs only.
  - Allowed values: `urls`, `inline`
- `include` (string, optional)
- `wait` (integer, optional, default: 0)

## Response

### 200

The run.

- `Spaces_spaceGetRun_Response_200`
  - V1ExtractRun: V1ExtractRun
  - V1ParseRun: V1ParseRun
  - V1RedactRun: V1RedactRun
  - V1FillRun: V1FillRun
  - V1SignRun: V1SignRun
  - V1PipelineRun: V1PipelineRun

## Errors

### 400 Bad Request Error

Validation Error

- `success` (boolean, required)
- `error` (list of any, required)
- `data` (any, required)

### 404 Not Found Error

Unknown run, or a run outside this space.

- `any`

### 429 Too Many Requests Error

Rate limited. The `/v1` API allows at least **67 requests per minute per organization** (about 1,000 requests per 15 minutes) — a guaranteed floor, enforced per edge location, so a geographically spread caller may get more. Wait for the `Retry-After` interval and retry — the error is `retryable`.

- `code` (enum, required)
  - Allowed values: `rate_limited`
- `message` (string, required)
- `retryable` (boolean, required)
- `requestId` (string, required)
- `docUrl` (string, optional)

## Types

### V1ExtractRun

- `object` ("extract_run", required)
- `id` (string, required)
- `status` (enum, required) — Where the run is in its life. | Status | Meaning | | --- | --- | | `queued` | Accepted, not started | | `processing` | Work in flight | | `needs_input` | Waiting for an external action, such as an e-signature | | `processed` | Finished; `output` is populated | | `failed` | Finished unsuccessfully | | `cancelled` | Stopped on request | | `expired` | TTL elapsed and the data was purged | The last four are terminal.
  - Allowed values: `queued`, `processing`, `processed`, `failed`, `cancelled`, `expired`, `needs_input`
- `expiresAt` (string, required, nullable)
- `statusUrl` (string, required)
- `files` (list of V1ExtractRunFilesItems, required)
- `file` (V1ExtractRunFile, optional)
- `error` (V1ExtractRunError, optional) — Why the run failed. Present whenever `status` is `failed`, and only then. `code` is the stable, snake_case reason (`input_unavailable`, `parse_failed`, …); `message` is the human-readable detail. Per-file and per-step failures are also reported in `files[].error` and, for a pipeline, `steps[].error`.
- `metadata` (map from string to any, optional)
- `config` (V1ExtractRunConfig, optional) — The output shape this run actually applied. On an inference run — one sent with neither `schema` nor `action` — this is where you read the schema that was inferred, ready to review and save as an action for the next run.
- `output` (V1ExtractRunOutput, optional) — The extracted data. Present once `status` is `processed`. `documents[]` always has one entry per input file. For a single-document run, `value`, `citations` and any parsed source fields are lifted to the top as aliases of `documents[0]` so the common case reads without indexing. Parsed source fields are present only when requested with `?output=inline`. The signed URLs remain as a fallback; `markdown` and `json` are omitted when the combined inline source exceeds 1 MiB.

### V1ParseRun

- `object` ("parse_run", required)
- `id` (string, required)
- `status` (enum, required) — Where the run is in its life. | Status | Meaning | | --- | --- | | `queued` | Accepted, not started | | `processing` | Work in flight | | `needs_input` | Waiting for an external action, such as an e-signature | | `processed` | Finished; `output` is populated | | `failed` | Finished unsuccessfully | | `cancelled` | Stopped on request | | `expired` | TTL elapsed and the data was purged | The last four are terminal.
  - Allowed values: `queued`, `processing`, `processed`, `failed`, `cancelled`, `expired`, `needs_input`
- `expiresAt` (string, required, nullable)
- `statusUrl` (string, required)
- `files` (list of V1ParseRunFilesItems, required)
- `file` (V1ParseRunFile, optional)
- `error` (V1ParseRunError, optional) — Why the run failed. Present whenever `status` is `failed`, and only then. `code` is the stable, snake_case reason (`input_unavailable`, `parse_failed`, …); `message` is the human-readable detail. Per-file and per-step failures are also reported in `files[].error` and, for a pipeline, `steps[].error`.
- `metadata` (map from string to any, optional)
- `output` (V1ParseRunOutput, optional) — The parsed document. Present once `status` is `processed`. Both links are signed and valid for about an hour: `markdownUrl` for the readable form, `jsonUrl` for the structured one. With `?output=inline`, `markdown` and parsed `json` are included too when their combined payload is at most 1 MiB; larger content falls back to the URLs only.

### V1RedactRun

- `object` ("redact_run", required)
- `id` (string, required)
- `status` (enum, required) — Where the run is in its life. | Status | Meaning | | --- | --- | | `queued` | Accepted, not started | | `processing` | Work in flight | | `needs_input` | Waiting for an external action, such as an e-signature | | `processed` | Finished; `output` is populated | | `failed` | Finished unsuccessfully | | `cancelled` | Stopped on request | | `expired` | TTL elapsed and the data was purged | The last four are terminal.
  - Allowed values: `queued`, `processing`, `processed`, `failed`, `cancelled`, `expired`, `needs_input`
- `expiresAt` (string, required, nullable)
- `statusUrl` (string, required)
- `files` (list of V1RedactRunFilesItems, required)
- `file` (V1RedactRunFile, optional)
- `error` (V1RedactRunError, optional) — Why the run failed. Present whenever `status` is `failed`, and only then. `code` is the stable, snake_case reason (`input_unavailable`, `parse_failed`, …); `message` is the human-readable detail. Per-file and per-step failures are also reported in `files[].error` and, for a pipeline, `steps[].error`.
- `metadata` (map from string to any, optional)
- `output` (V1RedactRunOutput, optional) — The redacted files. Present once `status` is `processed`. `files[]` holds the new documents — `file` is an alias of the first for single-file runs — each with a signed download link. A `/v1/redact` call takes one input, so it returns at most one file; a `redact` pipeline step over many files returns one per input that had a match. `entities` tallies what was removed per category. Its keys are open, not a closed set: a finding the `categories` list does not cover reports under its own label. `skipped` counts documents that contained nothing to redact and so produced no new file.

### V1FillRun

- `object` ("fill_run", required)
- `id` (string, required)
- `status` (enum, required) — Where the run is in its life. | Status | Meaning | | --- | --- | | `queued` | Accepted, not started | | `processing` | Work in flight | | `needs_input` | Waiting for an external action, such as an e-signature | | `processed` | Finished; `output` is populated | | `failed` | Finished unsuccessfully | | `cancelled` | Stopped on request | | `expired` | TTL elapsed and the data was purged | The last four are terminal.
  - Allowed values: `queued`, `processing`, `processed`, `failed`, `cancelled`, `expired`, `needs_input`
- `expiresAt` (string, required, nullable)
- `statusUrl` (string, required)
- `files` (list of V1FillRunFilesItems, required)
- `file` (V1FillRunFile, optional)
- `error` (V1FillRunError, optional) — Why the run failed. Present whenever `status` is `failed`, and only then. `code` is the stable, snake_case reason (`input_unavailable`, `parse_failed`, …); `message` is the human-readable detail. Per-file and per-step failures are also reported in `files[].error` and, for a pipeline, `steps[].error`.
- `metadata` (map from string to any, optional)
- `output` (V1FillRunOutput, optional) — The completed form. Present once `status` is `processed`. `file` is the filled PDF with a signed download link; `fields` reports the values that were written into it, keyed by field name.

### V1SignRun

- `object` ("sign_run", required)
- `id` (string, required)
- `status` (enum, required) — Where the run is in its life. | Status | Meaning | | --- | --- | | `queued` | Accepted, not started | | `processing` | Work in flight | | `needs_input` | Waiting for an external action, such as an e-signature | | `processed` | Finished; `output` is populated | | `failed` | Finished unsuccessfully | | `cancelled` | Stopped on request | | `expired` | TTL elapsed and the data was purged | The last four are terminal.
  - Allowed values: `queued`, `processing`, `processed`, `failed`, `cancelled`, `expired`, `needs_input`
- `expiresAt` (string, required, nullable)
- `statusUrl` (string, required)
- `files` (list of V1SignRunFilesItems, required)
- `envelopeUrl` (string, required)
- `file` (V1SignRunFile, optional)
- `error` (V1SignRunError, optional) — Why the run failed. Present whenever `status` is `failed`, and only then. `code` is the stable, snake_case reason (`input_unavailable`, `parse_failed`, …); `message` is the human-readable detail. Per-file and per-step failures are also reported in `files[].error` and, for a pipeline, `steps[].error`.
- `metadata` (map from string to any, optional)
- `output` (V1SignRunOutput, optional) — The signed document. Present once every required signing slot has completed. `file` is the sealed PDF, `signers[]` records who signed and when, and `auditUrl` points at the machine-readable audit trail.

### V1PipelineRun

- `object` ("pipeline_run", required)
- `id` (string, required)
- `status` (enum, required) — Where the run is in its life. | Status | Meaning | | --- | --- | | `queued` | Accepted, not started | | `processing` | Work in flight | | `needs_input` | Waiting for an external action, such as an e-signature | | `processed` | Finished; `output` is populated | | `failed` | Finished unsuccessfully | | `cancelled` | Stopped on request | | `expired` | TTL elapsed and the data was purged | The last four are terminal.
  - Allowed values: `queued`, `processing`, `processed`, `failed`, `cancelled`, `expired`, `needs_input`
- `expiresAt` (string, required, nullable)
- `statusUrl` (string, required)
- `files` (list of V1PipelineRunFilesItems, required)
- `steps` (list of V1PipelineStepView, required)
- `file` (V1PipelineRunFile, optional)
- `error` (V1PipelineRunError, optional) — Why the run failed. Present whenever `status` is `failed`, and only then. `code` is the stable, snake_case reason (`input_unavailable`, `parse_failed`, …); `message` is the human-readable detail. Per-file and per-step failures are also reported in `files[].error` and, for a pipeline, `steps[].error`.
- `metadata` (map from string to any, optional)

### V1ExtractRunFilesItems

- `id` (string, required)
- `name` (string, required)
- `status` (string, required)
- `error` (string, optional)

### V1ExtractRunFile

- `id` (string, required)
- `name` (string, required)
- `status` (string, required)
- `error` (string, optional)

### V1ExtractRunError

Why the run failed. Present whenever `status` is `failed`, and only then. `code` is the stable, snake_case reason (`input_unavailable`, `parse_failed`, …); `message` is the human-readable detail. Per-file and per-step failures are also reported in `files[].error` and, for a pipeline, `steps[].error`.

- `code` (string, required)
- `message` (string, required)

### V1ExtractRunConfig

The output shape this run actually applied. On an inference run — one sent with neither `schema` nor `action` — this is where you read the schema that was inferred, ready to review and save as an action for the next run.

- `schema` (map from string to any, required)

### V1ExtractRunOutput

The extracted data. Present once `status` is `processed`. `documents[]` always has one entry per input file. For a single-document run, `value`, `citations` and any parsed source fields are lifted to the top as aliases of `documents[0]` so the common case reads without indexing. Parsed source fields are present only when requested with `?output=inline`. The signed URLs remain as a fallback; `markdown` and `json` are omitted when the combined inline source exceeds 1 MiB.

- `documents` (list of V1ExtractRunOutputDocumentsItems, required)
- `value` (any, optional)
- `citations` (map from string to list of V1Citation, optional) — Where each extracted value came from, keyed by the field it backs. Keys are the top-level field keys of `value` (`load_number`); for a `rows_per_document` run they are prefixed with the row index, `[0].description`. Each entry names the `fileId` and, when known, the `page` and `bbox` (or `timecodeStart` and `timecodeEnd` for audio), plus the matched `text`. Add `judge: true` to also get a `confidence` score on each entry. An entry with `notFound: true` instead records that the value is not present in the documents at all, and the field is `null`; one with `uncited: true` records that the field IS filled but nothing in the source backs the value. Present whenever the run was grounded. Send `citations: true` on the request to ask for it.
- `citationsOmitted` (boolean, optional) — The citations were dropped because the result exceeded the size budget.
- `markdownUrl` (string, optional)
- `jsonUrl` (string, optional)
- `markdown` (string, optional)
- `json` (any, optional)

### V1ParseRunFilesItems

- `id` (string, required)
- `name` (string, required)
- `status` (string, required)
- `error` (string, optional)

### V1ParseRunFile

- `id` (string, required)
- `name` (string, required)
- `status` (string, required)
- `error` (string, optional)

### V1ParseRunError

Why the run failed. Present whenever `status` is `failed`, and only then. `code` is the stable, snake_case reason (`input_unavailable`, `parse_failed`, …); `message` is the human-readable detail. Per-file and per-step failures are also reported in `files[].error` and, for a pipeline, `steps[].error`.

- `code` (string, required)
- `message` (string, required)

### V1ParseRunOutput

The parsed document. Present once `status` is `processed`. Both links are signed and valid for about an hour: `markdownUrl` for the readable form, `jsonUrl` for the structured one. With `?output=inline`, `markdown` and parsed `json` are included too when their combined payload is at most 1 MiB; larger content falls back to the URLs only.

- `markdownUrl` (string, optional)
- `jsonUrl` (string, optional)
- `markdown` (string, optional)
- `json` (any, optional)

### V1RedactRunFilesItems

- `id` (string, required)
- `name` (string, required)
- `status` (string, required)
- `error` (string, optional)

### V1RedactRunFile

- `id` (string, required)
- `name` (string, required)
- `status` (string, required)
- `error` (string, optional)

### V1RedactRunError

Why the run failed. Present whenever `status` is `failed`, and only then. `code` is the stable, snake_case reason (`input_unavailable`, `parse_failed`, …); `message` is the human-readable detail. Per-file and per-step failures are also reported in `files[].error` and, for a pipeline, `steps[].error`.

- `code` (string, required)
- `message` (string, required)

### V1RedactRunOutput

The redacted files. Present once `status` is `processed`. `files[]` holds the new documents — `file` is an alias of the first for single-file runs — each with a signed download link. A `/v1/redact` call takes one input, so it returns at most one file; a `redact` pipeline step over many files returns one per input that had a match. `entities` tallies what was removed per category. Its keys are open, not a closed set: a finding the `categories` list does not cover reports under its own label. `skipped` counts documents that contained nothing to redact and so produced no new file.

- `files` (list of V1RedactRunOutputFilesItems, required)
- `file` (V1RedactRunOutputFile, optional)
- `entities` (map from string to double, optional)
- `skipped` (double, optional)

### V1FillRunFilesItems

- `id` (string, required)
- `name` (string, required)
- `status` (string, required)
- `error` (string, optional)

### V1FillRunFile

- `id` (string, required)
- `name` (string, required)
- `status` (string, required)
- `error` (string, optional)

### V1FillRunError

Why the run failed. Present whenever `status` is `failed`, and only then. `code` is the stable, snake_case reason (`input_unavailable`, `parse_failed`, …); `message` is the human-readable detail. Per-file and per-step failures are also reported in `files[].error` and, for a pipeline, `steps[].error`.

- `code` (string, required)
- `message` (string, required)

### V1FillRunOutput

The completed form. Present once `status` is `processed`. `file` is the filled PDF with a signed download link; `fields` reports the values that were written into it, keyed by field name.

- `files` (list of V1FillRunOutputFilesItems, required)
- `file` (V1FillRunOutputFile, optional)
- `fields` (map from string to any, optional)

### V1SignRunFilesItems

- `id` (string, required)
- `name` (string, required)
- `status` (string, required)
- `error` (string, optional)

### V1SignRunFile

- `id` (string, required)
- `name` (string, required)
- `status` (string, required)
- `error` (string, optional)

### V1SignRunError

Why the run failed. Present whenever `status` is `failed`, and only then. `code` is the stable, snake_case reason (`input_unavailable`, `parse_failed`, …); `message` is the human-readable detail. Per-file and per-step failures are also reported in `files[].error` and, for a pipeline, `steps[].error`.

- `code` (string, required)
- `message` (string, required)

### V1SignRunOutput

The signed document. Present once every required signing slot has completed. `file` is the sealed PDF, `signers[]` records who signed and when, and `auditUrl` points at the machine-readable audit trail.

- `files` (list of V1SignRunOutputFilesItems, required)
- `file` (V1SignRunOutputFile, optional)
- `envelopeId` (string, optional)
- `signers` (list of V1SignRunOutputSignersItems, optional)
- `cc` (list of V1SignRunOutputCcItems, optional)
- `auditUrl` (string, optional)

### V1PipelineRunFilesItems

- `id` (string, required)
- `name` (string, required)
- `status` (string, required)
- `error` (string, optional)

### V1PipelineStepView

- `id` (string, required, nullable)
- `capability` (enum, required)
  - Allowed values: `extract`, `parse`, `redact`, `fill`, `sign`, `classify`, `split`, `action`
- `status` (enum, required) — Where the run is in its life. | Status | Meaning | | --- | --- | | `queued` | Accepted, not started | | `processing` | Work in flight | | `needs_input` | Waiting for an external action, such as an e-signature | | `processed` | Finished; `output` is populated | | `failed` | Finished unsuccessfully | | `cancelled` | Stopped on request | | `expired` | TTL elapsed and the data was purged | The last four are terminal.
  - Allowed values: `queued`, `processing`, `processed`, `failed`, `cancelled`, `expired`, `needs_input`
- `error` (string, optional)
- `output` (any, optional)

### V1PipelineRunFile

- `id` (string, required)
- `name` (string, required)
- `status` (string, required)
- `error` (string, optional)

### V1PipelineRunError

Why the run failed. Present whenever `status` is `failed`, and only then. `code` is the stable, snake_case reason (`input_unavailable`, `parse_failed`, …); `message` is the human-readable detail. Per-file and per-step failures are also reported in `files[].error` and, for a pipeline, `steps[].error`.

- `code` (string, required)
- `message` (string, required)

### V1ExtractRunOutputDocumentsItems

- `fileId` (string, required)
- `name` (string, required)
- `status` (string, required)
- `error` (string, optional)
- `value` (any, optional)
- `citations` (map from string to list of V1Citation, optional) — Where each extracted value came from, keyed by the field it backs. Keys are the top-level field keys of `value` (`load_number`); for a `rows_per_document` run they are prefixed with the row index, `[0].description`. Each entry names the `fileId` and, when known, the `page` and `bbox` (or `timecodeStart` and `timecodeEnd` for audio), plus the matched `text`. Add `judge: true` to also get a `confidence` score on each entry. An entry with `notFound: true` instead records that the value is not present in the documents at all, and the field is `null`; one with `uncited: true` records that the field IS filled but nothing in the source backs the value. Present whenever the run was grounded. Send `citations: true` on the request to ask for it.
- `markdownUrl` (string, optional)
- `jsonUrl` (string, optional)
- `markdown` (string, optional)
- `json` (any, optional)

### V1Citation

- `fileId` (string, required)
- `page` (double, optional)
- `bbox` (V1CitationBbox, optional)
- `timecodeStart` (double, optional) — Where the value was said, for audio sources: seconds from the start of the recording. Seek here to hear it. It marks the transcript segment the quoted `text` falls in, so expect segment granularity — read the transcript's `words[]` around it when you need a tighter offset. The counterpart of `page` for documents; absent for document sources.
- `timecodeEnd` (double, optional) — Where the quote stops, in seconds — the end of the transcript segment it falls in. With `timecodeStart` it gives the span to highlight, as `bbox` does for a document page. Absent when the transcript reports no end for that segment (the last one often has none), so treat a missing end as "unknown", not as a zero-length quote.
- `text` (string, optional)
- `confidence` (double, optional) — How strongly the cited text supports the value, 0–5. Only the evidence judge writes it (`judge: true`), and it is absent wherever the judge did not score: an unjudged run, a judged run whose judge failed, or cited entries over the judge cap of 100 per pass. Missing means not graded, never badly graded.
- `uncited` (boolean, optional) — Nothing in the source supports this value, and it was returned anyway. The field IS filled (that is what separates this from `notFound`), but no passage backs it, so the entry carries no `text` and no location. Treat the value as unverified: it is kept so you can see what was extracted and judge it, not because the document bears it out.
- `notFound` (boolean, optional) — The value is not present in the source, and the field is `null`. The entry names the `fileId` it was checked against but carries no `page`, `bbox`, `timecodeStart`/`timecodeEnd` or `text`.
- `timecode` (V1CitationTimecode, optional, deprecated) — Deprecated — read `timecodeStart` instead, which always carries the same value. This is the original name for the start of the cited span, kept so integrations written before the span was published keep working. It is removed in a later release.

### V1RedactRunOutputFilesItems

- `id` (string, required)
- `name` (string, required)
- `url` (string, optional)

### V1RedactRunOutputFile

- `id` (string, required)
- `name` (string, required)
- `url` (string, optional)

### V1FillRunOutputFilesItems

- `id` (string, required)
- `name` (string, required)
- `url` (string, optional)

### V1FillRunOutputFile

- `id` (string, required)
- `name` (string, required)
- `url` (string, optional)

### V1SignRunOutputFilesItems

- `id` (string, required)
- `name` (string, required)
- `url` (string, optional)

### V1SignRunOutputFile

- `id` (string, required)
- `name` (string, required)
- `url` (string, optional)

### V1SignRunOutputSignersItems

- `name` (string, required)
- `email` (string, required)
- `signedAt` (string, optional)

### V1SignRunOutputCcItems

- `name` (string, required)
- `email` (string, required)

### V1CitationBbox

- `x` (double, required)
- `y` (double, required)
- `width` (double, required)
- `height` (double, required)

### V1CitationTimecode

Deprecated — read `timecodeStart` instead, which always carries the same value. This is the original name for the start of the cited span, kept so integrations written before the span was published keep working. It is removed in a later release.

- double
- string

## Examples

**Response**

```json
{
  "config": {
    "schema": {}
  },
  "error": {
    "code": "string",
    "message": "string"
  },
  "expiresAt": "string",
  "file": {
    "error": "string",
    "id": "string",
    "name": "string",
    "status": "string"
  },
  "files": [
    {
      "error": "string",
      "id": "string",
      "name": "string",
      "status": "string"
    }
  ],
  "id": "string",
  "metadata": {},
  "object": "string",
  "output": {
    "citations": {},
    "citationsOmitted": true,
    "documents": [
      {
        "citations": {},
        "error": "string",
        "fileId": "string",
        "jsonUrl": "string",
        "markdown": "string",
        "markdownUrl": "string",
        "name": "string",
        "status": "string"
      }
    ],
    "jsonUrl": "string",
    "markdown": "string",
    "markdownUrl": "string"
  },
  "status": "queued",
  "statusUrl": "string"
}
```

**SDK Code**

```python
import requests

url = "https://api.cloudraker.com/v1/spaces/spaceId/runs/id"

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

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

print(response.json())
```

```javascript
const url = 'https://api.cloudraker.com/v1/spaces/spaceId/runs/id';
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/v1/spaces/spaceId/runs/id"

	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/v1/spaces/spaceId/runs/id")

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/v1/spaces/spaceId/runs/id")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.cloudraker.com/v1/spaces/spaceId/runs/id', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.cloudraker.com/v1/spaces/spaceId/runs/id");
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/v1/spaces/spaceId/runs/id")! 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()
```