> ## 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 workflow visuali no-code che trovano e verificano le email con l'API di Enrow in Make (precedentemente Integromat)

Make (precedentemente Integromat) è una piattaforma di automazione visuale che ti permette di creare workflow Enrow no-code con un'interfaccia drag-and-drop. Questa guida mostra come chiamare l'API di Enrow da uno scenario Make, ricevere i risultati tramite un webhook e creare ramificazioni in base all'esito — senza alcun server. Autentica ogni richiesta con la tua [chiave API](/it/authentication) nell'header `x-api-key`.

## Cos'è Make?

Make è una piattaforma di automazione visuale che collega app e API tramite scenari — catene di moduli che si avviano quando scatta un trigger. Con il modulo HTTP puoi chiamare qualsiasi endpoint Enrow, quindi instradare la risposta verso Google Sheets, un CRM o una notifica senza scrivere codice. Per un'alternativa gestita, Enrow offre anche [integrazioni CRM native](/it/integrations/overview).

## Come chiamo l'API di Enrow da Make?

Crea uno scenario con un trigger, un modulo HTTP che chiama Enrow e un webhook che cattura il risultato asincrono. Segui questi passaggi.

### Passaggio 1: Crea uno scenario

1. Vai su [Make.com](https://make.com)
2. Clicca su **"Create a new scenario"**
3. Chiamalo "Enrow Email Finder"

### Passaggio 2: Aggiungi un trigger

Scegli cosa avvia lo scenario:

* **Google Sheets**: Monitora le righe
* **Webhooks**: Webhook personalizzato
* **Schedule**: Esegui ogni ora
* **Watch for changes**: Nel tuo CRM

### Passaggio 3: Aggiungi il modulo HTTP per Enrow

1. Clicca su **"+"** per aggiungere un modulo
2. Cerca **"HTTP"**
3. Scegli **"Make a request"**

### Passaggio 4: Configura la chiamata all'API di Enrow

Punta il modulo HTTP all'endpoint [Trova Email](/it/api-reference/email-finder/find-single) e passa la tua chiave API negli header.

**URL:**

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

**Method:** POST

**Headers:**

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

**Body (JSON):**

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

### Passaggio 5: Aggiungi un webhook per i risultati

Enrow elabora le ricerche in modo asincrono e notifica un webhook quando ogni ricerca termina. Consulta [Come funzionano i webhook](/it/how-webhooks-work) per il formato del payload.

1. Aggiungi un modulo **"Webhooks"** come nuovo trigger
2. Scegli **"Custom webhook"**
3. Copia l'URL del webhook
4. Torna al modulo HTTP
5. Aggiorna il body JSON per includere il webhook:

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

### Passaggio 6: Elabora i risultati

Dopo che il webhook ha ricevuto i risultati:

1. Aggiungi un modulo **"Router"** per ramificare la logica
2. Ramo 1: Salva su Google Sheets
3. Ramo 2: Aggiorna il CRM
4. Ramo 3: Invia una notifica

## Quali scenari posso creare?

Gli scenari Enrow più comuni combinano un trigger, il modulo HTTP e il webhook con le app a valle. Ecco tre pattern da cui partire.

### Scenario 1: Arricchisci Google Sheets

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

### Scenario 2: Verifica e aggiungi a Mailchimp

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

### Scenario 3: Elaborazione bulk

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

## Perché usare Make per Enrow?

Make ti offre un costruttore visuale, gestione degli errori integrata ed esecuzione parallela — utile quando un workflow Enrow deve diramarsi verso più app.

<AccordionGroup>
  <Accordion title="Costruttore di workflow visuale">
    Visualizza l'intero flusso di automazione. Perfetto per logiche complesse.
  </Accordion>

  <Accordion title="Gestione degli errori">
    Gestione degli errori e meccanismi di retry integrati.
  </Accordion>

  <Accordion title="Trasformazione dei dati">
    Funzioni e strumenti potenti per trasformare i dati tra i passaggi.
  </Accordion>

  <Accordion title="Esecuzione parallela">
    Esegui più percorsi simultaneamente con il modulo Router.
  </Accordion>
</AccordionGroup>

## Come creo scenari Make efficienti?

Elabora i risultati Enrow in batch, aggiungi gestori di errori e memorizza i risultati nella cache per evitare chiamate ridondanti. I pattern seguenti mantengono gli scenari veloci e nei limiti sia delle tue operazioni Make sia dei tuoi [crediti](/it/credits-billing) Enrow.

### Usa il modulo Iterator

Elabora i risultati bulk uno per uno:

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

### Aggiungi gestori di errori

1. Clicca con il tasto destro su un modulo qualsiasi
2. Aggiungi **"Error handler"**
3. Configura cosa accade in caso di errore (log, email, retry)

### Usa i Data Store

Memorizza i risultati nella cache per evitare chiamate API ridondanti:

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

## Come elaboro operazioni bulk?

Aggrega le righe in batch e chiama l'endpoint [Trova Email in bulk](/it/api-reference/email-finder/find-bulk) (fino a 5.000 ricerche per batch), quindi itera sui risultati del webhook. In questo modo elabori 1.000 contatti in una manciata di operazioni invece di una per contatto.

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

## Quali moduli Make mi servono per Enrow?

Questi sono i moduli che compaiono nella maggior parte degli scenari Enrow:

| Module               | Caso d'uso                               |
| -------------------- | ---------------------------------------- |
| **HTTP**             | Chiamare l'API di Enrow                  |
| **Webhooks**         | Ricevere risultati asincroni             |
| **Iterator**         | Elaborare i risultati bulk               |
| **Router**           | Ramificare la logica (valido/non valido) |
| **Filter**           | Saltare i risultati a bassa affidabilità |
| **Data Store**       | Memorizzare i risultati nella cache      |
| **Array Aggregator** | Creare batch                             |

## Come mantengo basso l'uso delle operazioni?

Make addebita per operazione, quindi preferisci gli endpoint bulk, memorizza i risultati nei data store e filtra in anticipo per saltare passaggi non necessari. Una singola richiesta bulk conta come molte meno operazioni rispetto a tante richieste singole.

**Esempio:**

* ❌ Sbagliato: 1000 richieste singole = 1000 operazioni
* ✅ Corretto: 10 richieste bulk (100 ciascuna) = 10 operazioni

## FAQ

<AccordionGroup>
  <Accordion title="Perché il mio webhook non riceve dati?">
    Verifica che lo scenario sia attivo (ON), controlla che l'URL del webhook nel campo `settings.webhook` di Enrow corrisponda esattamente a quello generato da Make e prova prima l'endpoint con uno strumento come Postman. Consulta [Come funzionano i webhook](/it/how-webhooks-work) per il formato del payload.
  </Accordion>

  <Accordion title="Il mio scenario ha raggiunto il limite di operazioni — cosa devo fare?">
    Passa dalle chiamate singole all'endpoint [Trova Email in bulk](/it/api-reference/email-finder/find-bulk), memorizza nella cache in un Data Store i dati a cui accedi di frequente e aggiorna il tuo piano Make se ti servono ancora più operazioni.
  </Accordion>

  <Accordion title="Il mio scenario va in timeout — come lo risolvo?">
    Suddividi uno scenario grande in altri più piccoli, usa trigger pianificati invece di quelli istantanei e riduci le dimensioni dei batch. Poiché le ricerche Enrow sono asincrone, lascia che sia il webhook a consegnare i risultati invece di attendere all'interno del modulo HTTP.
  </Accordion>

  <Accordion title="Quale endpoint Enrow deve chiamare il modulo HTTP?">
    Usa [Trova Email](/it/api-reference/email-finder/find-single) o [Verifica Email](/it/api-reference/email-verifier/verify-single) per il lavoro riga per riga, e l'endpoint [Trova Email in bulk](/it/api-reference/email-finder/find-bulk) quando aggreghi molte righe. Tutti si autenticano con lo stesso header `x-api-key`.
  </Accordion>
</AccordionGroup>

## Prossimi passi

<CardGroup cols={2}>
  <Card title="Trova Email" icon="envelope" href="/it/api-reference/email-finder/find-single">
    Chiama l'endpoint che userà il tuo modulo HTTP per trovare un'email.
  </Card>

  <Card title="Trova Email in bulk" icon="layer-group" href="/it/api-reference/email-finder/find-bulk">
    Esegui fino a 5.000 ricerche di email in un'unica richiesta.
  </Card>

  <Card title="Come funzionano i webhook" icon="bell" href="/it/how-webhooks-work">
    Comprendi il payload dei risultati asincroni che Make riceve.
  </Card>

  <Card title="Workflow n8n" icon="diagram-project" href="/it/playbooks/n8n/getting-started">
    Crea la stessa automazione su un'alternativa self-hosted.
  </Card>
</CardGroup>