EN

Notetaker integration

Meeting recording webhooks

Know exactly when a notetaker changes state and when each artifact is ready. Five event types, one signed envelope and an asynchronous pattern designed for reliable production workflows.

Start building Explore the Notetaker API

Artifact-ready notifications
POST /v2/webhooks
Notetaker status
Transcript
Recording
Signed eventFast acknowledgementAsync retrieval
  • 5

    Notetaker event types

    Status plus four artifact families

  • 5 seconds

    Delivery timeout

    Acknowledge first, process asynchronously

  • 3 attempts

    Maximum delivery tries

    Design the consumer for at-least-once delivery

  • HMAC-SHA256

    Signature verification

    Verify the timestamp and raw request body

Subscribe to every Notetaker event

Scope the webhook to selected accounts, or omit account_ids to receive matching events for the whole application.

Create webhook
curl --request POST "https://api.unipile.com/v2/webhooks" \
--header "X-API-KEY: $UNIPILE_API_KEY" \
--header "Content-Type: application/json" \
--data '{
  "url": "https://api.example.com/webhooks/unipile",
  "description": "Notetaker events",
  "trigger_events": [
    "notetaker.status",
    "notetaker.transcript",
    "notetaker.recording",
    "notetaker.summary",
    "notetaker.action_items"
  ],
  "account_ids": ["'$ACCOUNT_ID'"]
}'
Event
{
"object": "Event",
"id": "evt_01k0000000000000000000000",
"created_at": "2026-09-22T10:30:00.000Z",
"type": "notetaker.transcript",
"account_id": "acc_01k00000000000000000000",
"account_scope_id": null,
"account_provider": "google",
"application_id": "app_01k00000000000000000000",
"application_production": true,
"hash": "stable-event-hash",
"payload": {
  "notetaker_id": "nt_01k00000000000000000000000",
  "status": "available"
}
}

One event for each stage of the workflow

  • Status

    Drive scheduled, joining, in-call, processing, available, partial, cancelled, left and failed states in your product.

  • Transcript

    Fetch the final speaker-labelled transcript when its artifact status becomes available.

  • Recording

    Refresh the recording list and expose authenticated audio or video playback only after media is ready.

  • Summary

    Receive a separate readiness event for the post-meeting summary, including custom-instruction workflows.

  • Action items

    Push extracted follow-ups into a CRM, ATS or task system without waiting for another artifact.

  • Stable event identity

    Persist the event ID before processing so retries never create duplicate downstream work.

The reliable webhook pattern

  1. Verify before parsing

    Read the unmodified request body, validate the unipile-signature timestamp and HMAC, and reject stale requests.

  2. Persist and acknowledge

    Store the event ID transactionally and return a 2xx response quickly. Delivery is at least once, so duplicates are expected.

  3. Fetch asynchronously

    Queue downstream processing and retrieve the current transcript, recording, summary or action items from its authenticated endpoint.

What the signature covers

The signature header has the form t=timestamp,v0=signature. Compute the HMAC over the timestamp, a period and the exact raw request body.

Node.js
import { createHmac, timingSafeEqual } from "node:crypto";

const signedPayload = `${timestamp}.${rawBody}`;
const expected = createHmac("sha256", webhookSecret)
.update(signedPayload)
.digest("hex");

const valid = timingSafeEqual(
Buffer.from(expected, "hex"),
Buffer.from(receivedSignature, "hex"),
);

Notifications, not artifact payloads

Artifact webhooks deliberately stay small. They identify the Notetaker and tell you whether the resource is processing, available or failed. Your worker then fetches the authoritative object through the API.

That separation keeps retries inexpensive, avoids pushing sensitive meeting content into every webhook log and prevents an old delivery from overwriting a newer artifact state. Delivery times out after five seconds and is attempted at most three times, approximately two and ten seconds after the first failure.

Continue exploring the Notetaker API

Meeting recording webhooks — frequently asked questions

Are webhook events delivered exactly once?

No. Delivery is at least once, so persist the event ID and make processing idempotent. The service makes up to three total attempts.

Does the transcript arrive inside the webhook?

No. The event is a readiness notification. Fetch the authoritative transcript from its API endpoint after the payload status is available.

How do I verify a webhook?

Use the timestamp and v0 value from the unipile-signature header. Compute HMAC-SHA256 over timestamp.raw_request_body, compare safely and reject timestamps outside your tolerance.

How quickly should my endpoint respond?

Within five seconds. Persist the event, return 2xx or 204, then do artifact retrieval and downstream work asynchronously.

Can I subscribe for one account only?

Yes. Add account_ids when creating the webhook, or omit the field to receive matching events across the application.

Ready to integrate every channel?

Talk to our team or start building today.

Book a demo Start for free