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

# Plantillas de correo

> Cree plantillas de texto y HTML y envíe mensajes personalizados a uno o varios destinos.

Las plantillas almacenan asunto y cuerpo con variables. Los nombres son inmutables y únicos en la cuenta. `body_type` es `text` o `html`.

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

## Crear una plantilla

<Tabs>
  <Tab title="Console">
    Abra Email, después **Templates**, y haga clic en **Create template**. Introduzca las plantillas de asunto y cuerpo y elija el tipo de cuerpo. Abra la plantilla guardada para editarla o enviar un mensaje de prueba.
  </Tab>

  <Tab title="API">
    Envíe `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 actualizar el contenido. El nombre no cambia. Se conservan el asunto, cuerpo y tipo omitidos. Un `subject_template` vacío borra el asunto; el cuerpo debe seguir sin estar vacío.
  </Tab>

  <Tab title="CLI">
    Guarde la solicitud JSON de la pestaña API como `request-1.json`. Use su cuenta y región configuradas.

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

  <Tab title="Go">
    Guarde la solicitud JSON de la pestaña API como `request-1.json`. Configure credenciales, cuenta y región mediante las variables de entorno del 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" />

## Variables y escape

Use `{{name}}` o `{{ name }}` para una variable simple. `template_data` es un objeto cuyos valores son cadenas. El campo `variables` de la respuesta lista las variables detectadas. Los valores ausentes se renderizan como cadenas vacías; valide los obligatorios en su aplicación antes de enviar. Los cuerpos HTML escapan los valores insertados; los asuntos y cuerpos de texto son texto sin formato.

Envíe `POST /v1/sent-messages` con contenido de plantilla:

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

La identidad y la plantilla aceptan UUID, nombres o CRN. Enviar requiere `email:SendMessage` sobre la identidad y `email:SendTemplatedMessage` sobre la plantilla. `configuration_set` puede aplicar seguimiento, selección de grupo y excepciones de supresión. La plantilla se renderiza antes de encolar; las ediciones posteriores no cambian los mensajes aceptados.

<span id="batch-sends" />

## Envíos por lotes

`POST /v1/sent-messages/batch` acepta un array `messages` con hasta 50 solicitudes de envío normales. Cada entrada puede usar texto/HTML, MIME sin procesar o contenido de plantilla. Proporcione `template_data` personalizado en cada entrada.

Los permisos de identidad y plantilla se comprueban para todas las entradas antes de encolar cualquier mensaje. Las restricciones de envío y los fallos de renderizado, supresión, almacenamiento y cuotas generan resultados individuales. Los resultados conservan el orden de entrada; `index` identifica la entrada y `status` es `queued` o `rejected`. Los resultados aceptados incluyen un ResourceRef `message`. Los rechazados incluyen el objeto estándar `error` con `code`, `message` y `request_id`. Encolado no significa entregado.

Compruebe todos los resultados aunque la solicitud HTTP tenga éxito. Conserve la Idempotency-Key original para reintentos de transporte del mismo lote. Reintente solo las entradas rechazadas como una nueva solicitud tras corregir sus errores; una clave nueva para el lote completo puede duplicar mensajes ya aceptados.


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