---
title: "Connettore Zoom"
description: "Guida completa all'integrazione di Zoom per sincronizzare partecipanti ai meeting, iscritti ai webinar e dati di engagement con Brevo tramite Tajo."
url: https://tajo.io/it/docs/connectors/custom/zoom/
markdown: https://tajo.io/it/docs/connectors/custom/zoom.md
lang: it-IT
robots: noindex
---

Richiedi l’accesso anticipato

Inserisci il tuo nome e indirizzo email aziendale. Ti invieremo un link per confermare la richiesta di accesso a Tajo.

# Connettore Zoom

Stato del connettore: Pianificato Non ancora realizzato. Oggi Tajo non esegue questo connettore.

| Campo di origine | Campo di destinazione | Valore di esempio |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Collega Zoom a Brevo tramite Tajo per sincronizzare automaticamente i partecipanti ai meeting e i partecipanti ai webinar come contatti, attivare sequenze di follow-up post-meeting e tracciare metriche di engagement per le tue automazioni marketing.

## Panoramica

| Proprietà | Valore |
| --- | --- |
| **Piattaforma** | Zoom |
| **Categoria** | Video Conferencing (Custom) |
| **Complessità di setup** | Media |
| **Integrazione ufficiale** | No |
| **Dati sincronizzati** | Partecipanti, Eventi, Webinar, Contatti |
| **Metodo di autenticazione** | OAuth 2.0 / Server-to-Server OAuth |

## Funzionalità

- **Sync partecipanti** - Crea automaticamente contatti Brevo dai partecipanti ai meeting
- **Cattura partecipanti ai webinar** - Sincronizza iscritti e partecipanti ai webinar
- **Trigger eventi meeting** - Attiva automazioni su inizio, fine e registrazione del meeting
- **Tracciamento engagement** - Traccia la durata di partecipazione e le metriche di partecipazione
- **Follow-up webinar** - Attiva sequenze email mirate in base alla partecipazione ai webinar
- **Notifiche di registrazione** - Invia link alle registrazioni tramite campagne email Brevo

## Prerequisiti

Prima di iniziare, assicurati di avere:

