---
title: "Conector Slack"
description: "Ghid complet de integrare Slack pentru trimiterea notificărilor, sincronizarea datelor din canale și declanșarea automatizărilor Brevo din evenimentele Slack prin Tajo."
url: https://tajo.io/ro/docs/connectors/custom/slack/
markdown: https://tajo.io/ro/docs/connectors/custom/slack.md
lang: ro-RO
robots: noindex
---

Solicită acces anticipat

Introduceți prenumele și adresa de e-mail profesională. Vă vom trimite un link pentru a confirma cererea de acces la Tajo.

# Conector Slack

Starea conectorului: Planificat Încă neconstruit. Tajo nu rulează astăzi acest conector.

| Câmp sursă | Câmp destinație | Valoare exemplu |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Conectați spațiul de lucru Slack la Brevo prin Tajo pentru notificări de marketing în timp real, alerte de echipă pentru evenimentele clienților și automatizare a fluxului de lucru declanșată de interacțiunile Slack.

## Prezentare generală

| Proprietate | Valoare |
| --- | --- |
| **Platformă** | Slack |
| **Categorie** | Integrare personalizată |
| **Complexitate configurare** | Ușoară |
| **Integrare oficială** | Nu |
| **Date sincronizate** | Utilizatori, Canale, Mesaje, Evenimente |
| **URL de bază API** | `https://slack.com/api` |

## Funcționalități

- **Alerte de marketing** - Trimiteți notificări în timp real pentru evenimentele campaniei, noii abonați și etapele de venituri
- **Notificări de evenimente clienți** - Alertați echipele despre acțiunile clienților de mare valoare din Brevo
- **Declanșatoare de flux de lucru** - Utilizați interacțiunile Slack (clicuri pe butoane, trimiteri de formulare) pentru a declanșa automatizări Brevo
- **Rutare bazată pe canal** - Rutați notificările către canale specifice pe baza tipului de eveniment sau segmentului de clienți
- **Sincronizare utilizatori** - Mapați utilizatorii din spațiul de lucru Slack la contactele Brevo pentru comunicații interne
- **Mesaje interactive** - Trimiteți mesaje bogate cu butoane și acțiuni pentru fluxurile de lucru ale echipei
- **Mesaje programate** - Programați notificări pentru rezumatele zilnice/săptămânale de marketing
- **Suport fire de discuții** - Grupați notificările înrudite în fire de discuții pentru comunicare organizată

## Cerințe preliminare

Înainte de a începe, asigurați-vă că aveți:

