Gebruikersidentificatie

Door gebruikers te identificeren koppel je anonieme chatsessies aan echte gebruikersprofielen.

Hoe het werkt

Wanneer je Respondo.identify() aanroept, worden de opgegeven velden aan het gesprek gekoppeld. Alle velden zijn optioneel — geef alleen de velden door die je hebt. Je kunt bijvoorbeeld alleen userId versturen, zonder e-mail of naam. Supportmedewerkers zien deze gegevens in het detailpaneel van het gesprek.

Parameters#

Eigenschap	Type	Vereist	Beschrijving
email	string	optioneel	E-mailadres van de gebruiker
name	string	optioneel	Weergavenaam
userId	string	optioneel	Je interne gebruikers- of weergave-ID — wordt ongewijzigd in het dashboard getoond
userHash	string	optioneel	HMAC-SHA256-handtekening voor identiteitsverificatie
metadata	object	optioneel	Sleutel-waardeparen van aangepaste velden (plan, bedrijf, enz.)
properties	object	optioneel	Aangepaste contacteigenschappen gedefinieerd in Agent Settings. Sleutels moeten overeenkomen met de eigenschapdefinities. Waarden worden opgeslagen met het voorvoegsel `cp_` en zijn filterbaar in de Inbox.

Voorbeeld: Single Page Appjavascript

// Na succesvol inloggen
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: {                        // aangepaste contacteigenschappen
      account_type: user.accountType,    // moet overeenkomen met sleutels uit Agent Settings
      industry: user.industry,
      contract_tier: user.tier
    }
  });
}

Met het standaard installatiefragment kun je identify() op elk moment aanroepen — aanroepen die worden gedaan voordat widget.js klaar is met laden, worden door het fragment in een wachtrij geplaatst en automatisch opnieuw afgespeeld zodra de widget initialiseert. Identiteitsgegevens gaan alleen verloren (met een waarschuwing in de console) als je widget.js zelf laadt en identify() aanroept zonder ooit init() aan te roepen — roep in handmatige opstellingen altijd eerst init() aan.

Anonieme bezoekers#

Als je identify() niet aanroept, kent de widget automatisch een persistente bezoekers-ID toe die wordt opgeslagen in localStorage (sleutel respondoai_visitor_id). In het dashboard verschijnt het gesprek als Guest · Web widget.

Modus	Weergave in dashboard	HMAC vereist
Geen `identify()`	Guest · Web widget	Nee
`identify({ email, name })`	Naam + e-mail getoond	Nee — tenzij Identiteitsverificatie is ingeschakeld; dan worden niet-ondertekende e-mail/naam stilzwijgend verwijderd en blijft de sessie anoniem
`identify({ userId })`	userId ongewijzigd getoond	Nee — tenzij Identiteitsverificatie is ingeschakeld; dan is een geldige `userHash` vereist, anders wordt de identiteit verwijderd
`identify({ userId, userHash })`	Geverifieerde gebruikersidentiteit	Ja — cryptografisch geverifieerd

Wanneer Identiteitsverificatie voor het kanaal is ingeschakeld, wordt elke identify() met een e-mail of userId zonder geldige userHash aan de serverzijde verwijderd en blijft de bezoeker anoniem — zie Identiteitsverificatie (HMAC) hieronder.

De bezoekers-ID blijft behouden over sessies heen in dezelfde browser. Deze wordt nooit als geauthenticeerde identiteit naar Respondo verzonden — hij wordt alleen gebruikt voor continuïteit van anonieme gesprekken.

Identificatie met alleen userId (zonder e-mail of naam)#

Als je platform geen e-mailadressen of namen van gebruikers heeft — bijvoorbeeld als je alleen een interne weergave-ID hebt — kun je alleen userId doorgeven. Er zijn geen andere velden nodig. Het dashboard toont de userId ongewijzigd in de gespreksdetails.

userId + metadata (zonder e-mail of naam)javascript

// Je platform heeft alleen een weergave-ID — dat is genoeg
Respondo.identify({
  userId: user.displayId,      // bijv. "USR-4821" — getoond in het dashboard
  metadata: {                  // optionele extra context
    plan: 'premium',
    region: 'eu-west'
  }
});
// Geen e-mail of naam nodig — de widget werkt met alleen userId

Om vervalsing van de userId te voorkomen, combineer je die met userHash (zie Identiteitsverificatie hieronder). Zonder HMAC kan iedereen via de browserconsole een willekeurige userId doorgeven.

Google Tag Manager / uitgestelde identify()#

Bij het insluiten via GTM zijn de gebruikersgegevens mogelijk niet beschikbaar bij het laden van de pagina. Twee benaderingen:

Optie A: localStorageKey (geen JS nodig)javascript

// Als je platform de gebruikers-ID al naar localStorage schrijft:
Respondo.init({
  agentId: 'YOUR_AGENT_ID',
  localStorageKey: 'myapp_user_id'  // leest automatisch localStorage.getItem('myapp_user_id')
});
// Geen identify()-aanroep nodig — de widget pikt de userId zelf op

Optie B: uitgestelde identify() via dataLayerjavascript

// 1. Initialiseer de widget direct (GTM-tag)
Respondo.init({ agentId: 'YOUR_AGENT_ID' });

// 2. Later, wanneer de gebruikersgegevens verschijnen (bijv. uit dataLayer of je app):
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 wordt alleen gebruikt als er nog geen userId is ingesteld via identify(). Expliciete identify()-aanroepen hebben altijd voorrang.

Identiteitsverificatie (HMAC)#

Zonder verificatie kan iedereen zich voordoen als een gebruiker door een valse userId of email door te geven. Identiteitsverificatie gebruikt HMAC-SHA256 om cryptografisch te bewijzen dat de identiteit van de gebruiker door je server is ingesteld en niet door code aan de clientzijde.

Hoe het werkt#

Schakel Identiteitsverificatie in je kanaalinstellingen in — je krijgt een geheime sleutel.
Bereken op je server HMAC-SHA256(secret, userId) — de secret is de sleutel, de userId het bericht — en stuur het resultaat naar de frontend. Identificeer je gebruikers alleen op e-mail (zonder userId), onderteken dan de e-mail: de ondertekende payload is de userId indien ingesteld, anders de e-mail. Geef je beide door, onderteken dan de userId; die heeft voorrang.
Geef de hash door als userHash in Respondo.identify().
Respondo verifieert de hash aan de serverzijde. Als deze ongeldig is, wordt de identiteit verwijderd en wordt de gebruiker als anoniem behandeld.

Stel je geheime sleutel nooit bloot in frontendcode. De HMAC moet op je backend worden berekend.

Zodra verificatie is ingeschakeld, moet elke identify() die een userId of email bevat een geldige userHash meesturen — anders worden de identiteitsvelden verwijderd en wordt de bezoeker als anoniem behandeld.

Voorbeelden aan de serverzijde#

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

// In je API-endpoint:
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()

# In je view / endpoint:
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))
}

Gebruik in de frontend#

Met identiteitsverificatiejavascript

// Haal de hash op van JE server
const { userHash } = await fetch('/api/respondo-hash').then(r => r.json());

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