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

# Create a new asset

POST https://api.athenaintel.com/api/v0/assets/create
Content-Type: application/json

Create a new asset such as a spreadsheet, document, folder, database, computer, user interface, skill, collab agent, figure, Word document, presentation, or generic doc (admin-only) in your workspace with your current permissions. Computer assets return 202 after durable submission, which commits the asset and initialization delivery intent together. Runtime provisioning continues asynchronously. Inspect the returned asset ID for progress instead of repeating creation. Computers accept the same configuration as the Athena UI's creation dialog: template, provider, cpu, memory (GiB), disk (GiB) and env\_vars. Sizes must be offered by the environment's computer resource policy, and only admins may pick a size other than the template default (403 otherwise). In capability enforce mode, computer creation requires computer.create and returns 403 when denied. Databases accept suspend\_timeout\_seconds, the auto-suspend window from the database's Settings in Athena: 0 keeps the database running (it never suspends, and keeps using capacity), otherwise 60 to 86400 seconds. A database is provisioned in the background: poll GET /api/v0/databases/\{asset\_id}/compute-status until it reports running or suspended. Figures take figure\_config, a FigureSpec (kind, rendered and provenance, plus spec or chart), validated as the Athena UI's figures are. A word\_document is a Word document holding Athena's default template, and a presentation is a blank widescreen PPTX Studio deck (the workspace's default template is not applied): Athena creates each with its own studio credential, as your write, and answers once the studio has seeded it (502, keeping nothing, when PPTX Studio could not seed a deck). Edit them through DOCX Studio or PPTX Studio with a token from POST /api/v0/assets/\{asset\_id}/studio-token. From an agent run (a verified X-Athena-Session-Credential), their first write also records the run, and a presentation takes the create\_presentation\_pptx\_studio tool policy. Without workspace\_id the asset is created in the workspace of parent\_folder\_id when one is given, otherwise in your current workspace; you must be a member of that workspace.

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

## Authentication

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

## Request

### Body (application/json)

This endpoint expects a CreateAssetRequestIn.

- `asset_type` (enum, required) — Type of asset to create. Supported types: 'spreadsheet' (or 'sheet'), 'document' (or 'doc'), 'folder', 'database' (or 'db'), 'computer', 'generic_doc', 'user_interface' (or 'ui'), 'skill', 'collab_agent' (or 'agent'), 'figure', 'word_document' (or 'word'), 'presentation' (or 'deck'). 'document' is Athena's rich-text document; a Word document is 'word_document'.
  - Allowed values: `spreadsheet`, `document`, `folder`, `database`, `computer`, `generic_doc`, `user_interface`, `skill`, `collab_agent`, `figure`, `word_document`, `presentation`
- `agent_config` (PublicCollabAgentConfigIn, optional, nullable) — collab\_agent only. Initial agent configuration. Created as a draft; publish it with POST /api/v0/assets/\{asset\_id}/publish.
- `cpu` (integer, optional, nullable) — Computer only. vCPU count. Defaults to the template's default. Must be a size the environment's computer resource policy offers; sizes other than the template default require an admin.
- `disk` (integer, optional, nullable) — Computer only. Disk size in GiB. Defaults to the template's default. Same policy and admin rules as cpu.
- `env_vars` (map from string to string, optional, nullable) — Computer only. Environment variables to set on the computer. Must include every key the template or environment requires. Also accepted as 'envVars'.
- `figure_config` (PublicFigureConfigIn, optional, nullable) — figure only. The figure's FigureSpec: kind, rendered and provenance, plus spec (plotly, vega-lite) or chart (chart, mixed) and the optional fields.
- `html_content` (string, optional, nullable) — user_interface only. HTML used as the interface's initial index.html; without it the interface starts from Athena's starter page.
- `memory` (integer, optional, nullable) — Computer only. Memory in GiB. Defaults to the template's default. Same policy and admin rules as cpu.
- `parent_folder_id` (string, optional, nullable) — ID of the parent folder to create the asset in
- `provider` (string, optional, nullable) — Computer only. Runtime provider for the computer (e.g. 'talos_v2'). Defaults to the environment's configured computer provider.
- `skill_config` (PublicSkillConfigIn, optional, nullable) — skill only. The skill's SKILL.md content. Created as a draft; publish it with POST /api/v0/assets/\{asset\_id}/publish.
- `suspend_timeout_seconds` (integer, optional, nullable) — Database only. Seconds without activity after which the database suspends (scales to zero): 0 means it never suspends (the compute keeps running, and keeps using capacity), otherwise 60 to 86400 (24 hours). Defaults to 1800 (30 minutes). Applied while the database is provisioned; if it cannot be applied, the database is not created and compute-status reports failed. Read or change it later with GET/PATCH /api/v0/databases/\{asset\_id}/settings.
- `template` (string, optional, nullable) — Computer only. Template key to create the computer from, as picked in the Athena UI's computer creation dialog (e.g. 'default'), or an 'environment:\<asset\_id>' reference to a saved environment. Defaults to the default template. Also accepted as 'snapshot'.
- `title` (string, optional, nullable) — Title for the new asset
- `workspace_id` (string, optional, nullable) — ID of the workspace to create the asset in. If not provided, the asset is created in the workspace of parent_folder_id when one is given, otherwise in the user's current workspace. The user must be a member of that workspace.

