---
read_when:
    - Configurer Mattermost
    - Débogage du routage Mattermost
sidebarTitle: Mattermost
summary: Configuration du bot Mattermost et configuration d’OpenClaw
title: Mattermost
x-i18n:
    generated_at: "2026-05-02T06:59:16Z"
    model: gpt-5.5
    provider: openai
    source_hash: 319af8ba1cb8ff1aa5b52a57e809e6c76d3723012dc9cae7c456b89687dd6810
    source_path: channels/mattermost.md
    workflow: 16
---

Statut : plugin téléchargeable (jeton de bot + événements WebSocket). Les canaux, groupes et MP sont pris en charge. Mattermost est une plateforme de messagerie d’équipe auto-hébergeable ; consultez le site officiel sur [mattermost.com](https://mattermost.com) pour les détails du produit et les téléchargements.

## Installation

Installez Mattermost avant de configurer le canal :

<Tabs>
  <Tab title="npm registry">
    ```bash
    openclaw plugins install @openclaw/mattermost
    ```
  </Tab>
  <Tab title="Local checkout">
    ```bash
    openclaw plugins install ./path/to/local/mattermost-plugin
    ```
  </Tab>
</Tabs>

Détails : [Plugins](/fr/tools/plugin)

## Configuration rapide

<Steps>
  <Step title="Ensure plugin is available">
    Les versions packagées actuelles d’OpenClaw l’intègrent déjà. Les installations plus anciennes ou personnalisées peuvent l’ajouter manuellement avec les commandes ci-dessus.
  </Step>
  <Step title="Create a Mattermost bot">
    Créez un compte de bot Mattermost et copiez le **jeton de bot**.
  </Step>
  <Step title="Copy the base URL">
    Copiez l’**URL de base** Mattermost (par exemple, `https://chat.example.com`).
  </Step>
  <Step title="Configure OpenClaw and start the gateway">
    Configuration minimale :

    ```json5
    {
      channels: {
        mattermost: {
          enabled: true,
          botToken: "mm-token",
          baseUrl: "https://chat.example.com",
          dmPolicy: "pairing",
        },
      },
    }
    ```

  </Step>
</Steps>

## Commandes slash natives

Les commandes slash natives sont facultatives. Lorsqu’elles sont activées, OpenClaw enregistre les commandes slash `oc_*` via l’API Mattermost et reçoit les POST de rappel sur le serveur HTTP du Gateway.

```json5
{
  channels: {
    mattermost: {
      commands: {
        native: true,
        nativeSkills: true,
        callbackPath: "/api/channels/mattermost/command",
        // Use when Mattermost cannot reach the gateway directly (reverse proxy/public URL).
        callbackUrl: "https://gateway.example.com/api/channels/mattermost/command",
      },
    },
  },
}
```

<AccordionGroup>
  <Accordion title="Behavior notes">
    - `native: "auto"` est désactivé par défaut pour Mattermost. Définissez `native: true` pour l’activer.
    - Si `callbackUrl` est omis, OpenClaw en déduit un à partir de l’hôte/du port du Gateway + `callbackPath`.
    - Pour les configurations à plusieurs comptes, `commands` peut être défini au niveau supérieur ou sous `channels.mattermost.accounts.<id>.commands` (les valeurs du compte remplacent les champs de niveau supérieur).
    - Les rappels de commande sont validés avec les jetons propres à chaque commande renvoyés par Mattermost quand OpenClaw enregistre les commandes `oc_*`.
    - OpenClaw actualise l’enregistrement actuel des commandes Mattermost avant d’accepter chaque rappel, afin que les jetons obsolètes issus de commandes slash supprimées ou régénérées cessent d’être acceptés sans redémarrage du Gateway.
    - La validation des rappels échoue de manière fermée si l’API Mattermost ne peut pas confirmer que la commande est toujours actuelle ; les validations échouées sont brièvement mises en cache, les recherches concurrentes sont fusionnées, et les nouveaux lancements de recherche sont limités en débit par commande afin de borner la pression de rejeu.
    - Les rappels slash échouent de manière fermée lorsque l’enregistrement a échoué, que le démarrage a été partiel, ou que le jeton de rappel ne correspond pas au jeton enregistré de la commande résolue (un jeton valide pour une commande ne peut pas atteindre la validation amont pour une autre commande).

  </Accordion>
  <Accordion title="Reachability requirement">
    Le point de terminaison de rappel doit être accessible depuis le serveur Mattermost.

    - Ne définissez pas `callbackUrl` sur `localhost`, sauf si Mattermost s’exécute sur le même hôte/espace de noms réseau qu’OpenClaw.
    - Ne définissez pas `callbackUrl` sur votre URL de base Mattermost, sauf si cette URL relaie `/api/channels/mattermost/command` vers OpenClaw via un reverse proxy.
    - Une vérification rapide consiste à exécuter `curl https://<gateway-host>/api/channels/mattermost/command` ; une requête GET doit renvoyer `405 Method Not Allowed` depuis OpenClaw, pas `404`.

  </Accordion>
  <Accordion title="Mattermost egress allowlist">
    Si votre rappel cible des adresses privées/tailnet/internes, définissez `ServiceSettings.AllowedUntrustedInternalConnections` dans Mattermost pour inclure l’hôte/le domaine de rappel.

    Utilisez des entrées d’hôte/domaine, pas des URL complètes.

    - Correct : `gateway.tailnet-name.ts.net`
    - Incorrect : `https://gateway.tailnet-name.ts.net`

  </Accordion>
</AccordionGroup>

## Variables d’environnement (compte par défaut)

Définissez-les sur l’hôte du Gateway si vous préférez les variables d’environnement :

- `MATTERMOST_BOT_TOKEN=...`
- `MATTERMOST_URL=https://chat.example.com`

<Note>
Les variables d’environnement s’appliquent uniquement au compte **par défaut** (`default`). Les autres comptes doivent utiliser des valeurs de configuration.

`MATTERMOST_URL` ne peut pas être défini depuis un fichier `.env` d’espace de travail ; consultez [Fichiers `.env` d’espace de travail](/fr/gateway/security).
</Note>

## Modes de discussion

Mattermost répond automatiquement aux MP. Le comportement des canaux est contrôlé par `chatmode` :

<Tabs>
  <Tab title="oncall (default)">
    Répond uniquement lorsqu’il est @mentionné dans les canaux.
  </Tab>
  <Tab title="onmessage">
    Répond à chaque message de canal.
  </Tab>
  <Tab title="onchar">
    Répond lorsqu’un message commence par un préfixe déclencheur.
  </Tab>
</Tabs>

Exemple de configuration :

```json5
{
  channels: {
    mattermost: {
      chatmode: "onchar",
      oncharPrefixes: [">", "!"],
    },
  },
}
```

Notes :

- `onchar` répond toujours aux @mentions explicites.
- `channels.mattermost.requireMention` est respecté pour les anciennes configurations, mais `chatmode` est préférable.

## Fils de discussion et sessions

Utilisez `channels.mattermost.replyToMode` pour contrôler si les réponses dans les canaux et les groupes restent dans le canal principal ou démarrent un fil sous la publication déclencheuse.

- `off` (par défaut) : répond dans un fil uniquement lorsque la publication entrante s’y trouve déjà.
- `first` : pour les publications de canal/groupe de premier niveau, démarre un fil sous cette publication et achemine la conversation vers une session limitée au fil.
- `all` : même comportement que `first` pour Mattermost aujourd’hui.
- Les messages directs ignorent ce paramètre et restent sans fil.

Exemple de configuration :

```json5
{
  channels: {
    mattermost: {
      replyToMode: "all",
    },
  },
}
```

Notes :

- Les sessions limitées au fil utilisent l’identifiant de la publication déclencheuse comme racine du fil.
- `first` et `all` sont actuellement équivalents, car une fois que Mattermost dispose d’une racine de fil, les fragments de suivi et les médias continuent dans ce même fil.

## Contrôle d’accès (MP)

- Par défaut : `channels.mattermost.dmPolicy = "pairing"` (les expéditeurs inconnus reçoivent un code d’association).
- Approuvez via :
  - `openclaw pairing list mattermost`
  - `openclaw pairing approve mattermost <CODE>`
- MP publics : `channels.mattermost.dmPolicy="open"` plus `channels.mattermost.allowFrom=["*"]`.

## Canaux (groupes)

- Par défaut : `channels.mattermost.groupPolicy = "allowlist"` (soumis aux mentions).
- Autorisez les expéditeurs avec `channels.mattermost.groupAllowFrom` (identifiants utilisateur recommandés).
- Les remplacements de mention par canal se trouvent sous `channels.mattermost.groups.<channelId>.requireMention` ou `channels.mattermost.groups["*"].requireMention` pour une valeur par défaut.
- La correspondance `@username` est mutable et activée uniquement lorsque `channels.mattermost.dangerouslyAllowNameMatching: true`.
- Canaux ouverts : `channels.mattermost.groupPolicy="open"` (soumis aux mentions).
- Note d’exécution : si `channels.mattermost` est complètement absent, l’exécution revient à `groupPolicy="allowlist"` pour les vérifications de groupe (même si `channels.defaults.groupPolicy` est défini).

Exemple :

```json5
{
  channels: {
    mattermost: {
      groupPolicy: "open",
      groups: {
        "*": { requireMention: true },
        "team-channel-id": { requireMention: false },
      },
    },
  },
}
```

## Cibles pour la livraison sortante

Utilisez ces formats de cible avec `openclaw message send` ou les Cron/webhooks :

- `channel:<id>` pour un canal
- `user:<id>` pour un MP
- `@username` pour un MP (résolu via l’API Mattermost)

<Warning>
Les identifiants opaques nus (comme `64ifufp...`) sont **ambigus** dans Mattermost (identifiant utilisateur ou identifiant de canal).

OpenClaw les résout **utilisateur d’abord** :

- Si l’identifiant existe comme utilisateur (`GET /api/v4/users/<id>` réussit), OpenClaw envoie un **MP** en résolvant le canal direct via `/api/v4/channels/direct`.
- Sinon, l’identifiant est traité comme un **identifiant de canal**.

Si vous avez besoin d’un comportement déterministe, utilisez toujours les préfixes explicites (`user:<id>` / `channel:<id>`).
</Warning>

## Nouvelle tentative de canal MP

Quand OpenClaw envoie vers une cible MP Mattermost et doit d’abord résoudre le canal direct, il retente par défaut les échecs transitoires de création de canal direct.

Utilisez `channels.mattermost.dmChannelRetry` pour ajuster ce comportement globalement pour le plugin Mattermost, ou `channels.mattermost.accounts.<id>.dmChannelRetry` pour un compte.

```json5
{
  channels: {
    mattermost: {
      dmChannelRetry: {
        maxRetries: 3,
        initialDelayMs: 1000,
        maxDelayMs: 10000,
        timeoutMs: 30000,
      },
    },
  },
}
```

Notes :

- Cela s’applique uniquement à la création de canal MP (`/api/v4/channels/direct`), pas à chaque appel de l’API Mattermost.
- Les nouvelles tentatives s’appliquent aux échecs transitoires tels que les limites de débit, les réponses 5xx et les erreurs réseau ou d’expiration.
- Les erreurs client 4xx autres que `429` sont traitées comme permanentes et ne sont pas retentées.

## Diffusion d’aperçu

Mattermost diffuse le raisonnement, l’activité des outils et le texte de réponse partiel dans une seule **publication d’aperçu brouillon** qui est finalisée sur place lorsque la réponse finale peut être envoyée sans risque. L’aperçu se met à jour sur le même identifiant de publication au lieu d’inonder le canal avec des messages par fragment. Les finaux de média/erreur annulent les modifications d’aperçu en attente et utilisent la livraison normale au lieu de vider une publication d’aperçu jetable.

Activez via `channels.mattermost.streaming` :

```json5
{
  channels: {
    mattermost: {
      streaming: "partial", // off | partial | block | progress
    },
  },
}
```

<AccordionGroup>
  <Accordion title="Streaming modes">
    - `partial` est le choix habituel : une publication d’aperçu modifiée à mesure que la réponse s’allonge, puis finalisée avec la réponse complète.
    - `block` utilise des fragments brouillons de type ajout dans la publication d’aperçu.
    - `progress` affiche un aperçu de statut pendant la génération et ne publie la réponse finale qu’à la fin.
    - `off` désactive la diffusion d’aperçu.

  </Accordion>
  <Accordion title="Streaming behavior notes">
    - Si le flux ne peut pas être finalisé sur place (par exemple si la publication a été supprimée en cours de flux), OpenClaw revient à l’envoi d’une nouvelle publication finale afin que la réponse ne soit jamais perdue.
    - Les charges utiles contenant uniquement du raisonnement sont supprimées des publications de canal, y compris le texte qui arrive sous forme de citation `> Reasoning:`. Définissez `/reasoning on` pour voir le raisonnement dans d’autres surfaces ; la publication finale Mattermost ne conserve que la réponse.
    - Consultez [Diffusion](/fr/concepts/streaming#preview-streaming-modes) pour la matrice de correspondance des canaux.

  </Accordion>
</AccordionGroup>

## Réactions (outil de message)

- Utilisez `message action=react` avec `channel=mattermost`.
- `messageId` est l’identifiant de publication Mattermost.
- `emoji` accepte des noms comme `thumbsup` ou `:+1:` (les deux-points sont facultatifs).
- Définissez `remove=true` (booléen) pour supprimer une réaction.
- Les événements d’ajout/suppression de réaction sont transmis comme événements système à la session d’agent routée.

Exemples :

```
message action=react channel=mattermost target=channel:<channelId> messageId=<postId> emoji=thumbsup
message action=react channel=mattermost target=channel:<channelId> messageId=<postId> emoji=thumbsup remove=true
```

Configuration :

- `channels.mattermost.actions.reactions` : active/désactive les actions de réaction (true par défaut).
- Remplacement par compte : `channels.mattermost.accounts.<id>.actions.reactions`.

## Boutons interactifs (outil de message)

Envoyez des messages avec des boutons cliquables. Lorsqu’un utilisateur clique sur un bouton, l’agent reçoit la sélection et peut répondre.

Activez les boutons en ajoutant `inlineButtons` aux capacités du canal :

```json5
{
  channels: {
    mattermost: {
      capabilities: ["inlineButtons"],
    },
  },
}
```

Utilisez `message action=send` avec un paramètre `buttons`. Les boutons sont un tableau 2D (lignes de boutons) :

```
message action=send channel=mattermost target=channel:<channelId> buttons=[[{"text":"Yes","callback_data":"yes"},{"text":"No","callback_data":"no"}]]
```

Champs des boutons :

<ParamField path="text" type="string" required>
  Libellé d’affichage.
</ParamField>
<ParamField path="callback_data" type="string" required>
  Valeur renvoyée au clic (utilisée comme ID d’action).
</ParamField>
<ParamField path="style" type='"default" | "primary" | "danger"'>
  Style du bouton.
</ParamField>

Lorsqu’un utilisateur clique sur un bouton :

<Steps>
  <Step title="Buttons replaced with confirmation">
    Tous les boutons sont remplacés par une ligne de confirmation (par exemple, "✓ **Yes** selected by @user").
  </Step>
  <Step title="Agent receives the selection">
    L’agent reçoit la sélection sous forme de message entrant et répond.
  </Step>
</Steps>

<AccordionGroup>
  <Accordion title="Implementation notes">
    - Les rappels de boutons utilisent la vérification HMAC-SHA256 (automatique, aucune configuration requise).
    - Mattermost retire les données de rappel de ses réponses d’API (fonctionnalité de sécurité), donc tous les boutons sont supprimés au clic — la suppression partielle n’est pas possible.
    - Les ID d’action contenant des traits d’union ou des tirets bas sont assainis automatiquement (limitation du routage Mattermost).

  </Accordion>
  <Accordion title="Config and reachability">
    - `channels.mattermost.capabilities` : tableau de chaînes de capacité. Ajoutez `"inlineButtons"` pour activer la description de l’outil de boutons dans l’invite système de l’agent.
    - `channels.mattermost.interactions.callbackBaseUrl` : URL de base externe facultative pour les rappels de boutons (par exemple `https://gateway.example.com`). Utilisez-la lorsque Mattermost ne peut pas atteindre directement le Gateway à son hôte de liaison.
    - Dans les configurations multi-comptes, vous pouvez également définir le même champ sous `channels.mattermost.accounts.<id>.interactions.callbackBaseUrl`.
    - Si `interactions.callbackBaseUrl` est omis, OpenClaw dérive l’URL de rappel à partir de `gateway.customBindHost` + `gateway.port`, puis se rabat sur `http://localhost:<port>`.
    - Règle d’accessibilité : l’URL de rappel du bouton doit être accessible depuis le serveur Mattermost. `localhost` ne fonctionne que lorsque Mattermost et OpenClaw s’exécutent sur le même hôte/espace de noms réseau.
    - Si votre cible de rappel est privée/tailnet/interne, ajoutez son hôte/domaine à Mattermost `ServiceSettings.AllowedUntrustedInternalConnections`.

  </Accordion>
</AccordionGroup>

### Intégration API directe (scripts externes)

Les scripts externes et les webhooks peuvent publier des boutons directement via l’API REST Mattermost au lieu de passer par l’outil `message` de l’agent. Utilisez `buildButtonAttachments()` depuis le plugin lorsque c’est possible ; si vous publiez du JSON brut, suivez ces règles :

**Structure de charge utile :**

```json5
{
  channel_id: "<channelId>",
  message: "Choose an option:",
  props: {
    attachments: [
      {
        actions: [
          {
            id: "mybutton01", // alphanumeric only — see below
            type: "button", // required, or clicks are silently ignored
            name: "Approve", // display label
            style: "primary", // optional: "default", "primary", "danger"
            integration: {
              url: "https://gateway.example.com/mattermost/interactions/default",
              context: {
                action_id: "mybutton01", // must match button id (for name lookup)
                action: "approve",
                // ... any custom fields ...
                _token: "<hmac>", // see HMAC section below
              },
            },
          },
        ],
      },
    ],
  },
}
```

<Warning>
**Règles critiques**

1. Les pièces jointes vont dans `props.attachments`, pas dans `attachments` au niveau racine (ignoré silencieusement).
2. Chaque action a besoin de `type: "button"` — sans cela, les clics sont absorbés silencieusement.
3. Chaque action a besoin d’un champ `id` — Mattermost ignore les actions sans ID.
4. L’action `id` doit être **alphanumérique uniquement** (`[a-zA-Z0-9]`). Les traits d’union et les tirets bas cassent le routage des actions côté serveur de Mattermost (renvoie 404). Supprimez-les avant utilisation.
5. `context.action_id` doit correspondre à l’`id` du bouton afin que le message de confirmation affiche le nom du bouton (par exemple, "Approve") au lieu d’un ID brut.
6. `context.action_id` est requis — le gestionnaire d’interaction renvoie 400 sans lui.

</Warning>

**Génération de jeton HMAC**

Le Gateway vérifie les clics sur les boutons avec HMAC-SHA256. Les scripts externes doivent générer des jetons correspondant à la logique de vérification du Gateway :

<Steps>
  <Step title="Derive the secret from the bot token">
    `HMAC-SHA256(key="openclaw-mattermost-interactions", data=botToken)`
  </Step>
  <Step title="Build the context object">
    Construisez l’objet de contexte avec tous les champs **sauf** `_token`.
  </Step>
  <Step title="Serialize with sorted keys">
    Sérialisez avec des **clés triées** et **sans espaces** (le Gateway utilise `JSON.stringify` avec des clés triées, ce qui produit une sortie compacte).
  </Step>
  <Step title="Sign the payload">
    `HMAC-SHA256(key=secret, data=serializedContext)`
  </Step>
  <Step title="Add the token">
    Ajoutez le condensat hexadécimal résultant comme `_token` dans le contexte.
  </Step>
</Steps>

Exemple Python :

```python
import hmac, hashlib, json

secret = hmac.new(
    b"openclaw-mattermost-interactions",
    bot_token.encode(), hashlib.sha256
).hexdigest()

ctx = {"action_id": "mybutton01", "action": "approve"}
payload = json.dumps(ctx, sort_keys=True, separators=(",", ":"))
token = hmac.new(secret.encode(), payload.encode(), hashlib.sha256).hexdigest()

context = {**ctx, "_token": token}
```

<AccordionGroup>
  <Accordion title="Common HMAC pitfalls">
    - Python `json.dumps` ajoute des espaces par défaut (`{"key": "val"}`). Utilisez `separators=(",", ":")` pour correspondre à la sortie compacte de JavaScript (`{"key":"val"}`).
    - Signez toujours **tous** les champs de contexte (moins `_token`). Le Gateway retire `_token`, puis signe tout ce qui reste. Signer un sous-ensemble provoque un échec de vérification silencieux.
    - Utilisez `sort_keys=True` — le Gateway trie les clés avant de signer, et Mattermost peut réordonner les champs de contexte lors du stockage de la charge utile.
    - Dérivez le secret du jeton du bot (déterministe), et non d’octets aléatoires. Le secret doit être identique dans le processus qui crée les boutons et dans le Gateway qui vérifie.

  </Accordion>
</AccordionGroup>

## Adaptateur d’annuaire

Le plugin Mattermost inclut un adaptateur d’annuaire qui résout les noms de canaux et d’utilisateurs via l’API Mattermost. Cela active les cibles `#channel-name` et `@username` dans `openclaw message send` et les livraisons cron/webhook.

Aucune configuration n’est nécessaire — l’adaptateur utilise le jeton du bot issu de la configuration du compte.

## Multi-compte

Mattermost prend en charge plusieurs comptes sous `channels.mattermost.accounts` :

```json5
{
  channels: {
    mattermost: {
      accounts: {
        default: { name: "Primary", botToken: "mm-token", baseUrl: "https://chat.example.com" },
        alerts: { name: "Alerts", botToken: "mm-token-2", baseUrl: "https://alerts.example.com" },
      },
    },
  },
}
```

## Dépannage

<AccordionGroup>
  <Accordion title="No replies in channels">
    Assurez-vous que le bot est dans le canal et mentionnez-le (oncall), utilisez un préfixe de déclenchement (onchar), ou définissez `chatmode: "onmessage"`.
  </Accordion>
  <Accordion title="Auth or multi-account errors">
    - Vérifiez le jeton du bot, l’URL de base et si le compte est activé.
    - Problèmes multi-comptes : les variables d’environnement ne s’appliquent qu’au compte `default`.

  </Accordion>
  <Accordion title="Native slash commands fail">
    - `Unauthorized: invalid command token.` : OpenClaw n’a pas accepté le jeton de rappel. Causes typiques :
      - l’enregistrement de la commande slash a échoué ou ne s’est terminé que partiellement au démarrage
      - le rappel atteint le mauvais Gateway/compte
      - Mattermost possède encore d’anciennes commandes pointant vers une cible de rappel précédente
      - le Gateway a redémarré sans réactiver les commandes slash
    - Si les commandes slash natives cessent de fonctionner, consultez les journaux pour `mattermost: failed to register slash commands` ou `mattermost: native slash commands enabled but no commands could be registered`.
    - Si `callbackUrl` est omis et que les journaux avertissent que le rappel a été résolu vers `http://127.0.0.1:18789/...`, cette URL n’est probablement accessible que lorsque Mattermost s’exécute sur le même hôte/espace de noms réseau qu’OpenClaw. Définissez plutôt un `commands.callbackUrl` explicitement accessible depuis l’extérieur.

  </Accordion>
  <Accordion title="Buttons issues">
    - Les boutons apparaissent sous forme de boîtes blanches : l’agent envoie peut-être des données de bouton mal formées. Vérifiez que chaque bouton possède à la fois les champs `text` et `callback_data`.
    - Les boutons s’affichent mais les clics ne font rien : vérifiez que `AllowedUntrustedInternalConnections` dans la configuration du serveur Mattermost inclut `127.0.0.1 localhost`, et que `EnablePostActionIntegration` vaut `true` dans ServiceSettings.
    - Les boutons renvoient 404 au clic : l’`id` du bouton contient probablement des traits d’union ou des tirets bas. Le routeur d’action de Mattermost casse sur les ID non alphanumériques. Utilisez uniquement `[a-zA-Z0-9]`.
    - Les journaux du Gateway indiquent `invalid _token` : non-correspondance HMAC. Vérifiez que vous signez tous les champs de contexte (pas un sous-ensemble), que vous utilisez des clés triées et du JSON compact (sans espaces). Consultez la section HMAC ci-dessus.
    - Les journaux du Gateway indiquent `missing _token in context` : le champ `_token` n’est pas dans le contexte du bouton. Assurez-vous qu’il est inclus lors de la construction de la charge utile d’intégration.
    - La confirmation affiche l’ID brut au lieu du nom du bouton : `context.action_id` ne correspond pas à l’`id` du bouton. Définissez les deux sur la même valeur assainie.
    - L’agent ne connaît pas les boutons : ajoutez `capabilities: ["inlineButtons"]` à la configuration du canal Mattermost.

  </Accordion>
</AccordionGroup>

## Connexe

- [Routage des canaux](/fr/channels/channel-routing) — routage de session pour les messages
- [Aperçu des canaux](/fr/channels) — tous les canaux pris en charge
- [Groupes](/fr/channels/groups) — comportement des discussions de groupe et filtrage des mentions
- [Appairage](/fr/channels/pairing) — authentification par MP et flux d’appairage
- [Sécurité](/fr/gateway/security) — modèle d’accès et durcissement