1. Un account Zoom (piano Pro o superiore)
2. Un’app Zoom Server-to-Server OAuth o un’app OAuth tramite [Zoom App Marketplace](https://marketplace.zoom.us/)
3. Un account Brevo con accesso API
4. Un account Tajo con permessi sui connettori

## Autenticazione

### Server-to-Server OAuth (consigliato)

```bash
# Crea un'app Server-to-Server OAuth su marketplace.zoom.us
export ZOOM_ACCOUNT_ID=your_account_id
export ZOOM_CLIENT_ID=your_client_id
export ZOOM_CLIENT_SECRET=your_client_secret
```

```javascript
// Ottiene un access token tramite Server-to-Server OAuth
const tokenResponse = await fetch('https://zoom.us/oauth/token', {
  method: 'POST',
  headers: {
    'Authorization': `Basic ${Buffer.from(
      `${process.env.ZOOM_CLIENT_ID}:${process.env.ZOOM_CLIENT_SECRET}`
    ).toString('base64')}`,
    'Content-Type': 'application/x-www-form-urlencoded'
  },
  body: new URLSearchParams({
    grant_type: 'account_credentials',
    account_id: process.env.ZOOM_ACCOUNT_ID
  })
});

const { access_token } = await tokenResponse.json();
```

### OAuth 2.0 (user-level)

```javascript
// URL di autorizzazione per OAuth user-level
const authUrl = 'https://zoom.us/oauth/authorize?' +
  new URLSearchParams({
    client_id: process.env.ZOOM_CLIENT_ID,
    redirect_uri: 'https://your-app.com/callback',
    response_type: 'code'
  });

// Scambia il code per i token
const tokenResponse = await fetch('https://zoom.us/oauth/token', {
  method: 'POST',
  headers: {
    'Authorization': `Basic ${Buffer.from(
      `${process.env.ZOOM_CLIENT_ID}:${process.env.ZOOM_CLIENT_SECRET}`
    ).toString('base64')}`,
    'Content-Type': 'application/x-www-form-urlencoded'
  },
  body: new URLSearchParams({
    grant_type: 'authorization_code',
    code: authorizationCode,
    redirect_uri: 'https://your-app.com/callback'
  })
});
```

## Configurazione

### Setup di base

```yaml
connectors:
  zoom:
    enabled: true
    account_id: "${ZOOM_ACCOUNT_ID}"
    client_id: "${ZOOM_CLIENT_ID}"
    client_secret: "${ZOOM_CLIENT_SECRET}"

    sync:
      participants: true
      webinars: true
      recordings: true

    webhook:
      secret_token: "${ZOOM_WEBHOOK_SECRET}"
      verification_token: "${ZOOM_VERIFICATION_TOKEN}"

    lists:
      meeting_participants: 15
      webinar_attendees: 16
      webinar_registrants: 17
```

### Mapping dei campi

```yaml
field_mapping:
  email: email
  name: FIRSTNAME
  join_time: MEETING_JOIN_DATE
  duration: MEETING_DURATION
  webinar_title: WEBINAR_NAME
  attendance_status: ATTENDANCE_STATUS
  registration_source: UTM_SOURCE
```

## Endpoint API

| Endpoint | Metodo | Descrizione |
| --- | --- | --- |
| `https://api.zoom.us/v2/users` | GET | Elenca gli utenti |
| `https://api.zoom.us/v2/users/{userId}/meetings` | GET | Elenca i meeting |
| `https://api.zoom.us/v2/meetings/{meetingId}` | GET | Ottieni dettagli meeting |
| `https://api.zoom.us/v2/past_meetings/{meetingId}/participants` | GET | Elenca partecipanti ai meeting passati |
| `https://api.zoom.us/v2/users/{userId}/webinars` | GET | Elenca i webinar |
| `https://api.zoom.us/v2/webinars/{webinarId}/registrants` | GET | Elenca gli iscritti al webinar |
| `https://api.zoom.us/v2/webinars/{webinarId}/participants` | GET | Elenca i partecipanti al webinar |
| `https://api.zoom.us/v2/meetings/{meetingId}/recordings` | GET | Ottieni le registrazioni del meeting |
| `https://api.zoom.us/v2/webhooks` | POST | Sottoscrivi webhook |

## Esempi di codice

### Inizializzare il connettore

```javascript
import { TajoClient } from '@tajo/sdk';

const tajo = new TajoClient({
  apiKey: process.env.TAJO_API_KEY,
  brevoApiKey: process.env.BREVO_API_KEY
});

await tajo.connectors.connect('zoom', {
  accountId: process.env.ZOOM_ACCOUNT_ID,
  clientId: process.env.ZOOM_CLIENT_ID,
  clientSecret: process.env.ZOOM_CLIENT_SECRET
});
```

### Sincronizzare i partecipanti ai meeting

```javascript
// Recupera i partecipanti ai meeting passati
const response = await fetch(
  `https://api.zoom.us/v2/past_meetings/${meetingId}/participants`,
  {
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'Content-Type': 'application/json'
    }
  }
);

const { participants } = await response.json();

for (const participant of participants) {
  if (participant.user_email) {
    await tajo.contacts.sync({
      email: participant.user_email,
      attributes: {
        FIRSTNAME: participant.name,
        MEETING_DURATION: participant.duration,
        MEETING_JOIN_DATE: participant.join_time,
        ATTENDANCE_STATUS: 'attended'
      },
      listIds: [15]
    });
  }
}
```

### Sincronizzare i partecipanti al webinar

```javascript
// Recupera i partecipanti al webinar e sincronizzali su Brevo
const attendeesResponse = await fetch(
  `https://api.zoom.us/v2/past_webinars/${webinarId}/participants`,
  {
    headers: { 'Authorization': `Bearer ${accessToken}` }
  }
);

const { participants: attendees } = await attendeesResponse.json();

