> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tavus.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Post-Call Actions

> Run a tool automatically after a conversation ends - Tavus fills its open arguments from the transcript and perception analysis and delivers the result for you.

**Post-call actions** run a tool automatically once a conversation ends. Unlike [LLM](/sections/conversational-video-interface/pal/llm-tool) and [perception](/sections/conversational-video-interface/pal/perception-tool) 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](/sections/conversational-video-interface/pal/perception) and delivers the call to your endpoint for you.

<Note>
  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.
</Note>

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.

<Note>
  A post-call action needs a transcript to work from, so it won't run for a conversation with no dialogue.
</Note>

## Defining a Post-Call Action

A post-call action is a [tool](/api-reference/tools/create-tool) you create with the Tools API, with three things set:

| Field          | Type   | Required | Description                                                                                                                                                                 |
| -------------- | ------ | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `trigger_type` | string | ✅        | Set to `"post_call"` so the tool runs after the conversation ends (rather than the default `"in_call"`).                                                                    |
| `origin`       | string | -        | Leave unset. `origin` is the live modality (`llm`, `vision`, `audio`) for in-call tools; post-call actions have no live modality.                                           |
| `parameters`   | object | ✅        | A JSON Schema object describing the action's arguments (see below).                                                                                                         |
| `delivery`     | object | ✅        | How the action is sent when it runs (see [Delivery](#delivery)). Uses the standard tool [`delivery`](/sections/conversational-video-interface/pal/llm-tool-delivery) field. |

### Parameters

Each parameter is either **fixed** or **AI-filled**:

| Kind            | How to define it                                          | Behavior                                                                          |
| --------------- | --------------------------------------------------------- | --------------------------------------------------------------------------------- |
| **Fixed value** | Set a `const` on the parameter (e.g. a Slack channel ID). | Tavus uses it exactly as provided. The AI never changes it.                       |
| **AI-filled**   | Leave the parameter open with a clear `description`.      | Tavus writes it from the transcript and perception analysis when the action runs. |

<Tip>
  **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.
</Tip>

### Delivery

A post-call action uses the standard tool [`delivery`](/sections/conversational-video-interface/pal/llm-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](/sections/conversational-video-interface/pal/llm-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](/api-reference/tools/create-tool) for the full request and [Tool Delivery](/sections/conversational-video-interface/pal/llm-tool-delivery) for the `delivery` model.

```json Create a post-call action [expandable] theme={null}
{
  "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:

| Field                   | Description                                         |
| ----------------------- | --------------------------------------------------- |
| `tool_id` / `tool_name` | Which action ran.                                   |
| `status`                | `success`, `error`, `timeout`, or `skipped`.        |
| `request`               | What Tavus sent: `url`, `method`, `body`.           |
| `response`              | What your endpoint returned: `http_status`, `body`. |
| `error`                 | Present only on failure - the error detail.         |

You can read it two ways:

* **Webhook** - it's delivered to the conversation's [`callback_url`](/sections/webhooks-and-callbacks#conversation-callbacks), alongside the other conversation events. Branch on `event_type == "application.post_call_action_executed"`.
* **Pull** - it's also returned on the verbose [GET conversation](/api-reference/conversations/get-conversation) response under `events`, so you can reconcile after the fact without running a webhook server.

```json application.post_call_action_executed theme={null}
{
  "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](/api-reference/pal-tools/attach-tools-to-pal). Once attached, it runs after every conversation with that PAL.

<Note>
  Replace `<api-key>` with your actual API key when calling the Tools API. You can generate one in the <a href="https://maker.tavus.io/dev/api-keys" target="_blank">PAL Maker</a>.
</Note>