> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tess.im/llms.txt
> Use this file to discover all available pages before exploring further.

# Upload de Arquivo 

### `POST /files`

Faz upload de um novo arquivo para o sistema e opcionalmente o processa.

<Warning>
  **Máximo de 32 MB por arquivo neste endpoint.** Esta chamada single-shot `POST /files` envia o corpo do arquivo através do servidor da API, que tem um limite rígido de 32 MB no tamanho do corpo de requisições HTTP de entrada. Arquivos maiores que 32 MB são rejeitados antes de chegarem à camada da aplicação.

  Para arquivos maiores que 32 MB, utilize o [fluxo de upload assinado v2](/pt/upload-file-v2). Ele envia o corpo do arquivo diretamente do seu cliente para o Google Cloud Storage (o servidor da API fica fora do caminho dos bytes) e aceita arquivos de até 200 MB.
</Warning>

### **Arquivos suportados**

| **Rótulo**  | **Padrões de Arquivo**                                                                                                                                                                                                                           |
| :---------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Texto       | `*.txt`                                                                                                                                                                                                                                          |
| Word        | `*.{doc,docx}`                                                                                                                                                                                                                                   |
| Planilha    | `*.csv`                                                                                                                                                                                                                                          |
| PDF         | `*.pdf`                                                                                                                                                                                                                                          |
| Excel       | `*.xls`,`*.xlsx`                                                                                                                                                                                                                                 |
| Power Point | `*.{ppt,pptx}`                                                                                                                                                                                                                                   |
| Imagem      | `*.{jpg,jpeg,png,gif,bmp,svg,tiff,webp}`                                                                                                                                                                                                         |
| Vídeo       | `*.{mp4,avi,mov,mkv,wmv,flv}`                                                                                                                                                                                                                    |
| Áudio       | `*.{mp3,wav,aac,ogg,flac,m4a}`                                                                                                                                                                                                                   |
| Código      | `*.bas`, `*.bat`, `*.xml`, `*.css`, `*.dart`, `*.{html,htm}`, `*.inc`, `*.js`, `*.json`, `*.kt`, `*.lua`, `*.pas`, `*.php`, `*.pl`, `*.ps1`, `*.py`, `*.r`, `*.sh`, `*.vsd`, `*.sql`, `*.swift`, `*.ts`, `*.vb`, `*.vba`, `*.{yml,yaml}`, `*.md` |

### **Limites**

* Tamanho máximo de arquivo por upload neste endpoint: **32 MB** (limite de tamanho de requisição HTTP da plataforma). Para arquivos de até 200 MB, use o [fluxo de upload assinado v2](/pt/upload-file-v2).
* Este endpoint aceita um arquivo por solicitação (use várias solicitações para vários arquivos).
* Limite de armazenamento de arquivos: 30 arquivos
* Alguns recursos têm limites diferentes:
  * Anexos de bate-papo: até 200 MB por arquivo via o fluxo de upload assinado v2; até 5 arquivos por envio
  * Transcrição de áudio: até 10 MB por arquivo

### **Exemplos de Código**

