# Upload files via base64

Upload files directly to vector stores using base64-encoded content in a single API call.

Upload files directly to a vector store using base64-encoded content. This method allows you to upload files without first uploading them to the file storage system.

#### Path Parameters

**`organization_id`** string required

The unique identifier of the organization (format: `org_*`).

**`vector_store_id`** string required

The unique identifier of the vector store (format: `vs_*`).

#### Request Body

**`files`** array required

Array of file objects to upload (max 10 files per request).

**`files[].filename`** string required

Original filename with extension.

**`files[].content`** string required

Base64-encoded file content (without data URL prefix).

**`files[].mime_type`** string required

MIME type of the file.

#### Supported File Types

| Type | MIME Type | Max Size |
|  --- | --- | --- |
| PDF | `application/pdf` | 50 MB |
| Text | `text/plain` | 10 MB |
| Markdown | `text/markdown` | 10 MB |
| CSV | `text/csv` | 10 MB |
| JSON | `application/json` | 10 MB |
| Word | `application/vnd.openxmlformats-officedocument.wordprocessingml.document` | 50 MB |
| PowerPoint | `application/vnd.openxmlformats-officedocument.presentationml.presentation` | 50 MB |
| Excel | `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet` | 50 MB |


## Returns

A success response with uploaded file details including processing status.

Single File Upload

```bash
# Read file and encode to base64
FILE_CONTENT=$(base64 -i document.pdf)

curl -X POST "https://api.aitronos.com/v1/organizations/org_abc123/vector-stores/vs_xyz789/files/upload-base64" \
  -H "X-API-Key: $FREDDY_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"files\": [
      {
        \"filename\": \"document.pdf\",
        \"content\": \"$FILE_CONTENT\",
        \"mime_type\": \"application/pdf\"
      }
    ]
  }"
```


```python
import os
import base64
import requests

api_key = os.environ["FREDDY_API_KEY"]

# Read and encode file
with open("document.pdf", "rb") as f:
    file_content = base64.b64encode(f.read()).decode("utf-8")

response = requests.post(
    "https://api.aitronos.com/v1/organizations/org_abc123/vector-stores/vs_xyz789/files/upload-base64",
    headers={"X-API-Key": api_key},
    json={
        "files": [
            {
                "filename": "document.pdf",
                "content": file_content,
                "mime_type": "application/pdf"
            }
        ]
    }
)

result = response.json()
print(f"Uploaded file: {result['files'][0]['id']}")
```


```javascript
const apiKey = process.env.FREDDY_API_KEY;
const fs = require('fs');

// Read and encode file
const fileBuffer = fs.readFileSync('document.pdf');
const fileContent = fileBuffer.toString('base64');

const response = await fetch(
  'https://api.aitronos.com/v1/organizations/org_abc123/vector-stores/vs_xyz789/files/upload-base64',
  {
    method: 'POST',
    headers: {
      'X-API-Key': apiKey,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      files: [
        {
          filename: 'document.pdf',
          content: fileContent,
          mime_type: 'application/pdf'
        }
      ]
    })
  }
);

const result = await response.json();
console.log(`Uploaded file: ${result.files[0].id}`);
```

Multiple Files Upload

```bash
# Encode multiple files
FILE1=$(base64 -i report.pdf)
FILE2=$(base64 -i data.csv)
FILE3=$(base64 -i notes.txt)

curl -X POST "https://api.aitronos.com/v1/organizations/org_abc123/vector-stores/vs_xyz789/files/upload-base64" \
  -H "X-API-Key: $FREDDY_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"files\": [
      {
        \"filename\": \"report.pdf\",
        \"content\": \"$FILE1\",
        \"mime_type\": \"application/pdf\"
      },
      {
        \"filename\": \"data.csv\",
        \"content\": \"$FILE2\",
        \"mime_type\": \"text/csv\"
      },
      {
        \"filename\": \"notes.txt\",
        \"content\": \"$FILE3\",
        \"mime_type\": \"text/plain\"
      }
    ]
  }"
```


