Identification des utilisateurs

L’identification des utilisateurs relie les sessions de chat anonymes à de véritables profils d’utilisateurs.

Comment ça fonctionne

Lorsque vous appelez Respondo.identify(), les champs fournis sont rattachés à la conversation. Tous les champs sont facultatifs — ne transmettez que ceux dont vous disposez. Par exemple, vous pouvez n’envoyer que userId sans e-mail ni nom. Les agents du support voient ces données dans le panneau de détails de la conversation.

Paramètres#

Propriété	Type	Requis	Description
email	string	facultatif	Adresse e-mail de l’utilisateur
name	string	facultatif	Nom affiché
userId	string	facultatif	Votre ID utilisateur interne ou d’affichage — affiché tel quel dans le tableau de bord
userHash	string	facultatif	Signature HMAC-SHA256 pour la vérification d’identité
metadata	object	facultatif	Paires clé-valeur de champs personnalisés (plan, entreprise, etc.)
properties	object	facultatif	Propriétés de contact personnalisées définies dans les Paramètres de l’agent. Les clés doivent correspondre aux définitions de propriétés. Les valeurs sont stockées avec le préfixe `cp_` et sont filtrables dans la boîte de réception.

Exemple : application monopage (SPA)javascript

// Après une connexion réussie
async function onLogin(user) {
  await authenticateUser(user);

  Respondo.identify({
    email: user.email,
    name: user.fullName,
    userId: user.id,
    metadata: {
      plan: user.subscription.plan,
      company: user.company.name,
      role: user.role,
      signedUp: user.createdAt
    },
    properties: {                        // propriétés de contact personnalisées
      account_type: user.accountType,    // doit correspondre aux clés des Paramètres de l’agent
      industry: user.industry,
      contract_tier: user.tier
    }
  });
}

Avec l’extrait d’installation standard, vous pouvez appeler identify() à tout moment — les appels effectués avant la fin du chargement de widget.js sont mis en file d’attente par l’extrait et rejoués automatiquement une fois le widget initialisé. Les données d’identité ne sont perdues (avec un avertissement dans la console) que si vous chargez widget.js vous-même et appelez identify() avant tout appel à init() — dans les configurations manuelles, appelez toujours init() en premier.

Visiteurs anonymes#

Si vous n’appelez pas identify(), le widget attribue automatiquement un ID de visiteur persistant stocké dans localStorage (clé respondoai_visitor_id). Dans le tableau de bord, la conversation apparaît sous la forme Guest · Web widget.

Mode	Affichage dans le tableau de bord	HMAC requis
Aucun `identify()`	Guest · Web widget	Non
`identify({ email, name })`	Nom + e-mail affichés	Non — sauf si la Vérification d’identité est activée ; l’e-mail et le nom non signés sont alors silencieusement supprimés et la session reste anonyme
`identify({ userId })`	userId affiché tel quel	Non — sauf si la Vérification d’identité est activée ; un `userHash` valide est alors requis, sinon l’identité est supprimée
`identify({ userId, userHash })`	Identité utilisateur vérifiée	Oui — vérifié cryptographiquement

Lorsque la Vérification d’identité est activée pour le canal, tout appel à identify() transmettant un e-mail ou un userId sans userHash valide est supprimé côté serveur et le visiteur reste anonyme — voir la Vérification d’identité (HMAC) ci-dessous.

L’ID de visiteur persiste d’une session à l’autre sur le même navigateur. Il n’est jamais envoyé à Respondo en tant qu’identité authentifiée — il sert uniquement à la continuité des conversations anonymes.

Identification par userId uniquement (sans e-mail ni nom)#

Si votre plateforme ne dispose pas des e-mails ou des noms d’utilisateurs — par exemple, vous n’avez qu’un ID d’affichage interne — vous pouvez ne transmettre que userId. Aucun autre champ n’est nécessaire. Le tableau de bord affichera le userId tel quel dans les détails de la conversation.

userId + metadata (sans e-mail ni nom)javascript

// Votre plateforme n’a qu’un ID d’affichage — c’est suffisant
Respondo.identify({
  userId: user.displayId,      // ex. « USR-4821 » — affiché dans le tableau de bord
  metadata: {                  // contexte supplémentaire facultatif
    plan: 'premium',
    region: 'eu-west'
  }
});
// Aucun e-mail ni nom requis — le widget fonctionne avec le seul userId