## Response

### 200

Asset created successfully

- `asset_id` (string, required) — ID of the newly created asset
- `asset_type` (string, required) — Type of the created asset
- `created_at` (string, required) — Timestamp when the asset was created
- `title` (string, required) — Title of the created asset
- `parent_folder_id` (string, optional, nullable) — ID of the parent folder
- `workspace_id` (string, optional, nullable) — ID of the workspace that owns the created asset

### 202

Computer asset accepted. The returned asset starts with status=initializing while runtime provisioning continues.

- `any`

## Errors

### 400 Bad Request Error

Invalid asset type or request parameters, including an unknown template or a computer size outside the resource policy

- `map from string to any`

### 403 Forbidden Error

User is not a member of the specified workspace, or a non-admin requested an admin-only template or a non-default computer size

- `map from string to any`

### 410 Gone Error

The requested computer template is deprecated

- `any`

### 422 Unprocessable Entity Error

Validation Error

- `detail` (list of ValidationError, optional)

### 500 Internal Server Error

Internal server error during asset creation

- `map from string to any`

### 502 Bad Gateway Error

PPTX Studio could not seed a new presentation; nothing was kept

- `any`

### 503 Service Unavailable Error

Computer provisioning could not be scheduled

- `map from string to any`

## Types

### PublicCollabAgentConfigIn

Initial configuration for a collab agent created via the public API.

- `description` (string, optional, nullable) — What the agent does
- `model` (string, optional, nullable) — Model ID the agent runs on
- `name` (string, optional, nullable) — Agent name; also the asset title when title is omitted.
- `sources` (list of string, optional, nullable) — Knowledge source references: native source IDs, or collab\_source:\<asset\_id> to give the agent an asset as knowledge (e.g. collab\_source:asset\_123). Unrecognized entries are ignored.
- `system_prompt` (string, optional, nullable) — Instructions the agent follows
- `toolkits` (list of string, optional, nullable) — Toolkit IDs the agent can use
- `tools` (list of string, optional, nullable) — Tool IDs the agent can use

### PublicFigureConfigIn

A figure's FigureSpec for ``POST /api/v0/assets/create``. The unified shape only (``kind`` set); the create service validates it against the FigureSpec union, the same check ``createFigureTyped`` runs.

- `kind` (string, required) — FigureSpec discriminator: plotly, vega-lite, chart, mixed or image
- `provenance` (map from string to any, required) — Where the figure came from (runtime, library, versions)
- `rendered` (map from string to any, required) — The rendered preview every FigureSpec carries
- `alt_text` (string, optional, nullable) — Alt text (image figures)
- `chart` (map from string to any, optional, nullable) — chart / mixed only: the chart spec
- `data_snapshot` (map from string to any, optional, nullable) — Optional tabular snapshot supporting edit-later flows
- `description` (string, optional, nullable) — Description
- `source` (map from string to any, optional, nullable) — Where the data came from
- `spec` (map from string to any, optional, nullable) — plotly / vega-lite only: the library spec
- `user_overrides` (map from string to any, optional, nullable) — Overrides a person applied on top of the spec

### PublicSkillConfigIn

SKILL.md content for a skill created via the public API.

- `allowed_tools` (string, optional, nullable) — Space-separated list of pre-approved tools (experimental)
- `body_markdown` (string, optional, default: ) — The markdown instructions below the SKILL.md frontmatter
- `compatibility` (string, optional, nullable) — Environment requirements (max 500 chars)
- `description` (string, optional, default: ) — What the skill does and when to use it (max 1024 chars)
- `license` (string, optional, nullable) — License name or reference
- `metadata` (map from string to string, optional, nullable) — Additional string metadata
- `name` (string, optional, default: ) — Skill name slug (lowercase letters, numbers, single hyphens; max 64 chars). Defaults to a slug of the asset title.

### ValidationError

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

### ValidationErrorLocItems

- string
- integer

### ValidationErrorCtx

## Examples

### assets_create_example

**Request**

```json
{
  "asset_type": "spreadsheet",
  "parent_folder_id": "asset_folder_12345",
  "title": "My New Spreadsheet"
}
```

**Response**

```json
{
  "asset_id": "asset_abc123-def456-ghi789",
  "asset_type": "spreadsheet",
  "created_at": "2024-01-15T10:30:00Z",
  "title": "My New Spreadsheet",
  "parent_folder_id": "asset_folder_12345"
}
```

