---
title: "Integração com Home Assistant - Alertas de casa inteligente"
sidebarTitle: Home Assistant
description: "Conecte o Home Assistant ao Echobell para alertas instantâneos de casa inteligente: segurança, movimento, temperatura e eventos de automação como notificações push ou chamadas telefônicas."
---

import { Step, Steps } from "fumadocs-ui/components/steps";

# Integração com Home Assistant

O [Home Assistant](https://www.home-assistant.io/) é uma poderosa plataforma de automação residencial de código aberto que coloca o controle local e a privacidade em primeiro lugar. Ao integrar o Echobell com o Home Assistant, você pode receber notificações instantâneas e até chamadas telefônicas quando eventos importantes acontecem na sua casa inteligente — seja um alerta de segurança, uma temperatura acima do limite ou um gatilho de automação.

Este guia mostra como configurar o Echobell para receber notificações das suas automações do Home Assistant usando webhooks ou o serviço RESTful Notify.

## Pré-requisitos

Antes de começar, verifique se você tem:

- O [app Echobell](https://apps.apple.com/app/apple-store/id6743597198?pt=128151925&ct=docs-developer-home-assistant-pt&mt=8) / [Google Play](https://play.google.com/store/apps/details?id=one.echobell.echobellandroid) instalado no seu dispositivo móvel
- Um canal ativo no Echobell (crie um no app, caso ainda não tenha)
- Uma instância do Home Assistant em execução (versão 2023.1 ou mais recente é recomendada)
- Acesso à configuração do seu Home Assistant

## Método 1: usando gatilhos de webhook (recomendado)

O método por webhook é a abordagem mais flexível, permitindo enviar dados personalizados e usar [variáveis de modelo](/docs/template) nas suas notificações.

<Steps>
<Step>
### Obtenha a URL do webhook do Echobell

1. Abra o app Echobell e vá até o seu canal
2. Toque no canal para ver os detalhes
3. Encontre a **URL do Webhook** na seção "Triggers"
4. Copie a URL — ela terá este formato: `https://hook.echobell.one/t/<channel-token>`
</Step>
<Step>

### Crie uma automação no Home Assistant

No Home Assistant, você pode acionar notificações do Echobell usando o serviço `rest_command`. Primeiro, adicione o comando REST ao seu `configuration.yaml`:

```yaml
rest_command:
  echobell_notify:
    url: "https://hook.echobell.one/t/<channel-token>"
    method: POST
    content_type: "application/json"
    payload: '{"title": "{{ title }}", "message": "{{ message }}"}'
```

Substitua `YOUR_TOKEN` pelo token real do seu webhook do Echobell.

Depois de adicionar isso, reinicie o Home Assistant para carregar a nova configuração.

</Step>
<Step>
### Use em automações

Agora você pode chamar esse serviço a partir de qualquer automação. Veja um exemplo que notifica você quando uma porta é aberta:

```yaml
automation:
  - alias: "Door Open Alert"
    trigger:
      - platform: state
        entity_id: binary_sensor.front_door
        to: "on"
    action:
      - service: rest_command.echobell_notify
        data:
          title: "Security Alert"
          message: "Front door opened at {{ now().strftime('%H:%M') }}"
```

</Step>
<Step>
### Configure os modelos de notificação

Nas configurações do seu canal do Echobell, configure os modelos de notificação para exibir os dados do webhook:

- **Modelo de título**: `{{title}}`
- **Modelo de corpo**: `{{message}}`

Agora, quando a automação for acionada, você receberá uma notificação com o título e a mensagem personalizados.

</Step>
</Steps>

## Método 2: usando a plataforma RESTful Notify

Para uma abordagem mais integrada, você pode configurar o Echobell como um serviço de notificação no Home Assistant.

### Configuração

Adicione o seguinte ao seu `configuration.yaml`:

```yaml
notify:
  - name: echobell
    platform: rest
    resource: https://hook.echobell.one/t/<channel-token>
    method: POST_JSON
    data:
      title: "{{ title }}"
      message: "{{ message }}"
```

Substitua `YOUR_TOKEN` pelo token do seu webhook do Echobell e reinicie o Home Assistant.

### Usando o serviço de notificação

Agora você pode usar o Echobell como qualquer outro serviço de notificação:

```yaml
automation:
  - alias: "Low Battery Alert"
    trigger:
      - platform: numeric_state
        entity_id: sensor.phone_battery
        below: 20
    action:
      - service: notify.echobell
        data:
          title: "Low Battery Warning"
          message: "Phone battery is at {{ states('sensor.phone_battery') }}%"
```

## Casos de uso avançados

### Monitoramento de temperatura com alertas críticos

Use os [tipos de notificação](/docs/notification) para enviar alertas críticos de temperatura como chamadas:

```yaml
rest_command:
  echobell_critical:
    url: "https://hook.echobell.one/t/<channel-token>"
    method: POST
    content_type: "application/json"
    payload: '{"temperature": "{{ temperature }}", "location": "{{ location }}", "severity": "critical"}'
```

No seu canal do Echobell, defina o [tipo de notificação](/docs/notification) como "Chamada" e use este modelo:

- **Título**: `Critical Temperature Alert`
- **Corpo**: `{{location}} temperature is {{temperature}}°C - Immediate attention required!`

### Integração com sistema de segurança

Configure um monitoramento de segurança completo:

```yaml
automation:
  - alias: "Security Breach Detection"
    trigger:
      - platform: state
        entity_id:
          - binary_sensor.motion_detector_1
          - binary_sensor.motion_detector_2
          - binary_sensor.window_sensor
        to: "on"
    condition:
      - condition: state
        entity_id: alarm_control_panel.home_alarm
        state: "armed_away"
    action:
      - service: rest_command.echobell_notify
        data:
          title: "🚨 Security Alert"
          message: "{{ trigger.to_state.attributes.friendly_name }} detected activity while system armed"
          sensor: "{{ trigger.entity_id }}"
          timestamp: "{{ now().isoformat() }}"
```

### Notificações de eletrodomésticos inteligentes

Monitore os ciclos dos eletrodomésticos e seja avisado quando eles terminarem:

```yaml
automation:
  - alias: "Washing Machine Complete"
    trigger:
      - platform: state
        entity_id: sensor.washing_machine_power
        to: "0"
        for:
          minutes: 3
    action:
      - service: notify.echobell
        data:
          title: "Washing Machine Done"
          message: "Your laundry is ready to be moved to the dryer"
```

### Monitoramento ambiental

Acompanhe a qualidade do ar, a umidade ou outros fatores ambientais:

```yaml
automation:
  - alias: "High CO2 Alert"
    trigger:
      - platform: numeric_state
        entity_id: sensor.living_room_co2
        above: 1000
    action:
      - service: rest_command.echobell_notify
        data:
          title: "Air Quality Warning"
          message: "CO2 level in living room is {{ states('sensor.living_room_co2') }} ppm. Consider ventilating."
```

## Usando condições para filtragem inteligente

Você pode usar as [condições do Echobell](/docs/conditions) para filtrar notificações com base em critérios específicos. Por exemplo, notificar apenas em determinados horários ou quando os valores ultrapassarem um limite:

Defina uma condição no seu canal do Echobell:

```
severity == "critical" || (hour >= 22 || hour <= 7)
```

Isso só envia notificações se a severidade for crítica OU se for de madrugada (das 22h às 7h).

Na sua automação do Home Assistant, inclua os dados relevantes:

```yaml
action:
  - service: rest_command.echobell_notify
    data:
      title: "Temperature Alert"
      message: "Freezer temperature: {{ states('sensor.freezer_temp') }}°C"
      severity: "{% if states('sensor.freezer_temp') | float > -10 %}critical{% else %}normal{% endif %}"
      hour: "{{ now().hour }}"
```

## Enviando dados de sensores

Você pode enviar quaisquer dados de sensores do Home Assistant para as suas notificações do Echobell:

```yaml
rest_command:
  echobell_sensor_update:
    url: "https://hook.echobell.one/t/<channel-token>"
    method: POST
    content_type: "application/json"
    payload: >
      {
        "sensor_name": "{{ sensor_name }}",
        "current_value": "{{ current_value }}",
        "unit": "{{ unit }}",
        "state": "{{ state }}",
        "timestamp": "{{ timestamp }}"
      }
```

## Trabalhando com cabeçalhos HTTP

O Echobell consegue acessar os cabeçalhos HTTP das requisições de webhook. Isso é útil para autenticação ou rastreamento:

```yaml
rest_command:
  echobell_with_headers:
    url: "https://hook.echobell.one/t/<channel-token>"
    method: POST
    headers:
      X-Home-Assistant-Instance: "{{ instance_name }}"
      X-Automation-ID: "{{ automation_id }}"
    content_type: "application/json"
    payload: '{"message": "{{ message }}"}'
```

No seu modelo do Echobell, acesse os cabeçalhos com:

```
{{header["x-home-assistant-instance"]}}
```

## Depuração e testes

### Teste o seu webhook

Use as Ferramentas do Desenvolvedor → Serviços do Home Assistant para testar a sua configuração:

1. Selecione `rest_command.echobell_notify`
2. Informe os dados de teste:

```yaml
title: "Test Notification"
message: "This is a test from Home Assistant"
```

3. Clique em "Chamar serviço"
4. Verifique a notificação no seu app Echobell

### Verifique os logs do Home Assistant

Se as notificações não estiverem chegando, verifique os logs do Home Assistant:

```bash
# In Home Assistant, go to:
Settings → System → Logs

# Or check the log file:
config/home-assistant.log
```

Procure erros relacionados a `rest_command` ou a requisições HTTP para `hook.echobell.one`.

### Verifique a URL do webhook

Confirme se a URL do seu webhook está correta:

- Ela deve começar com `https://hook.echobell.one/t/`
- O token deve estar incluído
- Sem espaços ou caracteres extras

## Considerações de desempenho

### Limitação de taxa

Os webhooks do Echobell estão sujeitos a limitação de taxa para evitar abusos. Para sensores de alta frequência:

- Evite acionar a cada atualização do sensor
- Use `for` nos gatilhos para aplicar um debounce:

```yaml
trigger:
  - platform: numeric_state
    entity_id: sensor.temperature
    above: 30
    for:
      minutes: 5 # Only trigger after 5 minutes above threshold
```

### Agrupamento de atualizações

Para vários eventos relacionados, considere agrupá-los em uma única notificação:

```yaml
automation:
  - alias: "Daily Home Summary"
    trigger:
      - platform: time
        at: "09:00:00"
    action:
      - service: rest_command.echobell_notify
        data:
          title: "Morning Home Summary"
          message: >
            Temperature: {{ states('sensor.temperature') }}°C
            Humidity: {{ states('sensor.humidity') }}%
            Energy today: {{ states('sensor.daily_energy') }} kWh
            Windows open: {{ expand(states.binary_sensor) | selectattr('state', 'eq', 'on') | selectattr('attributes.device_class', 'eq', 'window') | list | count }}
```

## Boas práticas de segurança

### Proteja a URL do seu webhook

- Nunca envie URLs de webhook para repositórios públicos
- Use os secrets do Home Assistant para dados sensíveis
- Troque os tokens dos webhooks periodicamente

Usando secrets no `configuration.yaml`:

```yaml
# secrets.yaml
echobell_webhook: "https://hook.echobell.one/t/<channel-token>"

# configuration.yaml
rest_command:
  echobell_notify:
    url: !secret echobell_webhook
    method: POST
    content_type: "application/json"
    payload: '{"title": "{{ title }}", "message": "{{ message }}"}'
```

### Limite as informações sensíveis

Tenha cuidado com os dados que você inclui nas notificações:

```yaml
# Good - General information
message: "Motion detected in living room"

# Avoid - Sensitive details
message: "Security code: 1234, camera feed: http://..."
```

## Solução de problemas comuns

### As notificações não chegam

1. **Verifique a conectividade de rede**: confirme que a sua instância do Home Assistant consegue acessar a internet
2. **Confira a URL do webhook**: copie e cole com atenção, incluindo o token
3. **Verifique o app Echobell**: confirme que você está inscrito no canal
4. **Revise os logs do Home Assistant**: procure erros HTTP ou tempos limite esgotados

### Erros de modelo

Se os modelos não estiverem sendo renderizados corretamente:

1. Teste os modelos em Ferramentas do Desenvolvedor → Modelo
2. Confirme que os nomes das variáveis são iguais no Home Assistant e no Echobell
3. Procure erros de digitação na sintaxe do modelo: `{{variable}}` e não `{{ variable}}`

### A automação não é acionada

1. Confira as condições do gatilho no Home Assistant
2. Teste a automação manualmente pelas Ferramentas do Desenvolvedor
3. Verifique se os estados das entidades correspondem à configuração do seu gatilho
4. Revise os traces da automação para depurar

## Exemplo: configuração completa de um sistema de segurança

Veja um exemplo completo integrando vários sensores de segurança:

```yaml
# configuration.yaml
rest_command:
  echobell_security:
    url: !secret echobell_security_webhook
    method: POST
    content_type: "application/json"
    payload: >
      {
        "event_type": "{{ event_type }}",
        "location": "{{ location }}",
        "sensor": "{{ sensor }}",
        "timestamp": "{{ timestamp }}",
        "alarm_state": "{{ alarm_state }}"
      }

# automations.yaml
- alias: "Security Event Handler"
  trigger:
    - platform: state
      entity_id:
        - binary_sensor.front_door
        - binary_sensor.back_door
        - binary_sensor.garage_door
        - binary_sensor.motion_hallway
        - binary_sensor.motion_living_room
      to: "on"
  action:
    - service: rest_command.echobell_security
      data:
        event_type: "{{ 'door' if 'door' in trigger.entity_id else 'motion' }}"
        location: "{{ trigger.to_state.attributes.friendly_name }}"
        sensor: "{{ trigger.entity_id }}"
        timestamp: "{{ now().strftime('%Y-%m-%d %H:%M:%S') }}"
        alarm_state: "{{ states('alarm_control_panel.home_alarm') }}"
```

No Echobell, defina os seus modelos:

- **Título**: `Security Alert: {{event_type | upper}}`
- **Corpo**: `{{location}} activated at {{timestamp}} (Alarm: {{alarm_state}})`

## Próximos passos

Agora que você integrou o Echobell com o Home Assistant:

- Explore os [tipos de notificação](/docs/notification) para diferentes prioridades de alerta
- Aprenda sobre [condições](/docs/conditions) para filtrar notificações de forma inteligente
- Conheça as [variáveis de modelo](/docs/template) para formatar mensagens de forma avançada
- Leia sobre as [boas práticas de webhook](/docs/webhook) para uma integração ideal

## Recursos relacionados

- [Documentação do REST Command do Home Assistant](https://www.home-assistant.io/integrations/rest_command/)
- [Plataforma RESTful Notify do Home Assistant](https://www.home-assistant.io/integrations/notify.rest/)
- [Documentação do Webhook do Echobell](/docs/webhook)
- [Sistema de modelos do Echobell](/docs/template)