Pour empêcher l’usurpation du userId, associez-le à userHash (voir la Vérification d’identité ci-dessous). Sans HMAC, n’importe qui peut transmettre n’importe quel userId depuis la console du navigateur.

Google Tag Manager / identify() différé#

Lors de l’intégration via GTM, les données utilisateur peuvent ne pas être disponibles au chargement de la page. Deux approches :

Option A : localStorageKey (aucun JS requis)javascript

// Si votre plateforme écrit déjà l’ID utilisateur dans localStorage :
Respondo.init({
  agentId: 'YOUR_AGENT_ID',
  localStorageKey: 'myapp_user_id'  // lit automatiquement localStorage.getItem('myapp_user_id')
});
// Aucun appel à identify() requis — le widget récupère le userId de lui-même

Option B : identify() différé via dataLayerjavascript

// 1. Initialisez le widget immédiatement (tag GTM)
Respondo.init({ agentId: 'YOUR_AGENT_ID' });

// 2. Plus tard, quand les données utilisateur apparaissent (ex. depuis dataLayer ou votre application) :
var waitForUser = setInterval(function() {
  var uid = localStorage.getItem('myapp_user_id');
  if (uid && window.Respondo && typeof window.Respondo.identify === 'function') {
    clearInterval(waitForUser);
    Respondo.identify({ userId: uid });
  }
}, 500);

localStorageKey n’est utilisé que si aucun userId n’a déjà été défini via identify(). Les appels explicites à identify() ont toujours la priorité.

Vérification d’identité (HMAC)#

Sans vérification, n’importe qui pourrait se faire passer pour un utilisateur en transmettant un userId ou un email falsifié. La Vérification d’identité utilise HMAC-SHA256 pour prouver cryptographiquement que l’identité de l’utilisateur a été définie par votre serveur, et non par du code côté client.

Comment ça fonctionne#

Activez la Vérification d’identité dans les paramètres de votre canal — vous obtiendrez une clé secrète.
Sur votre serveur, calculez HMAC-SHA256(secret, userId) — le secret est la clé, le userId est le message — et envoyez le résultat au frontend. Si vous identifiez les utilisateurs uniquement par e-mail (sans userId), signez l’e-mail à la place : la charge signée est le userId lorsqu’il est défini, sinon l’e-mail. Si vous transmettez les deux, signez le userId ; il est prioritaire.
Transmettez le hash en tant que userHash dans Respondo.identify().
Respondo vérifie le hash côté serveur. S’il est invalide, l’identité est supprimée et l’utilisateur est traité comme anonyme.

N’exposez jamais votre clé secrète dans le code frontend. Le HMAC doit être calculé sur votre backend.

Une fois la vérification activée, chaque appel à identify() transmettant userId ou email doit inclure un userHash valide — sinon les champs d’identité sont supprimés et le visiteur est traité comme anonyme.

Exemples côté serveur#

Node.jsjavascript

const crypto = require('crypto');

const SECRET = process.env.RESPONDO_IDENTITY_SECRET;

function generateUserHash(userId) {
  return crypto
    .createHmac('sha256', SECRET)
    .update(userId)
    .digest('hex');
}

// Dans votre point d’accès API :
app.get('/api/respondo-hash', (req, res) => {
  const hash = generateUserHash(req.user.id);
  res.json({ userHash: hash });
});

Pythonpython

import hmac, hashlib, os

SECRET = os.environ['RESPONDO_IDENTITY_SECRET']

def generate_user_hash(user_id: str) -> str:
    return hmac.new(
        SECRET.encode(),
        user_id.encode(),
        hashlib.sha256
    ).hexdigest()

# Dans votre vue / point d’accès :
user_hash = generate_user_hash(request.user.id)

Gogo

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
)

func GenerateUserHash(userID, secret string) string {
    mac := hmac.New(sha256.New, []byte(secret))
    mac.Write([]byte(userID))
    return hex.EncodeToString(mac.Sum(nil))
}

Utilisation côté frontend#

Avec Vérification d’identitéjavascript

// Récupérez le hash depuis VOTRE serveur
const { userHash } = await fetch('/api/respondo-hash').then(r => r.json());

Respondo.identify({
  email: user.email,
  name: user.name,
  userId: user.id,
  userHash: userHash  // signature HMAC-SHA256
});