```python
import os
import base64
import requests

api_key = os.environ["FREDDY_API_KEY"]

# Prepare multiple files
files_to_upload = [
    ("report.pdf", "application/pdf"),
    ("data.csv", "text/csv"),
    ("notes.txt", "text/plain")
]

files_data = []
for filename, mime_type in files_to_upload:
    with open(filename, "rb") as f:
        content = base64.b64encode(f.read()).decode("utf-8")
        files_data.append({
            "filename": filename,
            "content": content,
            "mime_type": mime_type
        })

response = requests.post(
    "https://api.aitronos.com/v1/organizations/org_abc123/vector-stores/vs_xyz789/files/upload-base64",
    headers={"X-API-Key": api_key},
    json={"files": files_data}
)

result = response.json()
print(f"Uploaded {len(result['files'])} files")
for file in result['files']:
    print(f"  - {file['filename']}: {file['id']}")
```


```javascript
const apiKey = process.env.FREDDY_API_KEY;
const fs = require('fs');

// Prepare multiple files
const filesToUpload = [
  { path: 'report.pdf', mimeType: 'application/pdf' },
  { path: 'data.csv', mimeType: 'text/csv' },
  { path: 'notes.txt', mimeType: 'text/plain' }
];

const filesData = filesToUpload.map(file => ({
  filename: file.path,
  content: fs.readFileSync(file.path).toString('base64'),
  mime_type: file.mimeType
}));

const response = await fetch(
  'https://api.aitronos.com/v1/organizations/org_abc123/vector-stores/vs_xyz789/files/upload-base64',
  {
    method: 'POST',
    headers: {
      'X-API-Key': apiKey,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ files: filesData })
  }
);

const result = await response.json();
console.log(`Uploaded ${result.files.length} files`);
result.files.forEach(file => {
  console.log(`  - ${file.filename}: ${file.id}`);
});
```

Complete Workflow

```bash
# Step 1: Create vector store
VS_RESPONSE=$(curl -X POST "https://api.aitronos.com/v1/organizations/org_abc123/vector-stores" \
  -H "X-API-Key: $FREDDY_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My Documents",
    "description": "Company documents for Q1 2025"
  }')

VS_ID=$(echo $VS_RESPONSE | jq -r '.id')
echo "Created vector store: $VS_ID"

# Step 2: Upload file via base64
FILE_CONTENT=$(base64 -i document.pdf)

UPLOAD_RESPONSE=$(curl -X POST "https://api.aitronos.com/v1/organizations/org_abc123/vector-stores/$VS_ID/files/upload-base64" \
  -H "X-API-Key: $FREDDY_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"files\": [{
      \"filename\": \"document.pdf\",
      \"content\": \"$FILE_CONTENT\",
      \"mime_type\": \"application/pdf\"
    }]
  }")

FILE_ID=$(echo $UPLOAD_RESPONSE | jq -r '.files[0].file_id')
echo "Uploaded file: $FILE_ID"

# Step 3: Wait for processing (optional)
sleep 3

STATUS_RESPONSE=$(curl "https://api.aitronos.com/v1/organizations/org_abc123/vector-stores/$VS_ID/files/$FILE_ID/status" \
  -H "X-API-Key: $FREDDY_API_KEY")

echo "Processing status: $(echo $STATUS_RESPONSE | jq -r '.data.status')"

# Step 4: Query via chat API
curl -X POST "https://api.aitronos.com/v1/model/response" \
  -H "X-API-Key: $FREDDY_API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"inputs\": [{
      \"role\": \"user\",
      \"content\": \"Summarize the key points from the document\"
    }],
    \"vector_store_ids\": [\"$VS_ID\"],
    \"stream\": false
  }"
```