1. Un spațiu de lucru Slack cu acces de administrator
2. O aplicație Slack creată la [api.slack.com/apps](https://api.slack.com/apps)
3. Token bot cu scopurile necesare
4. Un cont Brevo cu acces API
5. Un cont Tajo

## Autentificare

### Token bot (Recomandat)

Instalați o aplicație Slack în spațiul de lucru și utilizați tokenul bot pentru acces API.

1. Creați aplicația la [api.slack.com/apps](https://api.slack.com/apps)
2. Adăugați scopurile OAuth necesare sub “OAuth & Permissions”
3. Instalați aplicația în spațiul de lucru
4. Copiați Bot User OAuth Token (`xoxb-...`)

```bash
curl -X POST "https://slack.com/api/chat.postMessage" \
  -H "Authorization: Bearer xoxb-YOUR-BOT-TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"channel": "C01234567", "text": "Hello from Tajo!"}'
```

### OAuth 2.0

Pentru distribuirea integrării Slack la mai multe spații de lucru:

```bash
# Authorization URL
https://slack.com/oauth/v2/authorize?
  client_id={client_id}&
  scope=chat:write,channels:read,users:read&
  redirect_uri={redirect_uri}

# Token exchange
curl -X POST "https://slack.com/api/oauth.v2.access" \
  -d "client_id={client_id}" \
  -d "client_secret={client_secret}" \
  -d "code={auth_code}"
```

#### Scopuri bot necesare

```
chat:write           # Send messages
channels:read        # List channels
channels:history     # Read channel messages
users:read           # List workspace users
users:read.email     # Read user email addresses
reactions:write      # Add reactions to messages
files:write          # Upload files
```

Acces e-mail utilizator

Scopul `users:read.email` este necesar pentru a potrivi utilizatorii Slack cu contactele Brevo. Fără el, maparea utilizatorilor va fi limitată la numele de afișare.

## Configurare

### Configurare de bază

```yaml
connectors:
  slack:
    enabled: true
    bot_token: "${SLACK_BOT_TOKEN}"
    signing_secret: "${SLACK_SIGNING_SECRET}"

    # Notification channels
    channels:
      marketing: "C01234567"
      sales: "C01234568"
      support: "C01234569"
      alerts: "C01234570"

    # Event routing
    notifications:
      new_subscriber:
        channel: marketing
        template: subscriber_alert
      high_value_order:
        channel: sales
        template: order_alert
      support_ticket:
        channel: support
        template: ticket_alert
```

### Mapare câmpuri

Mapați datele utilizatorilor Slack la atributele de contact Brevo:

#### Mapări implicite

| Parameter | Type | Description |
| --- | --- | --- |
| `profile.email` required | string | E-mailul utilizatorului (identificator unic pentru potrivirea cu Brevo) |
| `real_name` optional | string | Numele complet, împărțit în FIRSTNAME/LASTNAME |
| `profile.phone` optional | string | Mapează la atributul SMS |
| `profile.title` optional | string | Titlul postului |
| `tz` optional | string | Fusul orar al utilizatorului |
| `is_admin` optional | boolean | Statusul de administrator al spațiului de lucru |
| `team_id` optional | string | ID-ul echipei din spațiul de lucru |
| `status_text` optional | string | Statusul personalizat al utilizatorului |

## Metode API

### Mesagerie

| Metodă | Punct final | Descriere |
| --- | --- | --- |
| `POST` | `chat.postMessage` | Trimite un mesaj într-un canal |
| `POST` | `chat.update` | Actualizează un mesaj existent |
| `POST` | `chat.delete` | Șterge un mesaj |
| `POST` | `chat.scheduleMessage` | Programează un mesaj |
| `POST` | `chat.postEphemeral` | Trimite mesaj efemer utilizatorului |

### Canale

| Metodă | Punct final | Descriere |
| --- | --- | --- |
| `GET` | `conversations.list` | Listează canalele |
| `GET` | `conversations.info` | Obține informații canal |
| `GET` | `conversations.members` | Listează membrii canalului |
| `GET` | `conversations.history` | Obține mesajele din canal |

### Utilizatori

| Metodă | Punct final | Descriere |
| --- | --- | --- |
| `GET` | `users.list` | Listează utilizatorii din spațiul de lucru |
| `GET` | `users.info` | Obține informații utilizator |
| `GET` | `users.lookupByEmail` | Caută utilizator după e-mail |
| `GET` | `users.conversations` | Listează canalele utilizatorului |

### Interacțiuni

| Metodă | Punct final | Descriere |
| --- | --- | --- |
| `POST` | `views.open` | Deschide o vizualizare modală |
| `POST` | `views.update` | Actualizează o vizualizare modală |
| `POST` | `reactions.add` | Adaugă reacție emoji |

## Evenimente

### Notificări Brevo-la-Slack

| Eveniment | Declanșator | Acțiune Slack |
| --- | --- | --- |
| `new_subscriber` | Contact creat în Brevo | Postează în #marketing |
| `campaign_sent` | Campanie de e-mail trimisă | Postează rezumat în #marketing |
| `order_placed` | Comandă de mare valoare detectată | Postează în #sales cu detalii |
| `cart_abandoned` | Coș abandonat timp de 30 min | Postează în #sales pentru urmărire |
| `ticket_created` | Tichet de suport deschis | Postează în #support |
| `unsubscribed` | Contact dezabonat | Postează alertă în #marketing |

### Declanșatoare Slack-la-Brevo

| Eveniment Slack | Declanșator | Acțiune Brevo |
| --- | --- | --- |
| `message_action` | Comandă rapidă mesaj personalizată | Adaugă contact în listă sau declanșează automatizare |
| `block_actions` | Clic pe buton în mesaj | Actualizează atribut contact sau trimite e-mail |
| `view_submission` | Formular modal trimis | Creează contact sau declanșează flux de lucru |

## Exemple de cod

### Inițializare conector

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

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

// Connect Slack
await tajo.connectors.connect('slack', {
  botToken: process.env.SLACK_BOT_TOKEN,
  signingSecret: process.env.SLACK_SIGNING_SECRET
});
```

### Trimitere notificări de marketing

```javascript
// Send a notification when a high-value order is placed
await tajo.slack.notify({
  channel: 'sales',
  event: 'order_placed',
  data: {
    customerEmail: 'customer@example.com',
    orderValue: '$1,250.00',
    products: ['Premium Widget', 'Pro Service'],
    isFirstOrder: true
  },
  template: {
    blocks: [
      {
        type: 'header',
        text: { type: 'plain_text', text: 'New High-Value Order' }
      },
      {
        type: 'section',
        fields: [
          { type: 'mrkdwn', text: '*Customer:*\ncustomer@example.com' },
          { type: 'mrkdwn', text: '*Amount:*\n$1,250.00' }
        ]
      },
      {
        type: 'actions',
        elements: [
          {
            type: 'button',
            text: { type: 'plain_text', text: 'View in Brevo' },
            url: 'https://app.brevo.com/contacts'
          }
        ]
      }
    ]
  }
});
```

### Gestionare interacțiuni Slack

```javascript
import crypto from 'crypto';

app.post('/slack/interactions', async (req, res) => {
  // Verify Slack request signature
  const timestamp = req.headers['x-slack-request-timestamp'];
  const signature = req.headers['x-slack-signature'];
  const sigBasestring = `v0:${timestamp}:${req.rawBody}`;
  const mySignature = 'v0=' + crypto
    .createHmac('sha256', process.env.SLACK_SIGNING_SECRET)
    .update(sigBasestring)
    .digest('hex');

  if (signature !== mySignature) {
    return res.status(401).send('Unauthorized');
  }

  const payload = JSON.parse(req.body.payload);

  // Handle button actions
  if (payload.type === 'block_actions') {
    await tajo.connectors.handleWebhook('slack', {
      type: 'interaction',
      action: payload.actions[0].action_id,
      userId: payload.user.id,
      payload
    });
  }

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

## Limite de rată

Limitele de rată ale API-ului Slack utilizează un sistem pe niveluri:

| Nivel | Limită | Metode frecvente |
| --- | --- | --- |
| Nivel 1 | 1 cerere/minut | `chat.delete`, `conversations.kick` |
| Nivel 2 | 20 cereri/minut | `conversations.history`, `users.info` |
| Nivel 3 | 50 cereri/minut | `conversations.list`, `users.list` |
| Nivel 4 | 100 cereri/minut | `chat.postMessage` |
| Special | Variabil | `chat.postMessage` în același canal: 1/sec |

Limite suplimentare:

- **Web API**: Limită burst cu throttle pe termen scurt
- **Events API**: Reîncercări de livrare pentru 3 tentative
- **Incoming Webhooks**: 1 mesaj/secundă per URL webhook
- **Block Kit**: Maximum 50 blocuri per mesaj

Rata de postare în canal

Postarea în același canal este limitată la aproximativ 1 mesaj pe secundă. Grupați notificările sau utilizați fire de discuții pentru a evita limitarea ratei.

## Depanare

### Probleme frecvente

| Problemă | Cauză | Soluție |
| --- | --- | --- |
| `not_authed` | Token bot invalid | Reinstalați aplicația și copiați noul token bot |
| `channel_not_found` | Botul nu este în canal | Invitați botul în canalul țintă |
| `missing_scope` | Scop necesar neacordat | Adăugați scopul și reinstalați aplicația |
| Eveniment nerecepted | Abonament eveniment nesetat | Configurați URL-ul Event Subscriptions |
| Timeout interacțiune | Răspuns >3 secunde | Răspundeți cu 200 imediat, procesați asincron |

### Modul de depanare

Activați jurnalizarea verbosă:

```yaml
connectors:
  slack:
    debug: true
    log_level: verbose
    log_events: true
```

### Testare conexiune

```bash
tajo connectors test slack
# ✓ Bot token valid
# ✓ Workspace accessible
# ✓ Channels readable
# ✓ Message posting enabled
# ✓ Event subscriptions active
```

## Bune practici

1. **Utilizați Block Kit** - Construiți mesaje bogate, interactive cu framework-ul Block Kit al Slack
2. **Răspundeți rapid** - Confirmați interacțiunile în 3 secunde, procesați asincron
3. **Grupați mesajele înrudite** - Grupați notificările înrudite în fire de discuții pentru a reduce zgomotul
4. **Rutați pe canal** - Trimiteți diferite tipuri de evenimente în canalele de echipă corespunzătoare
5. **Includeți butoane de acțiune** - Adăugați butoane “View in Brevo” pentru acces rapid la datele clienților
6. **Implementați unfurling** - Afișați previzualizări bogate pentru linkurile Brevo partajate în Slack

## Securitate

- **Token bot** - Token de acces cu scop OAuth cu permisiuni granulare
- **Semnare cereri** - Verificare semnătură HMAC SHA-256 pentru cererile primite
- **OAuth 2.0** - Autorizare standard industrie pentru distribuire multi-spațiu de lucru
- **Criptare TLS** - Toată comunicarea API criptată prin HTTPS
- **Rotație token** - Rotație automată a tokenului pentru securitate îmbunătățită

## Resurse conexe

- [Documentație API Slack](https://api.slack.com/methods)
- [Slack Block Kit Builder](https://app.slack.com/block-kit-builder)
- [Slack Events API](https://api.slack.com/events-api)
- [Conector Brevo](https://tajo.io/ro/docs/connectors/marketing/brevo)
- [Skill Sincronizare clienți](https://tajo.io/ro/docs/skills/data-sync/customer-sync)