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

# Extract structured data from documents

POST https://api.cloudraker.com/v1/extract
Content-Type: application/json

Runs JSON-Schema extraction with per-field citations over one or more files.

Send exactly one of `file` or `files`, and at most one output shape:

* **`schema`** — an inline JSON Schema object, written in the [extraction schema dialect](https://docs.cloudraker.com/capabilities/extract/schema).
* **`action`** — a [saved action](https://docs.cloudraker.com/api/cloud-raker-api/actions/get-action) by id or slug. Inline config fields (`instructions`, `unit`, `judge`, …) are merged over the saved action's, so one saved action can be refined per call.
* **neither** — the shape is inferred from the documents themselves. Add `hints` to steer it in prose. The finished run reports what was inferred as `config.schema`, ready to save as an action for the next run.

**What you get back.** `output.value` holds the extracted object for a single-document run, `output.documents[]` one entry per file. Send `citations: true` to ground the result: `output.citations` then maps each extracted field to where it came from — `fileId` plus page and bounding box, or `timecodeStart`/`timecodeEnd` for audio, or `notFound: true` for a value the documents do not contain.

Add `?output=inline` to include each source file's parsed `markdown` and `json` alongside the extracted value. Signed `markdownUrl` / `jsonUrl` fields remain available; when the combined parsed source exceeds 1 MiB, the response falls back to those URLs only.

```json
{
  "file": { "url": "https://www.irs.gov/pub/irs-pdf/fw9.pdf" },
  "schema": {
    "type": "object",
    "properties": {
      "business_name": { "type": ["string", "null"] },
      "tax_classification": { "type": ["string", "null"] }
    }
  }
}
```

### Waiting for the result

Sync by default: the call holds open until the run finishes, up to `?wait=` seconds (default `60`, max `120`, `0` returns immediately).

| Outcome                    | Response                                     |
| -------------------------- | -------------------------------------------- |
| Finished inside the window | `200` with the full run                      |
| Still running at the cap   | `202` with `{object, id, status, statusUrl}` |

The `202` is a graceful degrade, never an error — poll [the run](https://docs.cloudraker.com/api/cloud-raker-api/runs/get-run) or wait for a [webhook](https://docs.cloudraker.com/api/cloud-raker-api/webhooks/create-webhook-endpoint). Replaying an `idempotency-key` returns the original run alongside an `idempotent-replay: true` response header.

**Learn more:** [Extraction guide](https://docs.cloudraker.com/capabilities/extract) · [Schema dialect](https://docs.cloudraker.com/capabilities/extract/schema)

Reference: https://docs.cloudraker.com/paperwork/api/capabilities/extract

## Authentication

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

## Request

### Query parameters

- `wait` (integer, optional, default: 60) — How many seconds to hold the request open waiting for the run to finish. Finishing inside the window returns `200` with the full run; running past it returns `202` with a `statusUrl` to poll. Send `0` to skip waiting entirely and always get the `202`.
- `output` (enum, optional, default: urls) — How parsed source content is returned. `urls` returns signed download URLs. `inline` also returns markdown and parsed JSON when their combined payload is at most 1 MiB; larger content falls back to the URLs only.
  - Allowed values: `urls`, `inline`

### Body (application/json)

This endpoint expects a V1ExtractBody.

- `schema` (map from string to any, optional) — The shape to extract, as a JSON Schema object. Send `action` instead to use a saved shape, or neither to have one inferred. The root must be `{"type": "object"}`. The dialect is deliberately narrow — no `$ref`, `$defs`, `oneOf`, `anyOf`, `allOf`, `const` or `pattern` — with a maximum nesting depth of 5 and a 64 KB size limit. Make primitives nullable (`{"type": ["string", "null"]}`) so a missing value reads as `null` rather than a hallucination.
- `action` (string, optional) — A saved action to run, by id or slug. An alternative to `schema`. The action carries the output shape and any saved settings. Config you send inline on the same call is merged over it, so `action` plus `instructions` refines a saved action for one run without redefining it.
- `hints` (string, optional) — Prose guidance for **schema inference** — only valid when you send neither `schema` nor `action`. Say what the documents are and what matters in them ("freight bills of lading; I care about the load number, the shipper and the total") and the shape is inferred from the document itself. Sending `hints` alongside `schema` or `action` is a `400`: the shape is already decided.
- `instructions` (string, optional) — Free-form guidance for the extraction, applied on top of the schema — house rules, formatting preferences, how to handle ambiguity.
- `citations` (boolean, optional) — Whether to ground each extracted value in the source document. Off by default — grounding is an explicit add-on, so send `citations: true` to ask for it. When on, `output.citations` maps every extracted field to where it came from — `fileId` plus page and bounding box for documents, or `timecodeStart`/`timecodeEnd` for audio. A field the documents simply do not contain comes back as an entry with `notFound: true` and no location.
- `unit` (enum, optional) — What one extraction result covers. - `per_document`: one result object per file (the default). - `across_documents`: one result object for the whole set. The files are read together as one source, in the order you list them, so a recording split into parts reads as one recording. Audio mixed with documents cannot be read as one source: each file is then extracted on its own and the results are merged. - `rows_per_document`: a list of results per file, for documents that hold repeated records.
  - Allowed values: `per_document`, `across_documents`, `rows_per_document`
- `judge` (boolean, optional) — Run a second review pass that scores each extracted value against the evidence it cites, adding a `confidence` (0–5) and leaving the values themselves alone. **It is the only pass that scores**: grounding cites without grading, so an unjudged run returns citations with no `confidence`. Slower and more thorough; worth it on documents where an error is expensive. **The judge audits citations, so it needs `citations: true`.** It scores cited evidence and never re-extracts, so with grounding off there is nothing for it to audit. Sending `judge: true` with `citations: false` is a `400`. When you name an `action`, the saved config's `citations` setting counts — a judge on a saved action that does not ground does nothing.
- `file` (V1ExtractBodyFile, optional) — A single input file. Send this or `files`, never both.
- `files` (list of V1ExtractBodyFilesItems, optional) — Several input files, up to 100. Send this or `file`, never both. Each file gets its own entry in `output.documents[]` unless `unit` says otherwise.
- `metadata` (map from string to any, optional) — Arbitrary JSON you attach to the run and get back on every read of it. Use it to carry your own identifiers — an order number, a customer id — so a webhook or a polled run reconciles without a lookup table. Capped at 10 KB serialized.
- `webhook` (V1ExtractBodyWebhook, optional) — Where to deliver this run's events, given one of two ways. * `{ "url": "…" }` — a one-off https endpoint for this run only. * `{ "id": "whe_…" }` — a saved endpoint from `POST /v1/webhooks`. Runs hold the reference, so pausing or re-pointing that endpoint applies to this run too. Deliveries are at-least-once and signed — dedupe on `eventId` and verify against `GET /v1/webhooks/jwks.json`.
- `ttl` (integer, optional, default: 86400) — How long, in seconds, to keep this run and its files before purging them automatically. The maximum is 604800 (7 days). The deadline comes back as `expiresAt` on every read of the run. Call `POST /v1/runs/{id}/keep` before then to clear the TTL and move the results into a space permanently. E-signature runs are exempt — an envelope waits for its signers however long that takes.

## Response

### 200

The finished run.

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

### 202

Accepted — still running, or awaiting human input.

- `object` (string, 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`
- `statusUrl` (string, required)
- `envelopeUrl` (string, optional)

## Errors

### 400 Bad Request Error

Invalid request (`invalid_request` / `invalid_schema`).

- `any`

### 422 Unprocessable Entity Error

Unusable input file or webhook endpoint.

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

### V1ExtractBodyFile

A single input file. Send this or `files`, never both.

- V1ExtractBodyFile0
- V1ExtractBodyFile1

### V1ExtractBodyFilesItems

An input file, given one of two ways. * `{ "url": "…", "name"?: "…", "processing"?: "…" }` — fetched over http(s) for this run and purged with it. * `{ "id": "…" }` — a file you already registered with `POST /v1/files`, reusable across runs and never re-parsed. * `{ "id": "…", "ephemeral": true }` — a file you uploaded only for this run, purged with it. Use it only on a file no other run uses.

- V1ExtractBodyFilesItems0
- V1ExtractBodyFilesItems1

### V1ExtractBodyWebhook

Where to deliver this run's events, given one of two ways. * `{ "url": "…" }` — a one-off https endpoint for this run only. * `{ "id": "whe_…" }` — a saved endpoint from `POST /v1/webhooks`. Runs hold the reference, so pausing or re-pointing that endpoint applies to this run too. Deliveries are at-least-once and signed — dedupe on `eventId` and verify against `GET /v1/webhooks/jwks.json`.

- V1ExtractBodyWebhook0
- V1ExtractBodyWebhook1

### 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)

### V1ExtractBodyFile0

- `url` (string, required)
- `name` (string, optional)
- `processing` (enum, optional)
  - Allowed values: `auto`, `ocr`, `simple`, `transcribe`, `transcribe_diarize`

### V1ExtractBodyFile1

- `id` (string, required)
- `ephemeral` (boolean, optional) — Purge this file with the run (TTL expiry or `DELETE /v1/runs/{id}`), unless you `keep` the run. API workspace only: ignored under `/v1/spaces/{spaceId}/…`.

### V1ExtractBodyFilesItems0

- `url` (string, required)
- `name` (string, optional)
- `processing` (enum, optional)
  - Allowed values: `auto`, `ocr`, `simple`, `transcribe`, `transcribe_diarize`

### V1ExtractBodyFilesItems1

- `id` (string, required)
- `ephemeral` (boolean, optional) — Purge this file with the run (TTL expiry or `DELETE /v1/runs/{id}`), unless you `keep` the run. API workspace only: ignored under `/v1/spaces/{spaceId}/…`.

### V1ExtractBodyWebhook0

- `url` (string, required)

### V1ExtractBodyWebhook1

- `id` (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.

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

### Example 1

**Request**

```json
{}
```

**Response**

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

**SDK Code**

```python
import requests

url = "https://api.cloudraker.com/v1/extract"

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

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

print(response.json())
```

```javascript
const url = 'https://api.cloudraker.com/v1/extract';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{}'
};

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"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.cloudraker.com/v1/extract"

	payload := strings.NewReader("{}")

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

}
```

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

url = URI("https://api.cloudraker.com/v1/extract")

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 = "{}"

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.post("https://api.cloudraker.com/v1/extract")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.cloudraker.com/v1/extract', [
  'body' => '{}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.cloudraker.com/v1/extract");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.cloudraker.com/v1/extract")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

### Example 2

**Request**

```json
{}
```

**Response**

```json
{
  "object": "string",
  "id": "string",
  "status": "queued",
  "statusUrl": "string",
  "envelopeUrl": "string"
}
```

**SDK Code**

```python
import requests

url = "https://api.cloudraker.com/v1/extract"

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

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

print(response.json())
```

```javascript
const url = 'https://api.cloudraker.com/v1/extract';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{}'
};

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"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.cloudraker.com/v1/extract"

	payload := strings.NewReader("{}")

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

}
```

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

url = URI("https://api.cloudraker.com/v1/extract")

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 = "{}"

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.post("https://api.cloudraker.com/v1/extract")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.cloudraker.com/v1/extract', [
  'body' => '{}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.cloudraker.com/v1/extract");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.cloudraker.com/v1/extract")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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