Vapi

Both Moda SDKs can turn a Vapi end-of-call report into conversation data: you host a webhook endpoint, Vapi posts the report when a call ends, and you pass the payload to one helper function. Use this page to set up the webhook handler in Node.js or Python and to see exactly what gets captured.

Prerequisites

moda-ai for Node.js (Node 18+) or Python (3.10+)
A webhook endpoint that Vapi can reach over HTTPS
A Moda API key, created at Settings → Ingestion keys (see Authentication)

Set up

Install the SDK

npm install moda-ai

pip install moda-ai

Create the webhook handler

Initialize Moda once, then pass each incoming payload to the end-of-call helper. Payloads that are not end-of-call reports are ignored without error, so it is safe to route all Vapi webhooks through the same handler — the isEndOfCallReport guard below is optional but makes the handler’s intent explicit.

import express from 'express';
import { Moda } from 'moda-ai';

await Moda.init(process.env.MODA_API_KEY!);

const app = express();
app.use(express.json());

app.post('/webhooks/vapi', (req, res) => {
  if (Moda.isEndOfCallReport(req.body)) {
    Moda.processVapiEndOfCallReport(req.body);
  }
  res.json({ status: 'ok' });
});

app.listen(3000);

import { Moda } from 'moda-ai';

export async function POST(request: Request) {
  if (!Moda.isInitialized()) {
    await Moda.init(process.env.MODA_API_KEY!);
  }

  const payload = await request.json();
  if (Moda.isEndOfCallReport(payload)) {
    Moda.processVapiEndOfCallReport(payload);
  }

  // On serverless platforms, flush before returning or the data is lost
  await Moda.flush();
  return Response.json({ status: 'ok' });
}

import os

import moda
from fastapi import FastAPI, Request

moda.init(os.environ["MODA_API_KEY"])

app = FastAPI()

@app.post("/webhooks/vapi")
async def vapi_webhook(request: Request):
    payload = await request.json()
    if moda.is_end_of_call_report(payload):
        moda.process_vapi_end_of_call_report(payload)
    return {"status": "ok"}

import os

import moda
from flask import Flask, request

moda.init(os.environ["MODA_API_KEY"])

app = Flask(__name__)

@app.route("/webhooks/vapi", methods=["POST"])
def vapi_webhook():
    payload = request.get_json()
    if moda.is_end_of_call_report(payload):
        moda.process_vapi_end_of_call_report(payload)
    return {"status": "ok"}

Point Vapi at your endpoint

In Vapi, set your assistant’s server URL to the webhook endpoint and enable the end-of-call-report server message so Vapi posts the report when a call ends.

Verify in the dashboard

Complete a test call, then open Conversations in the dashboard. Within minutes of the call ending you should see a new conversation containing the caller and assistant turns as messages, with any tool calls captured as tool-call entries.

On serverless platforms (Vercel, Lambda, Cloudflare Workers), call await Moda.flush() (Node.js) or moda.flush() (Python) before returning the response. The runtime can freeze or terminate after the response is sent, and unflushed data is lost. Long-running servers flush automatically on the batch interval; flush once more on shutdown.

Function reference

Both functions are available on the Moda object and as top-level imports in Node.js, and at module level in Python.

Node.js	Python	Behavior
`Moda.processVapiEndOfCallReport(payload, options?)`	`moda.process_vapi_end_of_call_report(payload, options=None)`	Parses the report and records the call. Returns nothing. Returns early without recording anything if the payload is not an end-of-call report.
`Moda.isEndOfCallReport(payload)`	`moda.is_end_of_call_report(payload)`	Returns `true` if the payload is an end-of-call report, in either the current `message`-wrapped format or the legacy flat format.

Options let you override the identifiers recorded on the call:

Moda.processVapiEndOfCallReport(payload, {
  conversationId: 'session_8f2a',
  userId: 'user_1042',
});

moda.process_vapi_end_of_call_report(payload, {
    "conversation_id": "session_8f2a",
    "user_id": "user_1042",
})

Option (Node.js / Python)	Default when omitted
`conversationId` / `conversation_id`	`call.id` from the report
`userId` / `user_id`	`call.customer.number` from the report

What gets captured

Each processed report produces one trace with a parent span for the call and child spans for its parts, so a call and its turns appear together as one conversation.

Span	Contents
`vapi.call` (one per call)	Conversation and user IDs, call duration, ended reason, status, assistant ID, start and end timestamps, total cost plus a per-component cost breakdown, and — when Vapi includes analysis — the call summary, structured data, and success evaluation.
`vapi.turn.{index}` (one per assistant turn)	The caller’s message and the assistant’s response, plus model, voice, transcriber, and total latency in milliseconds when the report includes turn timing.
`vapi.tool.{name}` (one per tool execution)	Tool name, tool call ID, parameters, and result.
`vapi.transfer` (one per squad transfer)	The transfer event.

Turns are read from the report’s call.artifact.messages; if the artifact has no messages, a transcript array of {role, message} entries on the report is converted instead.

Troubleshooting

Symptom	Fix
Nothing appears after calls end	Ensure `Moda.init()` / `moda.init()` runs before the handler processes payloads, and confirm Vapi is actually sending `end-of-call-report` messages — log the result of `isEndOfCallReport(payload)` in your handler.
Data appears locally but not from the deployed webhook	Serverless runtime terminated before export — flush before returning the response (see the warning above).
A call appears with no turns	The report contained no `call.artifact.messages` and no `transcript` array. Check that your Vapi assistant produces transcript data in its reports.

Next steps

Moda SDK for Node.js — init options, flush semantics, and context APIs.
Moda SDK for Python — the same for Python services.
Conversations — how captured calls appear in the dashboard.
Reliability — retry behavior and error envelopes.

Send data

SDKs

Providers

Frameworks and agents

OpenTelemetry

API reference

Prerequisites

Set up

Function reference

What gets captured

Troubleshooting

Next steps

​Prerequisites

​Set up

​Function reference

​What gets captured

​Troubleshooting

​Next steps

Prerequisites

Set up

Function reference

What gets captured

Troubleshooting

Next steps