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

# Publicando mensagens

> Publique notificações com atributos, escolha conteúdo por protocolo e acompanhe a distribuição.

Publique após criar assinaturas. A resposta confirma aceitação para distribuição assíncrona; não garante recebimento ou processamento pelo destinatário.

<span id="publish-a-notification" />

## Publicar uma notificação

<Tabs>
  <Tab title="Console">
    Abra o tópico e selecione **Publish**. Informe mensagem e, opcionalmente, assunto e atributos. Após publicar, o console abre a mensagem. Use **Messages** e **Deliveries** no tópico para retornar.
  </Tab>

  <Tab title="API">
    ```http theme={null}
    POST /v1/topics/{topic_id}/publish
    Content-Type: application/json
    ```

    ```json theme={null}
    {
      "subject": "Order paid",
      "message": "{\"order_id\":\"A-1001\",\"amount\":149.50}",
      "attributes": {
        "event": { "type": "String", "value": "order.paid" },
        "environment": { "type": "String", "value": "production" },
        "amount": { "type": "Number", "value": "149.50" }
      }
    }
    ```

    HTTP `202` retorna `{"message_id": "..."}`. Salve o ID para consultar `/v1/topics/{topic_id}/messages/{message_id}`. A listagem usa `/v1/topics/{topic_id}/messages` com paginação por marcador.
  </Tab>

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

    ```bash theme={null}
    basaltic notifications topic publish "$TOPIC_ID" --from-file request-1.json
    ```
  </Tab>

  <Tab title="Go">
    Salve a solicitação JSON da aba API como `request-1.json`. Defina `TOPIC_ID` com o UUID do recurso. 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/notifications"
    )

    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 := notifications.New(cfg)
    	var request1 notifications.PublishRequest
    	if err := readJSON("request-1.json", &request1); err != nil {
    		return err
    	}
    	result1, err := client.Publish(ctx, os.Getenv("TOPIC_ID"), &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="payloads-and-attributes" />

## Conteúdo e atributos

`message` é uma string não vazia de até 256 KiB. Conteúdo JSON deve ser codificado como string nesse campo. O assunto opcional tem até 100 bytes, sem quebras de linha. Atributos são um mapa separado usado na [filtragem de assinaturas](/pt/notifications/filter-policies).

Por padrão, todos os protocolos usam a mesma mensagem. Para conteúdos distintos, defina `message_structure` como `json` e codifique um objeto de strings em `message`. Um valor `default` é obrigatório:

```json theme={null}
{
  "message_structure": "json",
  "message": "{\"default\":\"Order A-1001 paid\",\"email\":\"Your order A-1001 is paid.\",\"https\":\"{\\\"order_id\\\":\\\"A-1001\\\"}\"}"
}
```

Cada assinatura escolhe a chave do protocolo ou `default` quando ela não existe. Isso não altera filtros, que continuam comparando os atributos da publicação.

<span id="batch-publishing" />

## Publicação em lote

A operação em lote aceita 1–10 entradas com IDs próprios exclusivos. A resposta separa sucessos e falhas. Verifique cada resultado; sucesso HTTP não prova aceitação de tudo. Repita somente as entradas desejadas; uma nova publicação aceita recebe outro ID.

<span id="follow-delivery" />

## Acompanhar a entrega

A distribuição passa por `pending`, `complete` ou `failed`. Concluir com zero entregas pode ser válido: não há assinaturas confirmadas ou todos os filtros rejeitam os atributos.

Registros mostram referência da assinatura, resultado, tentativas e último erro. A listagem no tópico aceita UUID ou CRN em `message` para restringir. Siga os marcadores para obter todas as páginas. **Metrics** mostra tendências via Telemetry; use registros para falhas individuais.

Consumidores de webhook e fila devem tolerar repetições. Sucesso de webhook significa resposta HTTP bem-sucedida; sucesso de fila significa enfileiramento, não processamento pelo consumidor. Veja [comportamento de entrega](/pt/notifications/delivery).


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