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

# Enviar template no atendimento

> Envie um template vinculado a um atendimento, com variáveis preenchidas automaticamente

```http theme={null}
POST https://api.hustapp.com/called/{id}/template/{idTemplate}
```

Envia um template dentro de um atendimento. São duas operações: primeiro [abra o atendimento](/chat/atendimentos/abrir), depois envie o template usando o `id` devolvido.

Diferente do [envio avulso](/chat/templates/enviar), aqui o Hust preenche automaticamente as variáveis do template com os dados do atendimento, e você pode simular o envio antes de dispará-lo.

## Parâmetros de caminho

| Parâmetro    | Descrição                                                                                                                                                   |
| ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `id`         | ID do atendimento.                                                                                                                                          |
| `idTemplate` | ID do template, obtido em [Listar templates](/chat/templates/listar). Ou `auto_by_connection` — veja [Escolha automática](#escolha-automática-por-conexão). |

## Parâmetros de consulta

| Parâmetro | Tipo      | Descrição                                                                                                   |
| --------- | --------- | ----------------------------------------------------------------------------------------------------------- |
| `dry_run` | `boolean` | Quando `true`, resolve as variáveis e devolve o resultado sem enviar. Veja [Simulando](#simulando-o-envio). |

## Corpo da requisição

| Campo       | Tipo        | Obrigatório              | Descrição                                                                                                                               |
| ----------- | ----------- | ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------- |
| `params`    | `object`    | Não                      | Valores das variáveis. Sobrepõem os preenchidos automaticamente. Mesmo formato de [Enviar template](/chat/templates/enviar#parâmetros). |
| `templates` | `integer[]` | Com `auto_by_connection` | IDs dos templates candidatos.                                                                                                           |

## Preenchimento automático

Variáveis do template cujo nome corresponde a um dado do atendimento são preenchidas pelo Hust. Você só precisa enviar em `params` o que o atendimento não sabe — um número de pedido, por exemplo.

Se uma variável vier nos dois lugares, o valor de `params` prevalece.

## Escolha automática por conexão

Como templates são aprovados por conta WABA, uma empresa com várias conexões costuma ter uma cópia do mesmo template em cada uma, com IDs diferentes.

Com `idTemplate` igual a `auto_by_connection`, você envia a lista de candidatos em `templates` e o Hust usa o que pertence à conexão do atendimento:

```json theme={null}
{ "templates": [3021, 3022, 3023] }
```

Assim a sua integração não precisa saber de antemão por qual conexão o atendimento corre.

## Simulando o envio

Com `dry_run=true`, nada é enviado. A resposta mostra como cada variável do template foi resolvida, e é a forma de descobrir quais o Hust preenche sozinho e quais você precisa enviar em `params`.

```json theme={null}
{
  "params": {
    "nome_cliente": { "location": "body", "type": "text", "value": "José Maria" },
    "valor": { "location": "body", "type": "text", "value": "" },
    "data_vencimento": { "location": "body", "type": "text", "value": "" }
  }
}
```

Neste exemplo, `nome_cliente` veio do atendimento, e `valor` e `data_vencimento` precisam ser enviados.

| Campo                        | Descrição                                                                 |
| ---------------------------- | ------------------------------------------------------------------------- |
| `location`                   | Onde a variável fica no template: `header` ou `body`.                     |
| `type`                       | `text`, `image`, `document` ou `video`.                                   |
| `value`                      | Valor resolvido, em variáveis de texto. Vazio indica que falta preencher. |
| `image`, `document`, `video` | Em variáveis de mídia, objeto com o `link` do arquivo.                    |

### Variáveis de mídia

Templates com imagem, documento ou vídeo no cabeçalho têm uma variável de mídia. Envie o arquivo como um link público em `params`:

```json theme={null}
{
  "params": {
    "comprovante": { "document": { "link": "https://exemplo.com/comprovante.pdf" } }
  }
}
```

A simulação também valida variáveis de mídia: se o link não for informado, a variável aparece sem valor no `dry_run` e o envio real é recusado.

## Fluxo completo

<CodeGroup>
  ```javascript Node.js theme={null}
  const headers = {
    Authorization: `Bearer ${token}`,
    "Content-Type": "application/json",
  };

  // 1. Abre (ou recupera) o atendimento
  const calledRes = await fetch("https://api.hustapp.com/called", {
    method: "POST",
    headers,
    body: JSON.stringify({
      contact: { phone: "5541988887777" },
      connection: { uuid: "9db04f68-9e7d-4297-ba41-5f4d4c44779a" },
      department: { id: 169070 },
    }),
  });
  const called = await calledRes.json();

  // 2. Envia o template no atendimento
  const sendRes = await fetch(
    `https://api.hustapp.com/called/${called.id}/template/3021`,
    {
      method: "POST",
      headers,
      body: JSON.stringify({ params: { pedido: { value: "4521" } } }),
    }
  );

  const sent = await sendRes.json(); // true
  ```

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

  headers = {"Authorization": f"Bearer {token}"}

  # 1. Abre (ou recupera) o atendimento
  called = requests.post(
      "https://api.hustapp.com/called",
      headers=headers,
      json={
          "contact": {"phone": "5541988887777"},
          "connection": {"uuid": "9db04f68-9e7d-4297-ba41-5f4d4c44779a"},
          "department": {"id": 169070},
      },
  ).json()

  # 2. Envia o template no atendimento
  sent = requests.post(
      f"https://api.hustapp.com/called/{called['id']}/template/3021",
      headers=headers,
      json={"params": {"pedido": {"value": "4521"}}},
  ).json()  # True
  ```

  ```php PHP theme={null}
  <?php
  function hustPost(string $url, array $body, string $token): mixed
  {
      $ch = curl_init($url);
      curl_setopt_array($ch, [
          CURLOPT_POST => true,
          CURLOPT_RETURNTRANSFER => true,
          CURLOPT_HTTPHEADER => [
              'Authorization: Bearer ' . $token,
              'Content-Type: application/json',
          ],
          CURLOPT_POSTFIELDS => json_encode($body),
      ]);
      $response = json_decode(curl_exec($ch), true);
      curl_close($ch);
      return $response;
  }

  // 1. Abre (ou recupera) o atendimento
  $called = hustPost('https://api.hustapp.com/called', [
      'contact' => ['phone' => '5541988887777'],
      'connection' => ['uuid' => '9db04f68-9e7d-4297-ba41-5f4d4c44779a'],
      'department' => ['id' => 169070],
  ], $token);

  // 2. Envia o template no atendimento
  $sent = hustPost(
      "https://api.hustapp.com/called/{$called['id']}/template/3021",
      ['params' => ['pedido' => ['value' => '4521']]],
      $token
  ); // true
  ```

  ```pascal Delphi theme={null}
  uses
    System.Net.HttpClient, System.Classes, System.JSON, System.SysUtils;

  const
    CalledBody =
      '{' +
      '  "contact": { "phone": "5541988887777" },' +
      '  "connection": { "uuid": "9db04f68-9e7d-4297-ba41-5f4d4c44779a" },' +
      '  "department": { "id": 169070 }' +
      '}';
    TemplateBody = '{ "params": { "pedido": { "value": "4521" } } }';

  var
    HttpClient: THTTPClient;
    Response: IHTTPResponse;
    Called: TJSONObject;
    CalledId: Integer;
  begin
    HttpClient := THTTPClient.Create;
    try
      HttpClient.CustomHeaders['Authorization'] := 'Bearer ' + Token;
      HttpClient.ContentType := 'application/json';

      // 1. Abre (ou recupera) o atendimento
      Response := HttpClient.Post('https://api.hustapp.com/called',
        TStringStream.Create(CalledBody, TEncoding.UTF8));

      Called := TJSONObject.ParseJSONValue(Response.ContentAsString) as TJSONObject;
      try
        CalledId := Called.GetValue<Integer>('id');
      finally
        Called.Free;
      end;

      // 2. Envia o template no atendimento
      Response := HttpClient.Post(
        Format('https://api.hustapp.com/called/%d/template/3021', [CalledId]),
        TStringStream.Create(TemplateBody, TEncoding.UTF8));
    finally
      HttpClient.Free;
    end;
  end;
  ```
</CodeGroup>

## Resposta

Retorna `200` com o corpo `true` quando o template é enviado, ou `200` com `{ "params": {...} }` em modo `dry_run`.

## Erros

| Status | Quando                                                                                                                                | Corpo                                                                                                                         |
| ------ | ------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `500`  | Variáveis do template sem valor                                                                                                       | `{ "user_message": "Não foi possível enviar o template.", "message": ["O parâmetro \"pedido\" do template é obrigatório."] }` |
| `500`  | Atendimento ou template não encontrados, `templates` ausente com `auto_by_connection`, nenhum candidato na conexão, ou falha no envio | `false`                                                                                                                       |

<Tip>
  Rode com `dry_run=true` antes de colocar um template novo em produção. É a forma mais rápida de ver quais variáveis ficariam vazias.
</Tip>