---
title: "Slack-kobling"
description: "Fullstendig Slack-integrasjonsveiledning for sending av varslinger, synkronisering av kanaldata og utløsing av Brevo-automatiseringer fra Slack-hendelser via Tajo."
url: https://tajo.io/no/docs/connectors/custom/slack/
markdown: https://tajo.io/no/docs/connectors/custom/slack.md
lang: no-NO
robots: noindex
---

Be om tidlig tilgang

Skriv inn fornavn og e-postadresse på jobb. Vi sender deg en lenke for å bekrefte forespørselen om tilgang til Tajo.

# Slack-kobling

Koblingsstatus: Planlagt Ikke bygget ennå. Tajo kjører ikke denne koblingen i dag.

| Kildefelt | Målfelt | Eksempelverdi |
| --- | --- | --- |
| `record.id` | `source_id` | `record_1042` |
| `record.updated_at` | `updated_at` | `2026-10-18T08:00:00Z` |
| `record.value` | `value` | `sample_value` |

Koble Slack-arbeidsområdet ditt til Brevo via Tajo for sanntidsmarkedsføringsvarslinger, teamvarsler ved kundehendelser og arbeidsflytautomatisering utløst av Slack-interaksjoner.

## Oversikt

| Egenskap | Verdi |
| --- | --- |
| **Plattform** | Slack |
| **Kategori** | Tilpasset integrasjon |
| **Oppsettskompleksitet** | Enkel |
| **Offisiell integrasjon** | Nei |
| **Synkroniserte data** | Brukere, kanaler, meldinger, hendelser |
| **API Base URL** | `https://slack.com/api` |

## Funksjoner

- **Markedsføringsvarsler** - Send sanntidsvarsler for kampanjehendelser, nye abonnenter og inntektsmilepæler
- **Kundehendelsesvarsler** - Varsle team om verdifulle kundehandlinger fra Brevo
- **Arbeidsflytutløsere** - Bruk Slack-interaksjoner (knappeklikk, skjemainnsendinger) for å utløse Brevo-automatiseringer
- **Kanalbasert ruting** - Rut varslinger til bestemte kanaler basert på hendelsestype eller kundesegment
- **Brukersynkronisering** - Mapp Slack-arbeidsområdebrukere til Brevo-kontakter for intern kommunikasjon
- **Interaktive meldinger** - Send rike meldinger med knapper og handlinger for teamarbeidsflyter
- **Planlagte meldinger** - Planlegg varslinger for daglige/ukentlige markedsføringssammendrag
- **Trådstøtte** - Grupper relaterte varslinger i tråder for organisert kommunikasjon

## Forutsetninger

Før du begynner, sørg for at du har:

