> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.termina.ai/api-reference/data/deck/get-deck-data/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.termina.ai/_mcp/server.

# Deck Data

GET https://app.termina.ai/api/v1/group/{group_id}/deal/{deal_id}/data/deck

Get parsed deck data for every deck file attached to the deal.

Returns an empty list when no decks have been parsed/published.

Reference: https://docs.termina.ai/api-reference/data/deck/get-deck-data

## Authentication

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

## Servers

- `https://app.termina.ai` (Production server, default)
- `https://app.termina.dev` (Development server)
- `http://localhost:8000` (Local development server)

## Request

### Path parameters

- `group_id` (integer, required)
- `deal_id` (integer, required)

## Response

### 200

Successful Response

- `list of ParsedDeckResponse`

## Errors

### 422 Unprocessable Entity Error

Validation Error

- `detail` (list of ValidationError, optional)

## Types

### ParsedDeckResponse

- `file_id` (integer, required) — ID of the source deck file on the deal.
- `file_name` (string, required) — Name of the source deck PDF.
- `gcs_uri` (string, required) — GCS URI of the source deck PDF.
- `num_pages` (integer, required) — Number of pages parsed from the deck.
- `logic_name` (string, required) — Parsing logic identifier.
- `logic_version` (string, required) — Parsing logic version.
- `metadata` (DocumentMetadataResponse, optional)
- `pages` (list of DocumentPageResponse, optional) — Per-page data-centric content.
- `summary` (DeckSummaryResponse, optional, nullable) — Best-effort deck summary; may be null.

### ValidationError

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

### DocumentMetadataResponse

- `filename` (string, optional, nullable) — PDF filename.
- `uri` (string, optional, nullable) — GCS URI of the source PDF.
- `file_type` (string, optional, nullable) — Media type, e.g. 'application/pdf'.
- `author` (string, optional, nullable) — Author from the PDF /Info dictionary.
- `created_at` (string, optional, nullable) — PDF creation date in ISO 8601.
- `last_updated_at` (string, optional, nullable) — PDF modification date in ISO 8601.
- `source_system` (string, optional, nullable) — Originating application (e.g. 'Keynote').

### DocumentPageResponse

- `page_number` (integer, required) — 1-indexed page number.
- `title` (string, optional, nullable)
- `description` (string, optional, nullable)
- `raw_text` (string, optional, nullable)
- `general_context` (list of string, optional) — Whole-slide caveats and flags from the slide pass.
- `data_series` (list of DataSeriesResponse, optional)
- `data_points` (list of DataPointResponse, optional)

### DeckSummaryResponse

- `title` (string, optional, default: )
- `summary` (string, optional, default: )

### ValidationErrorLocItems

### ValidationErrorCtx

### DataSeriesResponse

- `metrics` (list of MetricSpecResponse, required)
- `series_type` (enum, required)
  - Allowed values: `temporal`, `non_temporal`
- `description` (string, optional, nullable)
- `points` (list of DataPointResponse, optional)
- `context` (list of string, optional) — Chart/table caveats: projections, estimated reads, garbled geometry, units.

### DataPointResponse

- `values` (list of MetricValueResponse, required)
- `forecast` (boolean, optional, default: false) — True when this point is projected/forecasted.
- `temporal` (TemporalResponse, optional, nullable) — Date axis value, when temporal.

### MetricSpecResponse

- `metric` (string, required) — Original field name as it appeared in the chart/table.
- `normalized_metric` (string, required) — Snake-cased, ASCII-folded field name.
- `dtype` (string, optional, nullable) — Inferred data type, e.g. 'float', 'percentage'.

### MetricValueResponse

- `metric` (string, required) — Original field name as it appeared in the chart/table.
- `normalized_metric` (string, required) — Snake-cased, ASCII-folded field name.
- `value` (MetricValueResponseValue, required) — Cell value.
- `dtype` (string, optional, nullable) — Inferred data type, e.g. 'float', 'percentage'.

### TemporalResponse

- `type` (enum, required) — 'point' = instant, 'period' = span.
  - Allowed values: `point`, `period`
- `raw` (string, required) — Original date string.
- `start_date` (string, optional, nullable) — ISO date string for the start.
- `end_date` (string, optional, nullable) — ISO date string for the end.
- `grain` (string, optional, nullable) — Calendar grain, e.g. 'month', 'quarter', 'year'.

### MetricValueResponseValue

Cell value.

## Examples

**Response**

```json
[
  {
    "file_id": 42,
    "file_name": "acme-deck.pdf",
    "gcs_uri": "string",
    "num_pages": 18,
    "logic_name": "parse_deck",
    "logic_version": "0.1",
    "metadata": {
      "filename": "string",
      "uri": "string",
      "file_type": "string",
      "author": "string",
      "created_at": "string",
      "last_updated_at": "string",
      "source_system": "string"
    },
    "pages": [
      {
        "page_number": 1,
        "title": "string",
        "description": "string",
        "raw_text": "string",
        "general_context": [
          "string"
        ],
        "data_series": [
          {
            "metrics": [
              {
                "metric": "string",
                "normalized_metric": "string",
                "dtype": "string"
              }
            ],
            "series_type": "temporal",
            "description": "string",
            "points": [
              {
                "values": [
                  {
                    "metric": "string",
                    "normalized_metric": "string",
                    "value": 1,
                    "dtype": "string"
                  }
                ],
                "forecast": false,
                "temporal": {
                  "type": "point",
                  "raw": "string",
                  "start_date": "string",
                  "end_date": "string",
                  "grain": "string"
                }
              }
            ],
            "context": [
              "string"
            ]
          }
        ],
        "data_points": [
          {
            "values": [
              {
                "metric": "string",
                "normalized_metric": "string",
                "value": 1,
                "dtype": "string"
              }
            ],
            "forecast": false,
            "temporal": {
              "type": "point",
              "raw": "string",
              "start_date": "string",
              "end_date": "string",
              "grain": "string"
            }
          }
        ]
      }
    ],
    "summary": {
      "title": "",
      "summary": ""
    }
  }
]
```

**SDK Code**

```python
import requests

url = "https://app.termina.ai/api/v1/group/1/deal/1/data/deck"

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

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

print(response.json())
```

```javascript
const url = 'https://app.termina.ai/api/v1/group/1/deal/1/data/deck';
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://app.termina.ai/api/v1/group/1/deal/1/data/deck"

	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://app.termina.ai/api/v1/group/1/deal/1/data/deck")

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://app.termina.ai/api/v1/group/1/deal/1/data/deck")
  .header("Authorization", "Bearer <token>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://app.termina.ai/api/v1/group/1/deal/1/data/deck', [
  'headers' => [
    'Authorization' => 'Bearer <token>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://app.termina.ai/api/v1/group/1/deal/1/data/deck");
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://app.termina.ai/api/v1/group/1/deal/1/data/deck")! 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()
```