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

# Get asset by ID

GET https://api.athenaintel.com/api/v0/assets/{asset_id}

Retrieve a single asset by its ID. Returns comprehensive metadata including creation info, tags, timestamps, media type, and AI-generated summary.

Reference: https://docs.athenaintel.com/api-reference/assets/get

## Authentication

- `X-API-KEY` header (required) — API Key authentication via header

## Request

### Path parameters

- `asset_id` (string, required) — Unique identifier of the asset to retrieve

## Response

### 200

Successfully retrieved asset

- `athena_converted_type` (string, required) — File type after Athena processing/conversion (e.g., 'txt', 'pdf', 'md')
- `athena_original_type` (string, required) — Original asset type from AssetType enum (e.g., 'document', 'presentation', 'spreadsheet')
- `created_at` (datetime, required) — Timestamp when the asset was created (ISO 8601 format)
- `created_by_id` (string, required) — Unique identifier of the user who created this asset
- `id` (string, required) — Unique identifier of the asset (e.g., 'asset_abc123-def456-ghi789')
- `is_archived` (boolean, required) — Whether the asset has been archived (hidden from normal views)
- `is_hidden` (boolean, required) — Whether the asset is hidden from the user interface
- `media_type` (string, required) — MIME type or Athena-specific media type (e.g., 'text/plain', 'application/pdf', 'athena/document')
- `summary_ready` (boolean, required) — Whether the AI summary has been generated and is available
- `title` (string, required) — Display name/title of the asset
- `updated_at` (datetime, required) — Timestamp when the asset was last modified (ISO 8601 format)
- `athena_metadata` (map from string to any, optional, nullable) — Internal metadata used by Athena system (e.g., \{'source': 'kb', 'topic': 'insights'}). Never carries a stored credential: connection-string passwords are masked as '\*\*\*\*' and secret keys are removed; last\_read\_at holds only the caller's own read receipt.
- `created_by_email` (string, optional, nullable) — Email address of the user who created this asset
- `import_report` (PublicImportReportOut, optional, nullable) — For a Word document, spreadsheet or presentation imported from an Office file: what the file holds that is not shown, or is shown differently than in Office, and whether downloads keep it. Null when the import lost nothing, when the asset was not imported from a file, or when it was imported before these reports were kept.
- `parent_folder_id` (string, optional, nullable) — ID of the folder that directly contains this asset, or null when the asset is at the workspace root
- `summary` (string, optional, nullable) — AI-generated summary of the asset content
- `summary_status` (string, optional, nullable) — Status of summary generation process ('READY', 'PENDING', 'FAILED', etc.)
- `tags` (map from string to any, optional, nullable) — Custom tags associated with the asset as key-value pairs (e.g., \{'project': 'alpha', 'team': 'ml'})
- `workspace_id` (string, optional, nullable) — Unique identifier of the workspace this asset belongs to

## Errors

### 401 Unauthorized Error

Unauthorized - invalid or missing authentication or access denied

- `message` (string, required)

### 404 Not Found Error

Asset not found

- `message` (string, required)

### 422 Unprocessable Entity Error

Validation Error

- `detail` (list of ValidationError, optional)

## Types

### PublicImportReportOut

What the import of a Word document, spreadsheet or presentation could not carry.

- `items` (list of PublicImportLossOut, required) — The kinds of loss, most significant first

### ValidationError

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

### PublicImportLossOut

One kind of content an Office file's import could not carry.

- `codes` (map from string to integer, required) — The importer's stable codes behind it, with their counts (e.g. \{'alternate\_content\_a14\_dropped': 2})
- `download_note` (string, required) — That, as a sentence (e.g. 'Downloads keep them.'); empty when unknown
- `kind` (string, required) — The kind of loss, a stable id (e.g. 'equations_blank')
- `summary` (string, required) — What is affected (e.g. '2 equations are shown as blank')
- `count` (integer, optional, nullable) — How many there are, or null for a kind whose occurrences are not counted as one number
- `download` (string, optional, nullable) — What a download of the file does with it: 'kept', 'kept_unless_edited', 'edits_not_saved' or 'usually_kept'; null when unknown

### ValidationErrorLocItems

- string
- integer

### ValidationErrorCtx

## Examples

**Response**

```json
{
  "athena_converted_type": "pdf",
  "athena_original_type": "document",
  "created_at": "2024-01-15T10:30:00Z",
  "created_by_id": "user_123",
  "id": "asset_92492920-d118-42d3-95b4-00eccfe0754f",
  "is_archived": false,
  "is_hidden": false,
  "media_type": "application/pdf",
  "summary_ready": true,
  "title": "Quarterly Report Q1 2024",
  "updated_at": "2024-01-16T14:20:00Z",
  "athena_metadata": {
    "source": "upload",
    "topic": "finance"
  },
  "created_by_email": "user@example.com",
  "parent_folder_id": "asset_folder_1a2b3c",
  "summary": "Comprehensive quarterly financial report covering revenue, expenses, and growth metrics.",
  "summary_status": "READY",
  "tags": {
    "project": "alpha",
    "team": "ml"
  },
  "workspace_id": "ws_abc123-def456"
}
```

**SDK Code**

```python assets_get_example
import requests

url = "https://api.athenaintel.com/api/v0/assets/asset_id"

headers = {"X-API-KEY": "<apiKey>"}

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

print(response.json())
```

```javascript assets_get_example
const url = 'https://api.athenaintel.com/api/v0/assets/asset_id';
const options = {method: 'GET', headers: {'X-API-KEY': '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go assets_get_example
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.athenaintel.com/api/v0/assets/asset_id"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("X-API-KEY", "<apiKey>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

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

url = URI("https://api.athenaintel.com/api/v0/assets/asset_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["X-API-KEY"] = '<apiKey>'

response = http.request(request)
puts response.read_body
```

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

HttpResponse<String> response = Unirest.get("https://api.athenaintel.com/api/v0/assets/asset_id")
  .header("X-API-KEY", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.athenaintel.com/api/v0/assets/asset_id', [
  'headers' => [
    'X-API-KEY' => '<apiKey>',
  ],
]);

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

```csharp assets_get_example
using RestSharp;

var client = new RestClient("https://api.athenaintel.com/api/v0/assets/asset_id");
var request = new RestRequest(Method.GET);
request.AddHeader("X-API-KEY", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift assets_get_example
import Foundation

let headers = ["X-API-KEY": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.athenaintel.com/api/v0/assets/asset_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()
```