Skip to main content
Post-call actions run a tool automatically once a conversation ends. Unlike LLM and perception tool calling - which fire during the conversation and you handle in your own app - a post-call action runs after the call is over. Tavus fills its open arguments from the conversation transcript and perception analysis and delivers the call to your endpoint for you.
LLM and perception tools are surfaced to you as events to run yourself during the call. A post-call action is the opposite: it runs once, after the conversation ends, and Tavus delivers it for you - no client-side handling required.
Use a post-call action when something should happen once, after the call, based on what was discussed - for example: post a summary to Slack, create a CRM note or support ticket, or trigger a follow-up email.

​
How It Works

When a conversation ends, for each post-call action attached to the PAL:
  1. Tavus reads the conversation transcript and perception analysis.
  2. An AI step fills the action’s open arguments from that context - the fields you describe.
  3. Any fixed values you set are used exactly as provided.
  4. Tavus delivers an HTTPS request to your configured webhook endpoint.
Each action runs once per conversation. It is never shown to the model during the live conversation, so it can’t be triggered mid-call.
A post-call action needs a transcript to work from, so it won’t run for a conversation with no dialogue.

​
Defining a Post-Call Action

A post-call action is a tool you create with the Tools API, with three things set:
FieldTypeRequiredDescription
trigger_typestring✅Set to "post_call" so the tool runs after the conversation ends (rather than the default "in_call").
originstring-Leave unset. origin is the live modality (llm, vision, audio) for in-call tools; post-call actions have no live modality.
parametersobject✅A JSON Schema object describing the action’s arguments (see below).
deliveryobject✅How the action is sent when it runs (see Delivery). Uses the standard tool delivery field.

​
Parameters

Each parameter is either fixed or AI-filled:
KindHow to define itBehavior
Fixed valueSet a const on the parameter (e.g. a Slack channel ID).Tavus uses it exactly as provided. The AI never changes it.
AI-filledLeave the parameter open with a clear description.Tavus writes it from the transcript and perception analysis when the action runs.
Best practices:
  • Pin destinations and identifiers (channels, recipient IDs, record IDs) as fixed values so the AI never has to guess them.
  • Give every AI-filled field a precise description - it’s the biggest lever on the quality of what gets written.

​
Delivery

A post-call action uses the standard tool delivery field with delivery.api only. App-message delivery doesn’t apply once the call is over. Configure delivery.api with a URL, HTTP method, headers, body_template, and any auth. Tavus sends one HTTPS request to that endpoint when the action runs. See Tool Delivery for the request shape, URL templating, and response handling.

​
Example Configuration

A post-call action that posts a one-line summary to your backend. channel is pinned with a const; message is written by the AI from the transcript and perception analysis, and body_template maps both onto the request body. See the Tools API reference for the full request and Tool Delivery for the delivery model.
Create a post-call action
{
  "name": "post_call_summary",
  "description": "After the call ends, post a one-sentence summary of the conversation.",
  "trigger_type": "post_call",
  "parameters": {
    "type": "object",
    "properties": {
      "channel": {
        "type": "string",
        "const": "C0SUPPORT"
      },
      "message": {
        "type": "string",
        "description": "A concise, one-sentence summary of what the caller wanted and the outcome."
      }
    },
    "required": ["channel", "message"]
  },
  "delivery": {
    "api": {
      "url": "https://your-app.example.com/hooks/call-summary",
      "method": "POST",
      "body_template": { "channel": "{channel}", "text": "{message}" }
    }
  }
}

​
Observing Results

The delivery.api.url above is where the action fires - Tavus’s outbound request carrying your body_template. To see whether it actually ran and how it went, Tavus emits an application.post_call_action_executed event for each action it runs (one per attached post-call action), independent of how your endpoint responded. The event’s properties record the outcome:
FieldDescription
tool_id / tool_nameWhich action ran.
statussuccess, error, timeout, or skipped.
requestWhat Tavus sent: url, method, body.
responseWhat your endpoint returned: http_status, body.
errorPresent only on failure - the error detail.
You can read it two ways:
  • Webhook - it’s delivered to the conversation’s callback_url, alongside the other conversation events. Branch on event_type == "application.post_call_action_executed".
  • Pull - it’s also returned on the verbose GET conversation response under events, so you can reconcile after the fact without running a webhook server.
application.post_call_action_executed
{
  "properties": {
    "tool_id": "<tool_id>",
    "tool_name": "post_call_summary",
    "status": "success",
    "request": {
      "url": "https://your-app.example.com/hooks/call-summary",
      "method": "POST",
      "body": "{\"channel\":\"C0SUPPORT\",\"text\":\"Caller asked about order status; resolved.\"}"
    },
    "response": { "http_status": 200, "body": "ok" }
  },
  "conversation_id": "<conversation_id>",
  "event_type": "application.post_call_action_executed",
  "message_type": "application",
  "timestamp": "2026-04-29T03:47:05Z"
}

​
Attaching to a PAL

A post-call action runs for a PAL once you attach it, like any other tool - see Attach Tools to a PAL. Once attached, it runs after every conversation with that PAL.
Replace <api-key> with your actual API key when calling the Tools API. You can generate one in the PAL Maker.