> ## 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 con Make

> Crea flujos de trabajo visuales sin código que encuentran y verifican correos electrónicos con la API de Enrow en Make (antes Integromat)

Make (antes Integromat) es una plataforma de automatización visual que te permite crear flujos de trabajo de Enrow sin código con una interfaz de arrastrar y soltar. Esta guía muestra cómo llamar a la API de Enrow desde un escenario de Make, recibir resultados a través de un webhook y ramificar según el resultado, sin necesidad de un servidor. Autentica cada solicitud con tu [clave de API](/es/authentication) en el encabezado `x-api-key`.

## ¿Qué es Make?

Make es una plataforma de automatización visual que conecta aplicaciones y APIs mediante escenarios: cadenas de módulos que se ejecutan cuando se activa un disparador. Con el módulo HTTP puedes llamar a cualquier endpoint de Enrow y luego enrutar la respuesta a Google Sheets, un CRM o una notificación sin escribir código. Como alternativa gestionada, Enrow también ofrece [integraciones nativas con CRM](/es/integrations/overview).

## ¿Cómo llamo a la API de Enrow desde Make?

Crea un escenario con un disparador, un módulo HTTP que llame a Enrow y un webhook que capture el resultado asíncrono. Sigue estos pasos.

### Paso 1: Crea un escenario

