---
title: "Konektor Zoom"
description: "Kompletní průvodce integrací Zoom pro synchronizaci účastníků schůzek, návštěvníků webinářů a dat o zapojení s Brevo přes Tajo."
url: https://tajo.io/cz/docs/connectors/custom/zoom/
markdown: https://tajo.io/cz/docs/connectors/custom/zoom.md
lang: cs-CZ
robots: noindex
---

Požádejte o přednostní přístup

Zadejte své jméno a pracovní e-mailovou adresu. Pošleme vám odkaz pro potvrzení žádosti o přístup k Tajo.

# Konektor Zoom

Stav konektoru: Plánováno Zatím nevytvořeno. Tajo tento konektor dnes neprovozuje.

| Zdrojové pole | Cílové pole | Ukázková hodnota |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Propojte Zoom s Brevo přes Tajo pro automatickou synchronizaci účastníků schůzek a návštěvníků webinářů jako kontaktů, spouštění navazujících sekvencí po schůzce a sledování metrik zapojení pro vaše marketingové automatizace.

## Přehled

| Vlastnost | Hodnota |
| --- | --- |
| **Platforma** | Zoom |
| **Kategorie** | Videokonference (Vlastní) |
| **Složitost nastavení** | Střední |
| **Oficiální integrace** | Ne |
| **Synchronizovaná data** | Účastníci, Události, Webináře, Kontakty |
| **Metoda ověření** | OAuth 2.0 / Server-to-Server OAuth |

## Funkce

- **Synchronizace účastníků** – Automatické vytváření kontaktů Brevo z účastníků schůzek
- **Zachytávání návštěvníků webinářů** – Synchronizace registrantů a návštěvníků webinářů
- **Spouštěče událostí schůzek** – Spouštění automatizací při zahájení, ukončení a nahrání schůzky
- **Sledování zapojení** – Sledování doby účasti a metrik participace
- **Navazující akce po webináři** – Spouštění cílených e-mailových sekvencí na základě účasti na webináři
- **Notifikace o nahrávkách** – Odesílání odkazů na nahrávky přes e-mailové kampaně Brevo

## Předpoklady

Než začnete, ujistěte se, že máte:

1. Účet Zoom (plán Pro nebo vyšší)
2. Aplikaci Zoom Server-to-Server OAuth nebo OAuth aplikaci přes [Zoom App Marketplace](https://marketplace.zoom.us/)
3. Účet Brevo s přístupem k API
4. Účet Tajo s oprávněními ke konektoru

## Ověření

### Server-to-Server OAuth (doporučeno)

```bash
# Vytvořte Server-to-Server OAuth aplikaci na 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
// Získání přístupového tokenu přes 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 (na úrovni uživatele)

```javascript
// Autorizační URL pro OAuth na úrovni uživatele
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'
  });

// Výměna kódu za tokeny
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'
  })
});
```

## Konfigurace

### Základní nastavení

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

### Mapování polí

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

## Koncové body API

| Koncový bod | Metoda | Popis |
| --- | --- | --- |
| `https://api.zoom.us/v2/users` | GET | Výpis uživatelů |
| `https://api.zoom.us/v2/users/{userId}/meetings` | GET | Výpis schůzek |
| `https://api.zoom.us/v2/meetings/{meetingId}` | GET | Podrobnosti schůzky |
| `https://api.zoom.us/v2/past_meetings/{meetingId}/participants` | GET | Výpis účastníků minulé schůzky |
| `https://api.zoom.us/v2/users/{userId}/webinars` | GET | Výpis webinářů |
| `https://api.zoom.us/v2/webinars/{webinarId}/registrants` | GET | Výpis registrantů webináře |
| `https://api.zoom.us/v2/webinars/{webinarId}/participants` | GET | Výpis účastníků webináře |
| `https://api.zoom.us/v2/meetings/{meetingId}/recordings` | GET | Nahrávky schůzky |
| `https://api.zoom.us/v2/webhooks` | POST | Přihlášení k odběru webhooků |

## Příklady kódu

### Inicializace konektoru

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

### Synchronizace účastníků schůzky

```javascript
// Načtení účastníků minulé schůzky
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]
    });
  }
}
```

### Synchronizace návštěvníků webináře

```javascript
// Načtení návštěvníků webináře a synchronizace do 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]
  });
}
```

### Zpracování webhooků Zoom

```javascript
app.post('/webhooks/zoom', async (req, res) => {
  // Zpracování ověřovací výzvy 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
    });
  }

  // Ověření podpisu webhooku
  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');
});
```

## Omezení rychlosti

| Kategorie | Limit | Poznámky |
| --- | --- | --- |
| Lehká volání API | 30 požadavků/s | GET informace o uživateli a schůzce |
| Střední volání API | 20 požadavků/s | Výpis účastníků, webinářů |
| Těžká volání API | 10 požadavků/s | Přehledy, nahrávky |
| Denní limit | 5 000+ | Závisí na úrovni plánu |

Hlavičky limitu rychlosti

Zoom vrací hlavičky `X-RateLimit-Limit`, `X-RateLimit-Remaining` a `Retry-After`. Implementujte logiku zpětného odběrání na základě těchto hlaviček, abyste se vyhnuli chybám 429.

## Řešení problémů

| Problém | Příčina | Řešení |
| --- | --- | --- |
| 401 Unauthorized | Vypršelý token | Obnovte Server-to-Server OAuth token |
| Chybějící účastníci | Schůzka neskončila | Počkejte na ukončení schůzky pro úplná data |
| Ověření webhooku selhává | Nesprávný secret | Ověřte webhook secret v Zoom Marketplace |
| Žádné e-mailové údaje | Účastníci jako hosté | Povolte registraci pro zachytávání e-mailů |
| Limit rychlosti 429 | Příliš mnoho požadavků | Implementujte exponenciální zpětné odběrání |

### Režim ladění

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

## Osvědčené postupy

1. **Používejte Server-to-Server OAuth** – Jednodušší ověřování bez interakce uživatele
2. **Povolte registraci webináře** – Vyžadováno pro zachytávání e-mailových adres návštěvníků
3. **Zpracovávejte po ukončení schůzky** – Data účastníků jsou úplná teprve po ukončení schůzek
4. **Segmentujte podle typu události** – Přiřazujte různé seznamy Brevo pro schůzky vs. webináře
5. **Sledujte metriky zapojení** – Používejte dobu trvání a čas připojení pro skórování potenciálních zákazníků
6. **Odesílejte navazující akce o nahrávkách** – Automatizujte doručování odkazů na nahrávky přes Brevo

## Zabezpečení

- **OAuth 2.0** – Server-to-Server nebo OAuth ověřování na úrovni uživatele
- **Ověření webhooků** – Ověření podpisu HMAC-SHA256
- **Ověření URL** – Ověřování challenge-response pro webhookové koncové body
- **Omezená oprávnění** – Požadujte minimální potřebné rozsahy OAuth
- **Rotace tokenů** – Server-to-Server tokeny automaticky vyprší (1 hodina)
- **Šifrovaný přenos** – TLS 1.2+ pro veškerou API komunikaci

## Související zdroje

- [Konektor Calendly](https://tajo.io/cz/docs/connectors/custom/calendly)
- [Konektor Zapier](https://tajo.io/cz/docs/connectors/custom/zapier)
- [Dovednost synchronizace zákazníků](https://tajo.io/cz/docs/skills/data-sync/customer-sync)
- [Dokumentace Zoom API](https://developers.zoom.us/docs/api/)