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

# Enrow com Make

> Crie fluxos de trabalho visuais sem código que encontram e verificam e-mails com a API da Enrow no Make (antigo Integromat)

O Make (antigo Integromat) é uma plataforma de automação visual que permite criar fluxos de trabalho Enrow sem código com uma interface de arrastar e soltar. Este guia mostra como chamar a API da Enrow a partir de um cenário no Make, receber resultados por meio de um webhook e ramificar conforme o resultado — sem necessidade de servidor. Autentique cada requisição com sua [chave de API](/pt/authentication) no cabeçalho `x-api-key`.

## O que é o Make?

O Make é uma plataforma de automação visual que conecta aplicativos e APIs por meio de cenários — sequências de módulos que rodam quando um gatilho é disparado. Com o módulo HTTP você pode chamar qualquer endpoint da Enrow e, em seguida, encaminhar a resposta para o Google Sheets, um CRM ou uma notificação sem escrever código. Para uma alternativa gerenciada, a Enrow também oferece [integrações nativas com CRM](/pt/integrations/overview).

## Como chamo a API da Enrow a partir do Make?

Crie um cenário com um gatilho, um módulo HTTP que chama a Enrow e um webhook que captura o resultado assíncrono. Siga estes passos.

### Passo 1: Crie um cenário

