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

# Templates de email

> Crie templates de texto e HTML e envie mensagens personalizadas para um ou vários destinos.

Templates armazenam assunto e corpo com variáveis. Nomes são imutáveis e únicos na conta. `body_type` é `text` ou `html`.

<span id="create-a-template" />

## Criar um template

<Tabs>
  <Tab title="Console">
    Abra Email, depois **Templates**, e clique em **Create template**. Informe os templates de assunto e corpo e escolha o tipo do corpo. Abra o template salvo para editá-lo ou enviar uma mensagem de teste.
  </Tab>

  <Tab title="API">
    Envie `POST /v1/templates`:

    ```json theme={null}
    {
      "name":"report-ready",
      "subject_template":"Your report, {{name}}",
      "body_template":"<p>Hello {{name}}, your report is ready.</p>",
      "body_type":"html"
    }
    ```

    Use `PATCH /v1/templates/{template_id}` para atualizar o conteúdo. O nome permanece inalterado. Assunto, corpo e tipo omitidos são preservados. Um `subject_template` vazio limpa o assunto; o corpo deve continuar não vazio.
  </Tab>

  <Tab title="CLI">
    Salve a solicitação JSON da aba API como `request-1.json`. Use sua conta e região configuradas.

    ```bash theme={null}
    basaltic email template create --from-file request-1.json
    ```
  </Tab>

  <Tab title="Go">
    Salve a solicitação JSON da aba API como `request-1.json`. Configure credenciais, conta e região pelas variáveis de ambiente do SDK.

    ```go theme={null}
    package main

    import (
    	"context"
    	"encoding/json"
    	"fmt"
    	"os"

    	basaltic "github.com/basaltic-sh/sdk-go"
    	"github.com/basaltic-sh/sdk-go/email"
    )

    func readJSON(path string, value any) error {
    	data, err := os.ReadFile(path)
    	if err != nil {
    		return err
    	}
    	return json.Unmarshal(data, value)
    }

    func run() error {
    	ctx := context.Background()
    	cfg, err := basaltic.NewConfig(ctx)
    	if err != nil {
    		return err
    	}
    	client := email.New(cfg)
    	var request1 email.CreateTemplateRequest
    	if err := readJSON("request-1.json", &request1); err != nil {
    		return err
    	}
    	result1, err := client.CreateTemplate(ctx, &request1)
    	if err != nil {
    		return err
    	}
    	fmt.Printf("%+v\n", result1)
    	return nil
    }

    func main() {
    	if err := run(); err != nil {
    		fmt.Fprintln(os.Stderr, err)
    		os.Exit(1)
    	}
    }
    ```
  </Tab>
</Tabs>

<span id="variables-and-escaping" />

## Variáveis e escape

Use `{{name}}` ou `{{ name }}` para uma variável simples. `template_data` é um objeto cujos valores são strings. O campo `variables` da resposta lista as variáveis detectadas. Valores ausentes são renderizados como strings vazias; valide os obrigatórios na sua aplicação antes de enviar. Corpos HTML escapam os valores inseridos; assuntos e corpos de texto são texto simples.

Envie `POST /v1/sent-messages` com conteúdo de template:

```json theme={null}
{
  "identity": "example.com",
  "from": "updates@example.com",
  "to": ["reader@example.net"],
  "content": {
    "template": "report-ready",
    "template_data": {"name": "Alex"}
  }
}
```

A identidade e o template aceitam UUIDs, nomes ou CRNs. Enviar exige `email:SendMessage` na identidade e `email:SendTemplatedMessage` no template. `configuration_set` pode aplicar rastreamento, seleção de pool e exceções de supressão. O template é renderizado antes de enfileirar; edições posteriores não alteram mensagens aceitas.

<span id="batch-sends" />

## Envios em lote

`POST /v1/sent-messages/batch` aceita um array `messages` com até 50 solicitações comuns de envio. Cada entrada pode usar texto/HTML, MIME bruto ou conteúdo de template. Informe `template_data` personalizado em cada entrada.

Permissões de identidade e template são verificadas em todas as entradas antes de qualquer mensagem ser enfileirada. Restrições de envio e falhas de renderização, supressão, armazenamento e cotas geram resultados individuais. Os resultados preservam a ordem de entrada; `index` identifica a entrada e `status` é `queued` ou `rejected`. Resultados aceitos incluem um ResourceRef `message`. Resultados rejeitados incluem o objeto padrão `error` com `code`, `message` e `request_id`. Enfileirada não significa entregue.

Verifique todos os resultados mesmo quando a solicitação HTTP for bem-sucedida. Preserve a Idempotency-Key original para novas tentativas de transporte do mesmo lote. Repita somente as entradas rejeitadas como uma nova solicitação depois de corrigir seus erros; uma nova chave para o lote inteiro pode duplicar mensagens já aceitas.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.