```python
import os
import base64
import time
import requests

api_key = os.environ["FREDDY_API_KEY"]
base_url = "https://api.aitronos.com/v1"
org_id = "org_abc123"

# Step 1: Create vector store
vs_response = requests.post(
    f"{base_url}/organizations/{org_id}/vector-stores",
    headers={"X-API-Key": api_key},
    json={
        "name": "My Documents",
        "description": "Company documents for Q1 2025"
    }
)
vs_id = vs_response.json()["id"]
print(f"Created vector store: {vs_id}")

# Step 2: Upload file via base64
with open("document.pdf", "rb") as f:
    file_content = base64.b64encode(f.read()).decode("utf-8")

upload_response = requests.post(
    f"{base_url}/organizations/{org_id}/vector-stores/{vs_id}/files/upload-base64",
    headers={"X-API-Key": api_key},
    json={
        "files": [{
            "filename": "document.pdf",
            "content": file_content,
            "mime_type": "application/pdf"
        }]
    }
)
file_id = upload_response.json()["files"][0]["file_id"]
print(f"Uploaded file: {file_id}")

# Step 3: Wait for processing
time.sleep(3)

status_response = requests.get(
    f"{base_url}/organizations/{org_id}/vector-stores/{vs_id}/files/{file_id}/status",
    headers={"X-API-Key": api_key}
)
status = status_response.json()["data"]["status"]
print(f"Processing status: {status}")

# Step 4: Query via chat API
chat_response = requests.post(
    f"{base_url}/model/response",
    headers={"X-API-Key": api_key},
    json={
        "inputs": [{
            "role": "user",
            "content": "Summarize the key points from the document"
        }],
        "vector_store_ids": [vs_id],
        "stream": False
    }
)

result = chat_response.json()
print(f"AI Response: {result['response']}")
```


```javascript
const apiKey = process.env.FREDDY_API_KEY;
const fs = require('fs');

const baseUrl = 'https://api.aitronos.com/v1';
const orgId = 'org_abc123';

async function completeWorkflow() {
  // Step 1: Create vector store
  const vsResponse = await fetch(
    `${baseUrl}/organizations/${orgId}/vector-stores`,
    {
      method: 'POST',
      headers: {
        'X-API-Key': apiKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        name: 'My Documents',
        description: 'Company documents for Q1 2025'
      })
    }
  );
  const vsData = await vsResponse.json();
  const vsId = vsData.id;
  console.log(`Created vector store: ${vsId}`);

  // Step 2: Upload file via base64
  const fileContent = fs.readFileSync('document.pdf').toString('base64');
  
  const uploadResponse = await fetch(
    `${baseUrl}/organizations/${orgId}/vector-stores/${vsId}/files/upload-base64`,
    {
      method: 'POST',
      headers: {
        'X-API-Key': apiKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        files: [{
          filename: 'document.pdf',
          content: fileContent,
          mime_type: 'application/pdf'
        }]
      })
    }
  );
  const uploadData = await uploadResponse.json();
  const fileId = uploadData.files[0].file_id;
  console.log(`Uploaded file: ${fileId}`);

  // Step 3: Wait for processing
  await new Promise(resolve => setTimeout(resolve, 3000));

  const statusResponse = await fetch(
    `${baseUrl}/organizations/${orgId}/vector-stores/${vsId}/files/${fileId}/status`,
    {
      headers: { 'X-API-Key': apiKey }
    }
  );
  const statusData = await statusResponse.json();
  console.log(`Processing status: ${statusData.data.status}`);

  // Step 4: Query via chat API
  const chatResponse = await fetch(
    `${baseUrl}/model/response`,
    {
      method: 'POST',
      headers: {
        'X-API-Key': apiKey,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        inputs: [{
          role: 'user',
          content: 'Summarize the key points from the document'
        }],
        vector_store_ids: [vsId],
        stream: false
      })
    }
  );
  const chatData = await chatResponse.json();
  console.log(`AI Response: ${chatData.response}`);
}

completeWorkflow();
```

**Response:**

201 Created

```json
{
  "success": true,
  "message": "1 file(s) uploaded successfully",
  "files": [
    {
      "id": "vsf_abc123def456",
      "file_id": "file_xyz789ghi012",
      "filename": "document.pdf",
      "size": 28042,
      "mime_type": "application/pdf",
      "processing_status": "pending",
      "created_at": "2025-01-14T10:12:01.850Z"
    }
  ]
}
```