for (const attendee of attendees) {
  await tajo.contacts.sync({
    email: attendee.user_email,
    attributes: {
      FIRSTNAME: attendee.name,
      WEBINAR_NAME: webinarTitle,
      ATTENDANCE_STATUS: 'attended',
      MEETING_DURATION: attendee.duration
    },
    listIds: [16]
  });
}
```

### Gestire i webhook Zoom

```javascript
app.post('/webhooks/zoom', async (req, res) => {
  // Gestisci la challenge di validazione URL di Zoom
  if (req.body.event === 'endpoint.url_validation') {
    const hashForValidation = crypto
      .createHmac('sha256', process.env.ZOOM_WEBHOOK_SECRET)
      .update(req.body.payload.plainToken)
      .digest('hex');

    return res.json({
      plainToken: req.body.payload.plainToken,
      encryptedToken: hashForValidation
    });
  }

  // Verifica la firma del webhook
  const message = `v0:${req.headers['x-zm-request-timestamp']}:${JSON.stringify(req.body)}`;
  const hash = crypto
    .createHmac('sha256', process.env.ZOOM_WEBHOOK_SECRET)
    .update(message)
    .digest('hex');
  const signature = `v0=${hash}`;

  if (req.headers['x-zm-signature'] !== signature) {
    return res.status(401).send('Unauthorized');
  }

  const { event, payload } = req.body;

  await tajo.connectors.handleWebhook('zoom', {
    topic: event,
    payload: payload
  });

  res.status(200).send('OK');
});
```

## Limiti di rate

| Categoria | Limite | Note |
| --- | --- | --- |
| Chiamate API leggere | 30 req/sec | GET user, info meeting |
| Chiamate API medie | 20 req/sec | Lista partecipanti, webinar |
| Chiamate API pesanti | 10 req/sec | Report, registrazioni |
| Limite giornaliero | 5.000+ | Dipende dal livello del piano |

Header del rate limit

Zoom restituisce gli header `X-RateLimit-Limit`, `X-RateLimit-Remaining` e `Retry-After`. Implementa una logica di backoff basata su questi header per evitare errori 429.

## Risoluzione dei problemi

| Problema | Causa | Soluzione |
| --- | --- | --- |
| 401 Unauthorized | Token scaduto | Aggiorna il token Server-to-Server OAuth |
| Partecipanti mancanti | Meeting non terminato | Attendi la fine del meeting per dati completi |
| Validazione webhook fallisce | Secret errato | Verifica il secret del webhook nel Zoom Marketplace |
| Nessun dato email | Partecipanti come ospiti | Abilita la registrazione per catturare le email |
| Rate limit 429 | Troppe richieste | Implementa exponential backoff |

### Modalità debug

```yaml
connectors:
  zoom:
    debug: true
    log_level: verbose
    log_webhooks: true
```

## Best practice

1. **Usa Server-to-Server OAuth** - Autenticazione più semplice senza interazione utente
2. **Abilita la registrazione per i webinar** - Necessaria per catturare gli indirizzi email dei partecipanti
3. **Elabora dopo la fine del meeting** - I dati dei partecipanti sono completi solo dopo la fine dei meeting
4. **Segmenta per tipo di evento** - Assegna liste Brevo diverse per meeting vs. webinar
5. **Traccia le metriche di engagement** - Usa durata e orario di join per il lead scoring
6. **Invia follow-up delle registrazioni** - Automatizza la consegna del link alle registrazioni tramite Brevo

## Sicurezza

- **OAuth 2.0** - Autenticazione OAuth Server-to-Server o user-level
- **Verifica webhook** - Validazione firma HMAC-SHA256
- **Validazione URL** - Verifica challenge-response per gli endpoint webhook
- **Permessi con scope** - Richiedi gli scope OAuth minimi necessari
- **Rotazione dei token** - I token Server-to-Server scadono automaticamente (1 ora)
- **Trasporto cifrato** - TLS 1.2+ per tutte le comunicazioni API

## Risorse correlate

- [Connettore Calendly](https://tajo.io/it/docs/connectors/custom/calendly)
- [Connettore Zapier](https://tajo.io/it/docs/connectors/custom/zapier)
- [Skill Customer Sync](https://tajo.io/it/docs/skills/data-sync/customer-sync)
- [Documentazione Zoom API](https://developers.zoom.us/docs/api/)