<CodeGroup>
  ```http cURL theme={null}
  curl --request POST \
    --url 'https://api.tess.im/files' \
    --header 'Authorization: Bearer YOUR_API_KEY' \
    --header 'x-workspace-id: YOUR_WORKSPACE_ID' \
    --header 'Content-Type: multipart/form-data' \
    --form 'file=@/path/to/file' \
    --form 'process=false'
  ```

  ```json Node.js theme={null}
  const axios = require('axios');
  const FormData = require('form-data');
  const fs = require('fs');

  const form = new FormData();
  form.append('file', fs.createReadStream('/path/to/file'));
  form.append('process', 'false');

  const config = {
    method: 'post',
    url: 'https://api.tess.im/files',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
        'x-workspace-id': 'YOUR_WORKSPACE_ID',
      ...form.getHeaders()
    },
    data: form
  };

  try {
    const response = await axios(config);
    console.log(response.data);
  } catch (error) {
    console.error(error);
  }
  ```

  ```python Python theme={null}
  import requests

  url = "https://api.tess.im/files"
  headers = {
      "Authorization": "Bearer YOUR_API_KEY",
        "x-workspace-id": "YOUR_WORKSPACE_ID"
  }
  files = {
      'file': open('/path/to/file', 'rb')
  }
  data = {
      'process': 'false'
  }

  response = requests.post(url, headers=headers, files=files, data=data)
  print(response.json())
  ```

  ```php PHP theme={null}
  <?php
  $curl = curl_init();

  $file = new CURLFile('/path/to/file');

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://api.tess.im/files",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => [
      'file' => $file,
      'process' => 'false'
    ],
    CURLOPT_HTTPHEADER => [
      "Authorization: Bearer YOUR_API_KEY",
        "x-workspace-id: YOUR_WORKSPACE_ID",
      "Content-Type: multipart/form-data"
    ]
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "Error: " . $err;
  } else {
    echo $response;
  }
  ```

  ```java Java theme={null}
  import java.io.File;
  import java.net.URI;
  import java.net.http.HttpClient;
  import java.net.http.HttpRequest;
  import java.net.http.HttpResponse;
  import java.nio.file.Path;

  String boundary = "---boundary" + System.currentTimeMillis();
  File file = new File("/path/to/file");

  HttpClient client = HttpClient.newBuilder().build();
  HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://api.tess.im/files"))
      .header("Authorization", "Bearer YOUR_API_KEY")
        .header("x-workspace-id", "YOUR_WORKSPACE_ID")
      .header("Content-Type", "multipart/form-data;boundary=" + boundary)
      .POST(HttpRequest.BodyPublishers.ofFile(file.toPath()))
      .build();

  HttpResponse<String> response = client.send(request,
      HttpResponse.BodyHandlers.ofString());
  System.out.println(response.body());
  ```

  ```go Go theme={null}
  package main

  import (
      "bytes"
      "fmt"
      "io"
      "io/ioutil"
      "mime/multipart"
      "net/http"
      "os"
  )

  func main() {
      file, err := os.Open("/path/to/file")
      if err != nil {
          fmt.Println(err)
          return
      }
      defer file.Close()
      
      body := &bytes.Buffer{}
      writer := multipart.NewWriter(body)
      
      part, err := writer.CreateFormFile("file", "filename")
      if err != nil {
          fmt.Println(err)
          return
      }
      io.Copy(part, file)
      
      
      writer.WriteField("process", "false")
      writer.Close()
      
      client := &http.Client{}
      req, err := http.NewRequest("POST", "https://api.tess.im/files", body)
      if err != nil {
          fmt.Println(err)
          return
      }
      
      req.Header.Add("Authorization", "Bearer YOUR_API_KEY")
      req.Header.Add("x-workspace-id", "YOUR_WORKSPACE_ID")
      req.Header.Add("Content-Type", writer.FormDataContentType())
      
      resp, err := client.Do(req)
      if err != nil {
          fmt.Println(err)
          return
      }
      defer resp.Body.Close()
      
      respBody, err := ioutil.ReadAll(resp.Body)
      if err != nil {
          fmt.Println(err)
          return
      }
      
      fmt.Println(string(respBody))
  }
  ```

  ```jsonnet .NET theme={null}
  using System;
  using System.Net.Http;
  using System.Threading.Tasks;

  class Program
  {
      static async Task Main(string[] args)
      {
          using (var client = new HttpClient())
          {
              client.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_API_KEY");
              client.DefaultRequestHeaders.Add("x-workspace-id", "YOUR_WORKSPACE_ID");
              
              using (var formData = new MultipartFormDataContent())
              {
                  var fileContent = new ByteArrayContent(File.ReadAllBytes("/path/to/file"));
                  formData.Add(fileContent, "file", "filename");
                  formData.Add(new StringContent("false"), "process");
                  
                  try
                  {
                      var response = await client.PostAsync("https://api.tess.im/files", formData);
                      response.EnsureSuccessStatusCode();
                      string responseBody = await response.Content.ReadAsStringAsync();
                      Console.WriteLine(responseBody);
                  }
                  catch(HttpRequestException e)
                  {
                      Console.WriteLine("\nException Caught!");
                      Console.WriteLine("Message :{0} ",e.Message);
                  }
              }
          }
      }
  }
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'json'

  uri = URI('https://api.tess.im/files')
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  request = Net::HTTP::Post.new(uri)
  request['Authorization'] = 'Bearer YOUR_API_KEY'
  request['x-workspace-id'] = 'YOUR_WORKSPACE_ID'

  form_data = [
    ['file', File.open('/path/to/file')],
    ['process', 'false']
  ]
  request.set_form form_data, 'multipart/form-data'

  response = http.request(request)
  puts response.read_body
  ```
</CodeGroup>

### **Cabeçalhos**

<ParamField header="x-workspace-id" type="integer" required>
  ID do workspace. **Obrigatório a partir de 01/09/2026.** Até lá, se omitido, usa o workspace selecionado do usuário (deprecated). Após a data, ausência → **422**.
</ParamField>

### **Parâmetros do Corpo**

<Warning>
  O playground não suporta uploads `multipart/form-data` diretamente. Use os **Exemplos de Código** acima (cURL, Python, Node.js, etc.) para enviar o arquivo. Os campos abaixo são exibidos apenas para documentação.
</Warning>

<ParamField body="file" type="file" required>
  O arquivo a ser enviado (multipart/form-data)
</ParamField>

<ParamField body="process" type="boolean">
  Se deve processar o arquivo após o upload (padrão: false). O processamento consome créditos (true).
</ParamField>

### **Resposta**

```json theme={null}
{
"id": 123,
"filename": "documento.pdf",
"size": 1024000,
"content_type": "application/pdf",
"status": "uploaded",
"created_at": "2025-01-05T22:39:57+00:00",
"updated_at": "2025-01-05T22:39:57+00:00"
}
```