1. Ve a [Make.com](https://make.com)
2. Haz clic en **"Create a new scenario"**
3. Nómbralo "Enrow Email Finder"

### Paso 2: Añade un disparador

Elige qué inicia el escenario:

* **Google Sheets**: Vigilar filas
* **Webhooks**: Webhook personalizado
* **Schedule**: Ejecutar cada hora
* **Watch for changes**: En tu CRM

### Paso 3: Añade el módulo HTTP para Enrow

1. Haz clic en **"+"** para añadir un módulo
2. Busca **"HTTP"**
3. Elige **"Make a request"**

### Paso 4: Configura la llamada a la API de Enrow

Apunta el módulo HTTP al endpoint [Find Single Email](/es/api-reference/email-finder/find-single) y pasa tu clave de API en los encabezados.

**URL:**

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

**Método:** POST

**Encabezados:**

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

**Cuerpo (JSON):**

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

### Paso 5: Añade un webhook para los resultados

Enrow procesa las búsquedas de forma asíncrona y notifica a un webhook cuando finaliza cada búsqueda. Consulta [Cómo funcionan los webhooks](/es/how-webhooks-work) para conocer el formato del payload.

1. Añade un módulo **"Webhooks"** como nuevo disparador
2. Elige **"Custom webhook"**
3. Copia la URL del webhook
4. Vuelve al módulo HTTP
5. Actualiza el cuerpo JSON para incluir el webhook:

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

### Paso 6: Procesa los resultados

Después de que el webhook reciba los resultados:

1. Añade un módulo **"Router"** para ramificar la lógica
2. Rama 1: Guardar en Google Sheets
3. Rama 2: Actualizar el CRM
4. Rama 3: Enviar una notificación

## ¿Qué escenarios puedo crear?

Los escenarios habituales de Enrow combinan un disparador, el módulo HTTP y el webhook con aplicaciones posteriores. Aquí tienes tres patrones para empezar.

### Escenario 1: Enriquecer Google Sheets

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

### Escenario 2: Verificar y añadir a Mailchimp

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

### Escenario 3: Procesamiento masivo

```
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 qué usar Make para Enrow?

Make te ofrece un constructor visual, gestión de errores integrada y ejecución en paralelo, algo útil cuando un flujo de trabajo de Enrow tiene que distribuirse entre varias aplicaciones.

<AccordionGroup>
  <Accordion title="Constructor visual de flujos de trabajo">
    Visualiza todo tu flujo de automatización. Perfecto para lógica compleja.
  </Accordion>

  <Accordion title="Gestión de errores">
    Gestión de errores y mecanismos de reintento integrados.
  </Accordion>

  <Accordion title="Transformación de datos">
    Funciones y herramientas potentes para transformar datos entre pasos.
  </Accordion>

  <Accordion title="Ejecución en paralelo">
    Ejecuta varias rutas simultáneamente con el módulo Router.
  </Accordion>
</AccordionGroup>

## ¿Cómo creo escenarios de Make eficientes?

Procesa los resultados de Enrow por lotes, añade gestores de errores y almacena los resultados en caché para evitar llamadas redundantes. Los patrones siguientes mantienen los escenarios rápidos y dentro tanto de tus operaciones de Make como de tus [créditos](/es/credits-billing) de Enrow.

### Usa el módulo Iterator

Procesa los resultados masivos uno a uno:

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

### Añade gestores de errores

1. Haz clic derecho en cualquier módulo
2. Añade **"Error handler"**
3. Configura qué ocurre cuando hay un error (registrar, enviar correo, reintentar)

### Usa Data Stores

Almacena los resultados en caché para evitar llamadas redundantes a la API:

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

## ¿Cómo proceso operaciones masivas?

Agrega filas en lotes y llama al endpoint [Find Bulk Emails](/es/api-reference/email-finder/find-bulk) (hasta 5000 búsquedas por lote) y luego itera sobre los resultados del webhook. Así se procesan 1000 contactos en unas pocas operaciones en lugar de una por contacto.

```
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
```

## ¿Qué módulos de Make necesito para Enrow?

Estos son los módulos que aparecen en la mayoría de los escenarios de Enrow:

| Módulo               | Caso de uso                            |
| -------------------- | -------------------------------------- |
| **HTTP**             | Llamar a la API de Enrow               |
| **Webhooks**         | Recibir resultados asíncronos          |
| **Iterator**         | Procesar resultados masivos            |
| **Router**           | Ramificar la lógica (válido/no válido) |
| **Filter**           | Omitir resultados de baja confianza    |
| **Data Store**       | Almacenar resultados en caché          |
| **Array Aggregator** | Crear lotes                            |

## ¿Cómo mantengo bajo el uso de operaciones?

Make cobra por operación, así que prioriza los endpoints masivos, almacena los resultados en data stores y filtra pronto para omitir pasos innecesarios. Una sola solicitud masiva cuenta como muchas menos operaciones que muchas solicitudes individuales.

**Ejemplo:**

* ❌ Mal: 1000 solicitudes individuales = 1000 operaciones
* ✅ Bien: 10 solicitudes masivas (100 cada una) = 10 operaciones

## FAQ

<AccordionGroup>
  <Accordion title="¿Por qué mi webhook no recibe datos?">
    Verifica que el escenario esté activo (ON), comprueba que la URL del webhook en el campo `settings.webhook` de Enrow coincida exactamente con la que generó Make y prueba primero el endpoint con una herramienta como Postman. Consulta [Cómo funcionan los webhooks](/es/how-webhooks-work) para conocer el formato del payload.
  </Accordion>

  <Accordion title="Mi escenario alcanzó el límite de operaciones, ¿qué debo hacer?">
    Cambia las llamadas individuales al endpoint [Find Bulk Emails](/es/api-reference/email-finder/find-bulk), almacena en caché los datos de acceso frecuente en un Data Store y mejora tu plan de Make si aún necesitas más operaciones.
  </Accordion>

  <Accordion title="Mi escenario está agotando el tiempo de espera, ¿cómo lo soluciono?">
    Divide un escenario grande en otros más pequeños, usa disparadores programados en lugar de instantáneos y reduce los tamaños de lote. Como las búsquedas de Enrow son asíncronas, deja que el webhook entregue los resultados en lugar de esperar dentro del módulo HTTP.
  </Accordion>

  <Accordion title="¿A qué endpoint de Enrow debe llamar el módulo HTTP?">
    Usa [Find Single Email](/es/api-reference/email-finder/find-single) o [Verify Single Email](/es/api-reference/email-verifier/verify-single) para el trabajo por filas, y el endpoint [Find Bulk Emails](/es/api-reference/email-finder/find-bulk) al agregar muchas filas. Todos se autentican con el mismo encabezado `x-api-key`.
  </Accordion>
</AccordionGroup>

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Buscar correo" icon="envelope" href="/es/api-reference/email-finder/find-single">
    Llama al endpoint que usará tu módulo HTTP para encontrar un correo electrónico.
  </Card>

  <Card title="Buscar correos en masa" icon="layer-group" href="/es/api-reference/email-finder/find-bulk">
    Ejecuta hasta 5000 búsquedas de correo en una sola solicitud.
  </Card>

  <Card title="Cómo funcionan los webhooks" icon="bell" href="/es/how-webhooks-work">
    Comprende el payload de resultados asíncronos que recibe Make.
  </Card>

  <Card title="Flujos de trabajo de n8n" icon="diagram-project" href="/es/playbooks/n8n/getting-started">
    Crea la misma automatización en una alternativa autoalojada.
  </Card>
</CardGroup>