1. Et Slack-arbeidsområde med administratortilgang
2. En Slack-app opprettet på [api.slack.com/apps](https://api.slack.com/apps)
3. Bot-token med nødvendige scopes
4. En Brevo-konto med API-tilgang
5. En Tajo-konto

## Autentisering

### Bot-token (anbefalt)

Installer en Slack-app i arbeidsområdet ditt og bruk bot-tokenet for API-tilgang.

1. Opprett app på [api.slack.com/apps](https://api.slack.com/apps)
2. Legg til nødvendige OAuth-scopes under “OAuth & Permissions”
3. Installer app i arbeidsområdet
4. Kopier 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

For å distribuere Slack-integrasjonen din til flere arbeidsområder:

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

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

#### Nødvendige bot-scopes

```
chat:write           # Send meldinger
channels:read        # List kanaler
channels:history     # Les kanalmeldinger
users:read           # List arbeidsområdebrukere
users:read.email     # Les brukerens e-postadresser
reactions:write      # Legg til reaksjoner på meldinger
files:write          # Last opp filer
```

Tilgang til brukerens e-post

`users:read.email`-scopet er nødvendig for å matche Slack-brukere med Brevo-kontakter. Uten det vil brukermapping være begrenset til visningsnavn.

## Konfigurasjon

### Grunnleggende oppsett

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

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

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

### Feltmapping

Mapp Slack-brukerdata til Brevo-kontaktattributter:

#### Standardmappinger

| Parameter | Type | Description |
| --- | --- | --- |
| `profile.email` required | string | Brukerens e-post (unik identifikator for Brevo-matching) |
| `real_name` optional | string | Fullt navn, delt i FIRSTNAME/LASTNAME |
| `profile.phone` optional | string | Mappes til SMS-attributt |
| `profile.title` optional | string | Jobbtittel |
| `tz` optional | string | Brukerens tidssone |
| `is_admin` optional | boolean | Administratorstatus i arbeidsområdet |
| `team_id` optional | string | Arbeidsområdets team-ID |
| `status_text` optional | string | Brukerens egendefinerte status |

## API-metoder

### Meldinger

| Metode | Endepunkt | Beskrivelse |
| --- | --- | --- |
| `POST` | `chat.postMessage` | Send en melding til en kanal |
| `POST` | `chat.update` | Oppdater en eksisterende melding |
| `POST` | `chat.delete` | Slett en melding |
| `POST` | `chat.scheduleMessage` | Planlegg en melding |
| `POST` | `chat.postEphemeral` | Send kortvarig melding til bruker |

### Kanaler

| Metode | Endepunkt | Beskrivelse |
| --- | --- | --- |
| `GET` | `conversations.list` | List kanaler |
| `GET` | `conversations.info` | Hent kanalinfo |
| `GET` | `conversations.members` | List kanalmedlemmer |
| `GET` | `conversations.history` | Hent kanalmeldinger |

### Brukere

| Metode | Endepunkt | Beskrivelse |
| --- | --- | --- |
| `GET` | `users.list` | List arbeidsområdebrukere |
| `GET` | `users.info` | Hent brukerinfo |
| `GET` | `users.lookupByEmail` | Finn bruker etter e-post |
| `GET` | `users.conversations` | List brukerens kanaler |

### Interaksjoner

| Metode | Endepunkt | Beskrivelse |
| --- | --- | --- |
| `POST` | `views.open` | Åpne en modal-visning |
| `POST` | `views.update` | Oppdater en modal-visning |
| `POST` | `reactions.add` | Legg til emoji-reaksjon |

## Hendelser

### Brevo-til-Slack-varsler

| Hendelse | Utløser | Slack-handling |
| --- | --- | --- |
| `new_subscriber` | Kontakt opprettet i Brevo | Post til #marketing |
| `campaign_sent` | E-postkampanje sendt | Post sammendrag til #marketing |
| `order_placed` | Verdifull bestilling oppdaget | Post til #sales med detaljer |
| `cart_abandoned` | Handlekurv forlatt i 30 min | Post til #sales for oppfølging |
| `ticket_created` | Supportsak åpnet | Post til #support |
| `unsubscribed` | Kontakt avmeldt | Post varsel til #marketing |

### Slack-til-Brevo-utløsere

| Slack-hendelse | Utløser | Brevo-handling |
| --- | --- | --- |
| `message_action` | Egendefinert meldingsnarvei | Legg kontakt til liste eller utløs automatisering |
| `block_actions` | Knappeklikk i melding | Oppdater kontaktattributt eller send e-post |
| `view_submission` | Modalskjema sendt inn | Opprett kontakt eller utløs arbeidsflyt |

## Kodeeksempler

### Initialiser kobling

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

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

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

### Send markedsføringsvarsler

```javascript
// Send et varsel når en verdifull bestilling legges inn
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'
          }
        ]
      }
    ]
  }
});
```

### Håndter Slack-interaksjoner

```javascript
import crypto from 'crypto';

app.post('/slack/interactions', async (req, res) => {
  // Verifiser Slack-forespørselssignatur
  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);

  // Håndter knappehandlinger
  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();
});
```

## Ratebegrensninger

Slack APIs ratebegrensninger bruker et nivåsystem:

| Nivå | Grense | Vanlige metoder |
| --- | --- | --- |
| Nivå 1 | 1 forespørsel/minutt | `chat.delete`, `conversations.kick` |
| Nivå 2 | 20 forespørsler/minutt | `conversations.history`, `users.info` |
| Nivå 3 | 50 forespørsler/minutt | `conversations.list`, `users.list` |
| Nivå 4 | 100 forespørsler/minutt | `chat.postMessage` |
| Spesial | Varierer | `chat.postMessage` til samme kanal: 1/sek |

Ytterligere grenser:

- **Web API**: Burstgrense med kortvarig struping
- **Events API**: Leveringsforsøk inntil 3 ganger
- **Incoming Webhooks**: 1 melding/sekund per webhook-URL
- **Block Kit**: Maksimalt 50 blokker per melding

Rate for kanalpublisering

Å poste til samme kanal er begrenset til omtrent 1 melding per sekund. Batch varsler eller bruk tråder for å unngå ratebegrensning.

## Feilsøking

### Vanlige problemer

| Problem | Årsak | Løsning |
| --- | --- | --- |
| `not_authed` | Ugyldig bot-token | Installer appen på nytt og kopier nytt bot-token |
| `channel_not_found` | Bot ikke i kanal | Inviter boten til målkanalen |
| `missing_scope` | Nødvendig scope ikke gitt | Legg til scope og installer appen på nytt |
| Hendelse ikke mottatt | Hendelsesabonnement ikke satt | Konfigurer Event Subscriptions-URL |
| Interaksjonstidsavbrudd | Respons >3 sekunder | Svar med 200 umiddelbart, behandle asynkront |

### Feilsøkingsmodus

Aktiver utvidet logging:

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

### Test tilkobling

```bash
tajo connectors test slack
# ✓ Bot-token gyldig
# ✓ Arbeidsområde tilgjengelig
# ✓ Kanaler lesbare
# ✓ Meldingspublisering aktivert
# ✓ Hendelsesabonnementer aktive
```

## Beste praksis

1. **Bruk Block Kit** - Bygg rike, interaktive meldinger med Slacks Block Kit-rammeverk
2. **Svar raskt** - Bekreft interaksjoner innen 3 sekunder, behandle asynkront
3. **Trådkoble relaterte meldinger** - Grupper relaterte varslinger i tråder for å redusere støy
4. **Rut etter kanal** - Send ulike hendelsestyper til passende teamkanaler
5. **Inkluder handlingsknapper** - Legg til “View in Brevo”-knapper for rask tilgang til kundedata
6. **Implementer unfurling** - Vis rike forhåndsvisninger for Brevo-lenker delt i Slack

## Sikkerhet

- **Bot-token** - OAuth-avgrenset tilgangstoken med granulære rettigheter
- **Forespørselssignering** - HMAC SHA-256-signaturverifisering for innkommende forespørsler
- **OAuth 2.0** - Bransjestandard autorisasjon for distribusjon til flere arbeidsområder
- **TLS-kryptering** - All API-kommunikasjon kryptert via HTTPS
- **Tokenrotasjon** - Automatisk tokenrotasjon for økt sikkerhet

## Relaterte ressurser

- [Slack API-dokumentasjon](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)
- [Brevo-kobling](https://tajo.io/no/docs/connectors/marketing/brevo)
- [Customer Sync-ferdighet](https://tajo.io/no/docs/skills/data-sync/customer-sync)