1. Acesse [Make.com](https://make.com)
2. Clique em **"Create a new scenario"**
3. Nomeie como "Enrow Email Finder"

### Passo 2: Adicione um gatilho

Escolha o que inicia o cenário:

* **Google Sheets**: Monitore linhas
* **Webhooks**: Webhook personalizado
* **Schedule**: Execute a cada hora
* **Watch for changes**: No seu CRM

### Passo 3: Adicione o módulo HTTP para a Enrow

1. Clique em **"+"** para adicionar um módulo
2. Pesquise por **"HTTP"**
3. Escolha **"Make a request"**

### Passo 4: Configure a chamada à API da Enrow

Aponte o módulo HTTP para o endpoint [Find Single Email](/pt/api-reference/email-finder/find-single) e passe sua chave de API nos cabeçalhos.

**URL:**

```
https://api.enrow.io/email/find/single
```

**Método:** POST

**Cabeçalhos:**

```
Content-Type: application/json
x-api-key: YOUR_ENROW_API_KEY
```

**Corpo (JSON):**

```json theme={null}
{
  "company_domain": "{{1.company_domain}}",
  "fullname": "{{1.first_name}} {{1.last_name}}"
}
```

### Passo 5: Adicione um webhook para os resultados

A Enrow processa as buscas de forma assíncrona e notifica um webhook quando cada busca é concluída. Consulte [Como funcionam os Webhooks](/pt/how-webhooks-work) para o formato do payload.

1. Adicione um módulo **"Webhooks"** como um novo gatilho
2. Escolha **"Custom webhook"**
3. Copie a URL do webhook
4. Volte ao módulo HTTP
5. Atualize o corpo JSON para incluir o webhook:

```json theme={null}
{
  "company_domain": "{{1.company_domain}}",
  "fullname": "{{1.first_name}} {{1.last_name}}",
  "settings": {
    "webhook": "YOUR_MAKE_WEBHOOK_URL"
  }
}
```

### Passo 6: Processe os resultados

Depois que o webhook recebe os resultados:

1. Adicione um módulo **"Router"** para ramificar a lógica
2. Ramificação 1: Salvar no Google Sheets
3. Ramificação 2: Atualizar o CRM
4. Ramificação 3: Enviar notificação

## Quais cenários posso criar?

Os cenários comuns da Enrow combinam um gatilho, o módulo HTTP e o webhook com aplicativos posteriores. Aqui estão três padrões para começar.

### Cenário 1: Enriquecer o Google Sheets

```
Google Sheets (Watch rows)
  → HTTP (Find email with Enrow)
  → Webhook (Receive results)
  → Google Sheets (Update row)
```

### Cenário 2: Verificar e adicionar ao Mailchimp

```
Typeform (Watch responses)
  → HTTP (Verify email)
  → Filter (Only valid emails)
  → Mailchimp (Add subscriber)
```

### Cenário 3: Processamento em massa

```
Schedule (Every hour)
  → Google Sheets (Get rows without emails)
  → Array aggregator (Batch 100 rows)
  → HTTP (Bulk find emails)
  → Webhook (Receive results)
  → Iterator (Process each result)
  → Google Sheets (Update row)
```

## Por que usar o Make com a Enrow?

O Make oferece um construtor visual, tratamento de erros embutido e execução paralela — útil quando um fluxo de trabalho Enrow precisa se distribuir entre vários aplicativos.

<AccordionGroup>
  <Accordion title="Construtor visual de fluxos de trabalho">
    Veja todo o seu fluxo de automação de forma visual. Ideal para lógicas complexas.
  </Accordion>

  <Accordion title="Tratamento de erros">
    Tratamento de erros e mecanismos de repetição embutidos.
  </Accordion>

  <Accordion title="Transformação de dados">
    Funções e ferramentas poderosas para transformar dados entre etapas.
  </Accordion>

  <Accordion title="Execução paralela">
    Execute múltiplos caminhos simultaneamente com o módulo Router.
  </Accordion>
</AccordionGroup>

## Como crio cenários eficientes no Make?

Processe os resultados da Enrow em lotes, adicione tratadores de erro e armazene resultados em cache para evitar chamadas redundantes. Os padrões abaixo mantêm os cenários rápidos e dentro tanto das operações do Make quanto dos seus [créditos](/pt/credits-billing) da Enrow.

### Use o módulo Iterator

Processe resultados em massa um a um:

```
HTTP (Bulk find)
  → Webhook (Receive batch results)
  → Iterator (Loop through results)
  → Google Sheets (Update each row)
```

### Adicione tratadores de erro

1. Clique com o botão direito em qualquer módulo
2. Adicione **"Error handler"**
3. Configure o que acontece em caso de erro (registrar, e-mail, repetir)

### Use Data Stores

Armazene resultados em cache para evitar chamadas redundantes à API:

```
Router
  → Path 1: Check data store for cached email
  → Path 2: If not found, call Enrow API → Save to data store
```

## Como processo operações em massa?

Agregue linhas em lotes e chame o endpoint [Find Bulk Emails](/pt/api-reference/email-finder/find-bulk) (até 5.000 buscas por lote) e, em seguida, itere sobre os resultados do webhook. Isso processa 1.000 contatos em um punhado de operações, em vez de uma por contato.

```
Google Sheets (Get all rows)
  → Array aggregator (Batch size: 100)
  → HTTP (POST /email/find/bulk)
  → Webhook (Receive bulk results)
  → Iterator (Loop results)
  → Router
    → Path 1 (Valid): Update sheet with email
    → Path 2 (Invalid): Log to error sheet
```

## De quais módulos do Make preciso para a Enrow?

Estes são os módulos que aparecem na maioria dos cenários da Enrow:

| Module               | Caso de uso                          |
| -------------------- | ------------------------------------ |
| **HTTP**             | Chamar a API da Enrow                |
| **Webhooks**         | Receber resultados assíncronos       |
| **Iterator**         | Processar resultados em massa        |
| **Router**           | Ramificar a lógica (válido/inválido) |
| **Filter**           | Pular resultados de baixa confiança  |
| **Data Store**       | Armazenar resultados em cache        |
| **Array Aggregator** | Criar lotes                          |

## Como mantenho baixo o uso de operações?

O Make cobra por operação, então prefira endpoints em massa, armazene resultados em cache em data stores e filtre cedo para pular etapas desnecessárias. Uma única requisição em massa conta como muito menos operações do que muitas requisições individuais.

**Exemplo:**

* ❌ Ruim: 1000 requisições individuais = 1000 operações
* ✅ Bom: 10 requisições em massa (100 cada) = 10 operações

## FAQ

<AccordionGroup>
  <Accordion title="Por que meu webhook não está recebendo dados?">
    Verifique se o cenário está ativo (ON), confira se a URL do webhook no campo `settings.webhook` da Enrow corresponde exatamente à que o Make gerou e teste o endpoint primeiro com uma ferramenta como o Postman. Consulte [Como funcionam os Webhooks](/pt/how-webhooks-work) para o formato do payload.
  </Accordion>

  <Accordion title="Meu cenário atingiu o limite de operações — o que devo fazer?">
    Troque chamadas individuais pelo endpoint [Find Bulk Emails](/pt/api-reference/email-finder/find-bulk), armazene em cache os dados acessados com frequência em um Data Store e atualize seu plano do Make se ainda precisar de mais operações.
  </Accordion>

  <Accordion title="Meu cenário está expirando — como corrijo?">
    Divida um cenário grande em outros menores, use gatilhos agendados em vez de instantâneos e reduza o tamanho dos lotes. Como as buscas da Enrow são assíncronas, deixe o webhook entregar os resultados em vez de aguardar dentro do módulo HTTP.
  </Accordion>

  <Accordion title="Qual endpoint da Enrow o módulo HTTP deve chamar?">
    Use [Find Single Email](/pt/api-reference/email-finder/find-single) ou [Verify Single Email](/pt/api-reference/email-verifier/verify-single) para trabalho por linha, e o endpoint [Find Bulk Emails](/pt/api-reference/email-finder/find-bulk) ao agregar muitas linhas. Todos eles se autenticam com o mesmo cabeçalho `x-api-key`.
  </Accordion>
</AccordionGroup>

## Próximos passos

<CardGroup cols={2}>
  <Card title="Find Single Email" icon="envelope" href="/pt/api-reference/email-finder/find-single">
    Chame o endpoint que seu módulo HTTP usará para encontrar um e-mail.
  </Card>

  <Card title="Encontrar e-mails em massa" icon="layer-group" href="/pt/api-reference/email-finder/find-bulk">
    Execute até 5.000 buscas de e-mail em uma única requisição.
  </Card>

  <Card title="Como funcionam os Webhooks" icon="bell" href="/pt/how-webhooks-work">
    Entenda o payload de resultado assíncrono que o Make recebe.
  </Card>

  <Card title="Fluxos de trabalho n8n" icon="diagram-project" href="/pt/playbooks/n8n/getting-started">
    Crie a mesma automação em uma alternativa auto-hospedada.
  </Card>
</CardGroup>