---
title: "Connecteur Zoom"
description: "Guide complet d'intégration Zoom pour synchroniser participants aux réunions, inscrits aux webinaires et données d'engagement avec Brevo via Tajo."
url: https://tajo.io/fr/docs/connectors/custom/zoom/
markdown: https://tajo.io/fr/docs/connectors/custom/zoom.md
lang: fr-FR
robots: noindex
---

Demandez un accès anticipé

Indiquez votre prénom et votre adresse e-mail professionnelle. Nous vous enverrons un lien pour confirmer votre demande d’accès à Tajo.

# Connecteur Zoom

Statut du connecteur: Prévu Pas encore construit. Tajo n'exécute pas ce connecteur aujourd'hui.

| Champ source | Champ de destination | Valeur d’exemple |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Connectez Zoom à Brevo via Tajo pour synchroniser automatiquement les participants aux réunions et aux webinaires en tant que contacts, déclencher des séquences de suivi post-réunion, et suivre les métriques d’engagement pour vos automatisations marketing.

## Vue d’ensemble

| Propriété | Valeur |
| --- | --- |
| **Plateforme** | Zoom |
| **Catégorie** | Visioconférence (Personnalisé) |
| **Complexité de configuration** | Moyenne |
| **Intégration officielle** | Non |
| **Données synchronisées** | Participants, Événements, Webinaires, Contacts |
| **Méthode d’authentification** | OAuth 2.0 / Server-to-Server OAuth |

## Fonctionnalités

- **Synchronisation des participants** - Création automatique de contacts Brevo depuis les participants aux réunions
- **Capture des participants aux webinaires** - Synchronisation des inscrits et participants aux webinaires
- **Déclencheurs d’événements de réunion** - Lancement d’automatisations au début, à la fin et lors des événements d’enregistrement
- **Suivi de l’engagement** - Suivi de la durée de présence et des métriques de participation
- **Suivi post-webinaire** - Déclenchement de séquences email ciblées selon la présence aux webinaires
- **Notifications d’enregistrement** - Envoi des liens d’enregistrement via des campagnes email Brevo

## Prérequis

Avant de commencer, assurez-vous d’avoir :

1. Un compte Zoom (plan Pro ou supérieur)
2. Une application Server-to-Server OAuth ou OAuth via le [Zoom App Marketplace](https://marketplace.zoom.us/)
3. Un compte Brevo avec accès API
4. Un compte Tajo avec permissions de connecteur

## Authentification

### Server-to-Server OAuth (Recommandé)

```bash
# Créez une application Server-to-Server OAuth sur 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
// Obtenir un jeton d'accès via 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 (Niveau utilisateur)

```javascript
// URL d'autorisation pour OAuth de niveau utilisateur
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'
  });

// Échanger le code contre des jetons
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'
  })
});
```

## Configuration

### Configuration de 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
```

### Mappage de champs

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

## Endpoints API

| Endpoint | Méthode | Description |
| --- | --- | --- |
| `https://api.zoom.us/v2/users` | GET | Lister les utilisateurs |
| `https://api.zoom.us/v2/users/{userId}/meetings` | GET | Lister les réunions |
| `https://api.zoom.us/v2/meetings/{meetingId}` | GET | Obtenir les détails d’une réunion |
| `https://api.zoom.us/v2/past_meetings/{meetingId}/participants` | GET | Lister les participants aux réunions passées |
| `https://api.zoom.us/v2/users/{userId}/webinars` | GET | Lister les webinaires |
| `https://api.zoom.us/v2/webinars/{webinarId}/registrants` | GET | Lister les inscrits aux webinaires |
| `https://api.zoom.us/v2/webinars/{webinarId}/participants` | GET | Lister les participants aux webinaires |
| `https://api.zoom.us/v2/meetings/{meetingId}/recordings` | GET | Obtenir les enregistrements de réunions |
| `https://api.zoom.us/v2/webhooks` | POST | S’abonner aux webhooks |

## Exemples de code

### Initialiser le connecteur

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

### Synchroniser les participants aux réunions

```javascript
// Récupérer les participants aux réunions passées
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]
    });
  }
}
```

### Synchroniser les participants aux webinaires

```javascript
// Obtenir les participants aux webinaires et les synchroniser vers 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]
  });
}
```

### Gérer les webhooks Zoom

```javascript
app.post('/webhooks/zoom', async (req, res) => {
  // Gérer le challenge de validation d'URL 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
    });
  }

  // Vérifier la signature du 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');
});
```

## Limites de taux

| Catégorie | Limite | Notes |
| --- | --- | --- |
| Appels API légers | 30 req/sec | GET utilisateur, informations de réunion |
| Appels API moyens | 20 req/sec | Liste de participants, webinaires |
| Appels API lourds | 10 req/sec | Rapports, enregistrements |
| Limite quotidienne | 5 000+ | Dépend du niveau du plan |

En-têtes de limite de taux

Zoom retourne les en-têtes `X-RateLimit-Limit`, `X-RateLimit-Remaining` et `Retry-After`. Implémentez une logique de backoff basée sur ces en-têtes pour éviter les erreurs 429.

## Dépannage

| Problème | Cause | Solution |
| --- | --- | --- |
| 401 Unauthorized | Jeton expiré | Rafraîchissez le jeton Server-to-Server OAuth |
| Participants manquants | Réunion non terminée | Attendez la fin de la réunion pour les données complètes |
| Validation webhook échoue | Mauvais secret | Vérifiez le secret webhook dans Zoom Marketplace |
| Pas de données email | Participants invités | Activez l’inscription pour capturer les emails |
| Limite de taux 429 | Trop de requêtes | Implémentez un backoff exponentiel |

### Mode debug

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

## Bonnes pratiques

1. **Utilisez Server-to-Server OAuth** - Authentification plus simple sans interaction utilisateur
2. **Activez l’inscription aux webinaires** - Nécessaire pour capturer les adresses email des participants
3. **Traitez après la fin de la réunion** - Les données des participants ne sont complètes qu’après la fin des réunions
4. **Segmentez par type d’événement** - Assignez différentes listes Brevo pour les réunions vs les webinaires
5. **Suivez les métriques d’engagement** - Utilisez la durée et l’heure de connexion pour le scoring de leads
6. **Envoyez des suivis d’enregistrement** - Automatisez l’envoi des liens d’enregistrement via Brevo

## Sécurité

- **OAuth 2.0** - Authentification Server-to-Server ou OAuth de niveau utilisateur
- **Vérification des webhooks** - Validation de signature HMAC-SHA256
- **Validation d’URL** - Vérification par challenge-réponse pour les endpoints webhook
- **Permissions à périmètre réduit** - Demandez les périmètres OAuth minimaux requis
- **Rotation des jetons** - Les jetons Server-to-Server expirent automatiquement (1 heure)
- **Transport chiffré** - TLS 1.2+ pour toutes les communications API

## Ressources liées

- [Connecteur Calendly](https://tajo.io/fr/docs/connectors/custom/calendly)
- [Connecteur Zapier](https://tajo.io/fr/docs/connectors/custom/zapier)
- [Compétence de synchronisation client](https://tajo.io/fr/docs/skills/data-sync/customer-sync)
- [Documentation API Zoom](https://developers.zoom.us/docs/api/)