Webhooks

1
curl -X POST https://api.hume.ai/v0/evi/configs \
2
  -H "X-Hume-Api-Key: <YOUR_API_KEY>" \
3
  -H "Content-Type: application/json" \
4
  -d '{
5
    "evi_version": "2",
6
    "name": "Sample Webhook Config",
7
    "webhooks": [{
8
      "url": <YOUR_WEBHOOK_URL>,
9
      "events": ["chat_started", "chat_ended"]
10
    }]
11
  }'

1
import { WebhookEvent } from "hume/serialization/resources/empathicVoice/types/WebhookEvent";
2
3
// Route to handle webhook events
4
app.post("/hume-webhook", (req: Request, res: Response) => {
5
  // Validate and parse using WebhookEvent
6
  const event = WebhookEvent.parseOrThrow(JSON.parse(req.body));
7
8
  try {
9
    // Handle the specific event type
10
    switch (event.eventName) {
11
      case 'chat_started':
12
        console.info('Processing chat_started event:', event);
13
        // Add additional chat_started processing logic here
14
        break;
15
      
16
      case 'chat_ended':
17
        console.info("Processing chat_ended event:", event);
18
        // Add additional chat_ended processing logic here
19
        break;
20
21
      default:
22
        console.warn(`[Event Handling] Unsupported event type: '${event.eventName}'`);
23
        res.status(400).json({ error: `Unsupported event type: '${event.eventName}'` });
24
        return;
25
    }
26
27
    res.json({ status: "success", message: `${event.event_name} processed` });
28
  } catch (error) {
29
    console.error("Error processing event:", error);
30
    res.status(500).json({ error: "Internal server error" });
31
  }
32
});

1
import * as crypto from 'crypto';
2
3
export function validateHmacSignature(payload: string, headers: IncomingHttpHeaders): void {
4
  // Retrieve the timestamp and signature from headers
5
  const timestamp = headers['x-hume-ai-webhook-timestamp'];
6
  if (!timestamp) {
7
    console.error('Error: Missing timestamp in the request headers.');
8
    throw new Error('Missing timestamp header');
9
  }
10
11
  const signature = headers['x-hume-ai-webhook-signature'] as string;
12
  if (!signature) {
13
    console.error('Error: Missing signature in the request headers.');
14
    throw new Error('Missing signature header');
15
  }
16
17
  // 2. Retrieve the API key from environment variables
18
  const apiKey = process.env.HUME_API_KEY;
19
  if (!apiKey) {
20
    console.error('Error: HUME_API_KEY is not set in environment variables.');
21
    throw new Error('Missing API key');
22
  }
23
24
  // 3. Construct the message to be hashed by concatenating the payload and the timestamp
25
  const message = `${payload}.${timestamp}`;
26
  const expectedSig = crypto
27
    .createHmac('sha256', apiKey)
28
    .update(message)
29
    .digest('hex');
30
31
  // 4. Compare the provided signature with the expected one using timing-safe comparison
32
  const signatureBuffer = Buffer.from(signature, 'utf8');
33
  const expectedSigBuffer = Buffer.from(expectedSig, 'utf8');
34
  const validSignature =
35
    signatureBuffer.length === expectedSigBuffer.length &&
36
    crypto.timingSafeEqual(signatureBuffer, expectedSigBuffer);
37
38
  // 5. If the signatures do not match, throw an error
39
  if (!validSignature) {
40
    console.error(`Error: Invalid HMAC signature. Expected: ${expectedSig}, Received: ${signature}`);
41
    throw new Error('Invalid HMAC signature');
42
  }
43
44
  console.info('HMAC validation successful!');
45
}

1
export function validateTimestamp(headers: IncomingHttpHeaders): void {
2
  // 1. Retrieve the timestamp from the headers
3
  const timestamp = headers['x-hume-ai-webhook-timestamp'] as string;
4
  if (!timestamp) {
5
    console.error('Error: Missing timestamp.');
6
    throw new Error('Missing timestamp');
7
  }
8
9
  // 2. Attempt to parse the timestamp to a number
10
  let timestampInt: number;
11
  try {
12
    timestampInt = parseInt(timestamp, 10);
13
    if (isNaN(timestampInt)) {
14
      // parseInt can return NaN if the string isn't a valid integer
15
      throw new Error();
16
    }
17
  } catch (err) {
18
    console.error(`Error: Invalid timestamp format: ${timestamp}`);
19
    throw new Error('Invalid timestamp format');
20
  }
21
22
  // 3. Get the current time in seconds
23
  const currentTime = Math.floor(Date.now() / 1000);
24
25
  // 4. Check if the timestamp is more than 180 seconds behind the current time
26
  const TIMESTAMP_VALIDATION_WINDOW = 180;
27
  if (currentTime - timestampInt > TIMESTAMP_VALIDATION_WINDOW) {
28
    console.error(`Error: The timestamp on the request is too old. Current time: ${currentTime}, Timestamp: ${timestamp}`);
29
    throw new Error('The timestamp on the request is too old');
30
  }
31
32
  console.info('Timestamp validation successful!');
33
}