**SDK Code**

```python assets_create_example
import requests

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

payload = {
    "asset_type": "spreadsheet",
    "parent_folder_id": "asset_folder_12345",
    "title": "My New Spreadsheet"
}
headers = {
    "X-API-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript assets_create_example
const url = 'https://api.athenaintel.com/api/v0/assets/create';
const options = {
  method: 'POST',
  headers: {'X-API-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"asset_type":"spreadsheet","parent_folder_id":"asset_folder_12345","title":"My New Spreadsheet"}'
};

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

```go assets_create_example
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"asset_type\": \"spreadsheet\",\n  \"parent_folder_id\": \"asset_folder_12345\",\n  \"title\": \"My New Spreadsheet\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-API-KEY", "<apiKey>")
	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 assets_create_example
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["X-API-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"asset_type\": \"spreadsheet\",\n  \"parent_folder_id\": \"asset_folder_12345\",\n  \"title\": \"My New Spreadsheet\"\n}"

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

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

HttpResponse<String> response = Unirest.post("https://api.athenaintel.com/api/v0/assets/create")
  .header("X-API-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"asset_type\": \"spreadsheet\",\n  \"parent_folder_id\": \"asset_folder_12345\",\n  \"title\": \"My New Spreadsheet\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.athenaintel.com/api/v0/assets/create', [
  'body' => '{
  "asset_type": "spreadsheet",
  "parent_folder_id": "asset_folder_12345",
  "title": "My New Spreadsheet"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-API-KEY' => '<apiKey>',
  ],
]);

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

```csharp assets_create_example
using RestSharp;

var client = new RestClient("https://api.athenaintel.com/api/v0/assets/create");
var request = new RestRequest(Method.POST);
request.AddHeader("X-API-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"asset_type\": \"spreadsheet\",\n  \"parent_folder_id\": \"asset_folder_12345\",\n  \"title\": \"My New Spreadsheet\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift assets_create_example
import Foundation

let headers = [
  "X-API-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "asset_type": "spreadsheet",
  "parent_folder_id": "asset_folder_12345",
  "title": "My New Spreadsheet"
] as [String : Any]

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

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

### assets_create_example

**Request**

```json
{
  "asset_type": "spreadsheet",
  "parent_folder_id": "asset_folder_12345",
  "title": "My New Spreadsheet"
}
```

**Response**

```json
{
  "asset_id": "asset_abc123-def456-ghi789",
  "asset_type": "computer",
  "created_at": "2024-01-15T10:30:00Z",
  "title": "My Computer",
  "workspace_id": "workspace_abc123"
}
```

**SDK Code**

```python assets_create_example
import requests

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

payload = {
    "asset_type": "spreadsheet",
    "parent_folder_id": "asset_folder_12345",
    "title": "My New Spreadsheet"
}
headers = {
    "X-API-KEY": "<apiKey>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript assets_create_example
const url = 'https://api.athenaintel.com/api/v0/assets/create';
const options = {
  method: 'POST',
  headers: {'X-API-KEY': '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"asset_type":"spreadsheet","parent_folder_id":"asset_folder_12345","title":"My New Spreadsheet"}'
};

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

```go assets_create_example
package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"asset_type\": \"spreadsheet\",\n  \"parent_folder_id\": \"asset_folder_12345\",\n  \"title\": \"My New Spreadsheet\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("X-API-KEY", "<apiKey>")
	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 assets_create_example
require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["X-API-KEY"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"asset_type\": \"spreadsheet\",\n  \"parent_folder_id\": \"asset_folder_12345\",\n  \"title\": \"My New Spreadsheet\"\n}"

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

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

HttpResponse<String> response = Unirest.post("https://api.athenaintel.com/api/v0/assets/create")
  .header("X-API-KEY", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"asset_type\": \"spreadsheet\",\n  \"parent_folder_id\": \"asset_folder_12345\",\n  \"title\": \"My New Spreadsheet\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.athenaintel.com/api/v0/assets/create', [
  'body' => '{
  "asset_type": "spreadsheet",
  "parent_folder_id": "asset_folder_12345",
  "title": "My New Spreadsheet"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'X-API-KEY' => '<apiKey>',
  ],
]);

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

```csharp assets_create_example
using RestSharp;

var client = new RestClient("https://api.athenaintel.com/api/v0/assets/create");
var request = new RestRequest(Method.POST);
request.AddHeader("X-API-KEY", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"asset_type\": \"spreadsheet\",\n  \"parent_folder_id\": \"asset_folder_12345\",\n  \"title\": \"My New Spreadsheet\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift assets_create_example
import Foundation

let headers = [
  "X-API-KEY": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "asset_type": "spreadsheet",
  "parent_folder_id": "asset_folder_12345",
  "title": "My New Spreadsheet"
] as [String : Any]

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

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