400 Bad Request - Invalid File

```json
{
  "detail": {
    "code": "VALIDATION_ERROR",
    "message": "Invalid file format",
    "details": {
      "filename": "document.txt",
      "error": "MIME type text/plain does not match file content (detected: application/pdf)"
    }
  }
}
```

400 Bad Request - File Too Large

```json
{
  "detail": {
    "code": "VALIDATION_ERROR",
    "message": "File size exceeds limit",
    "details": {
      "filename": "large.pdf",
      "size": 52428800,
      "limit": 52428800,
      "mime_type": "application/pdf"
    }
  }
}
```

401 Unauthorized

```json
{
  "success": false,
  "error": {
    "code": "UNAUTHORIZED",
    "message": "Authentication required. Please provide a valid API key.",
    "system_message": "Missing or invalid authorization header",
    "type": "authentication_error",
    "status": 401,
    "trace_id": "req_abc123",
    "timestamp": "2025-01-14T10:12:01.850Z"
  }
}
```

403 Forbidden

```json
{
  "success": false,
  "error": {
    "code": "FORBIDDEN",
    "message": "You don't have permission to upload files to this vector store.",
    "system_message": "Insufficient permissions",
    "type": "authorization_error",
    "status": 403,
    "trace_id": "req_def456",
    "timestamp": "2025-01-14T10:12:01.850Z"
  }
}
```

404 Not Found

```json
{
  "detail": {
    "code": "RESOURCE_NOT_FOUND",
    "message": "Vector store not found",
    "details": {
      "vector_store_id": "vs_invalid"
    }
  }
}
```

## Processing Status

After upload, files are queued for processing:

1. **pending** - File uploaded, waiting in queue
2. **processing** - File being chunked and embedded
3. **completed** - File ready for search (typically 2-5 seconds)
4. **failed** - Processing error occurred


Check processing status:


```
GET /v1/organizations/{org_id}/vector-stores/{vector_store_id}/files/{file_id}/status
```

## Using Uploaded Files

### Method 1: Direct Vector Store Attachment

Attach vector stores directly to chat requests:


```json
{
  "inputs": [
    {
      "role": "user",
      "content": "What is in the uploaded document?"
    }
  ],
  "vector_store_ids": ["vs_abc123"],
  "stream": false
}
```

### Method 2: Via Assistant

1. Create assistant with `file_search` tool enabled
2. Attach vector stores to assistant
3. Use assistant in chat requests


## Rate Limits

- **Max files per request**: 10
- **Max file size**: 50 MB (PDFs, Office docs), 10 MB (text files)
- **Max concurrent uploads**: 100 per organization
- **Processing queue**: Files processed in order, typically 2-5 seconds per file


## Best Practices

1. **Batch uploads**: Upload multiple files in a single request when possible
2. **Check status**: Poll status endpoint after upload to confirm processing completion
3. **Handle errors**: Implement retry logic for transient failures
4. **File naming**: Use descriptive filenames for better organization
5. **MIME types**: Always provide accurate MIME types for proper processing
6. **Base64 encoding**: Remove data URL prefix (`data:application/pdf;base64,`) before sending


## Security

- Files are scoped to organizations - users can only access files in their organization
- Files are stored securely with encryption at rest
- Vector embeddings are isolated per organization
- API keys and bearer tokens provide authentication
- All uploads are validated for file type and size


## Limitations

- Maximum 10 files per request
- Files must be base64-encoded
- Processing is asynchronous (2-5 seconds typical)
- Vector stores have a maximum capacity (contact support for limits)
- Some file types require specific processing (OCR for images, parsing for Office docs)


## Related Resources

- [Add File to Vector Store](/docs/api-reference/vector-stores/add-file)
- [List Files in Vector Store](/docs/api-reference/vector-stores/list-files)
- [Get File Processing Status](/docs/api-reference/vector-stores/file-status)
- [Upload File](/docs/api-reference/files/upload)
- [Create Vector Store](/docs/api-reference/vector-stores/create)