> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.vapi.ai/tools/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.vapi.ai/_mcp/server.

# Tools

> Learn what a Vapi tool is, how a tool call flows between the model, Vapi, and your server, which tool types exist, and the configuration every tool shares.

A tool is a capability an assistant can invoke during a conversation to do something beyond talking: transfer the call, look up a customer record, book an appointment, or end the call. You define the tools an assistant is allowed to use, and the model decides when to use them.

Tools are configured in an assistant's `tools` array, either in the Dashboard's Tools section or through the API. A tool created in the Dashboard can be reused across multiple assistants, and tools are [versioned](/assistants/versioning), so an assistant can pin a specific version or always track the latest.

## How a tool call works

Every tool call follows the same four steps, whatever the tool type:

1. **The model decides.** Based on the conversation and the tool's name and description, the model chooses to call a tool and generates the arguments defined by its input schema.
2. **Vapi resolves the call.** Vapi merges in any [static parameters](/tools/static-variables-and-aliases) you configured, which the model never sees and cannot override, then checks the [rejection plan](/tools/tool-rejection-plan) to confirm the call is allowed.
3. **The tool executes.** What happens here depends on the type. Vapi may send an HTTP request directly, POST a `tool-calls` webhook to your server, emit an event to the browser, or perform a built-in action such as transferring the call.
4. **The result returns.** The assistant receives the result and can speak it to the caller. Tools can also be configured to run asynchronously, so the assistant continues without waiting.

Because the model controls both *when* a tool runs and the arguments it receives, validate any caller-influenced value at the destination before using it for a sensitive action.

## Tool types

| Type                                           | What it does                                                                                                               |
| ---------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| [Built-in tools](/tools/default-tools)         | Actions Vapi provides out of the box: transfer a call, end a call, send an SMS, dial keypad digits, or make an API request |
| [API Request tool](/tools/api-request)         | Calls an ordinary HTTPS endpoint directly, with a configurable URL, method, headers, and JSON body                         |
| [Function tools](/tools/custom-tools)          | Sends Vapi's `tool-calls` webhook to a server you control, so your code decides what happens                               |
| [Transfer Call tool](/tools/transfer-call)     | Routes a live call to a phone number or SIP URI                                                                            |
| [Handoff tool](/squads/handoff)                | Moves a call from one assistant to another, carrying context and extracted variables                                       |
| [Voicemail tool](/tools/voicemail-tool)        | Lets the assistant decide what to do when it reaches a voicemail system                                                    |
| [Client-side tools](/tools/client-side-websdk) | Runs in the browser through the Web SDK, with no server URL                                                                |
| [Query tool](/knowledge-base/using-query-tool) | Searches a [knowledge base](/knowledge-base) and returns matching content                                                  |
| [MCP tools](/tools/mcp)                        | Connects to an MCP server so the assistant can use tools resolved at runtime                                               |
| [Integrations](/tools/integrations)            | Service-specific guides for prebuilt integrations and standard tool patterns                                               |

If you are deciding between calling an API directly and running your own logic, see [When to use API Request or Function tools](/tools/api-request-vs-function).

If you're building a tool with an AI coding assistant, the [create-tool skill](/agent-skills#create-tool) helps you select, configure, attach, and verify it.

## Configuration shared by every tool

Most tool settings are specific to the type, but several apply across all of them:

* **Name and description.** The model reads both when deciding whether to call the tool, so describe the action, when it applies, and what to do with the result.
* **Parameters.** The model-facing input schema defines what the model generates. Separately, [static parameters](/tools/static-variables-and-aliases) inject server-controlled values that the model never sees.
* **Messages.** Configure what the assistant says at each phase of the call, so a caller is not left in silence while a request is in flight.
* **Rejection plan.** Block a tool call based on conversation state with a [tool rejection plan](/tools/tool-rejection-plan).
* **Argument encryption.** Encrypt sensitive fields before they reach your server with [argument encryption](/tools/encryption).

## Next steps

#### [When to use API Request or Function tools](/tools/api-request-vs-function)

Decide whether to call an HTTPS API directly or route the call through your own server.

#### [API Request tool quickstart](/tools/api-request/quickstart)

Build a working tool end to end, from an inbound call to a server-calculated result.

#### [Static variables and aliases](/tools/static-variables-and-aliases)

Inject trusted values into tool calls and pass data from one tool to the next.

#### [Troubleshoot tools](/tools/custom-tools-troubleshooting)

Diagnose tools that never fire, return nothing, or have their results ignored.

> Give an assistant the ability to act during a call, from transferring to looking up data

## Docs

- [Built-in tools](https://docs.vapi.ai/tools/default-tools.md): Add Vapi's built-in default tools to assistants, including transfer call, end call, SMS, DTMF keypad, and API request, through the API or dashboard.
- [When to use API Request or Function tools](https://docs.vapi.ai/tools/api-request-vs-function.md): Compare Vapi's API Request and Function tools, choosing API Request for direct HTTPS APIs and Function for tool-calls webhooks or async and client-side execution.
- [API Request tool](https://docs.vapi.ai/tools/api-request.md): Learn when to use an API Request Tool, how requests move between an assistant and an HTTP endpoint, and how to build your first working integration with Vapi.
- [API Request tool quickstart](https://docs.vapi.ai/tools/api-request/quickstart.md): Build a coffee-order assistant that sends confirmed orders to a public endpoint and reads the server-calculated total and order number back to the caller.
- [Customize API Request tool requests](https://docs.vapi.ai/tools/api-request/configuration.md): Configure an API Request Tool's URL, method, model-generated body, request headers, static body fields, and Liquid values with Dashboard and cURL examples.
- [Get order status](https://docs.vapi.ai/tools/api-request/order-status.md): Add an order-status API Request Tool to the coffee-order assistant, update its opening and system prompt, and verify status lookup across two inbound calls.
- [Handle API Request Tool latency and retries](https://docs.vapi.ai/tools/api-request/reliability.md): Learn how API Request Tool timeouts and failed HTTP requests behave, keep callers informed, and handle safe retries in a service you control.
- [Handle API Request tool responses and errors](https://docs.vapi.ai/tools/api-request/response-handling.md): Handle successful and failed API Request Tool responses, test structured errors, guide assistant recovery, and inspect call results in the Dashboard or with cURL.
- [Use API Request tool response data](https://docs.vapi.ai/tools/api-request/response-data.md): Use API Request Tool JSON responses immediately, extract response fields with schemas or aliases, and pass extracted variables to subsequent tools.
- [Function tools](https://docs.vapi.ai/tools/custom-tools.md): Create and manage Function tools through the Vapi dashboard or API, connect them to server-side logic, test webhooks locally, and reuse them across assistants.
- [Transfer Call tool](https://docs.vapi.ai/tools/transfer-call.md): Create a transfer call tool in the Vapi Dashboard or API, add it to an assistant, configure destinations, and troubleshoot invocation and routing failures.
- [Configure blind transfer modes](https://docs.vapi.ai/tools/transfer-call/blind-transfer.md): Configure blind call transfers in the Vapi Dashboard or API, choose a SIP transfer method, add a summary header, verify routing, and diagnose failures.
- [Configure warm transfer modes](https://docs.vapi.ai/tools/transfer-call/warm-transfer.md): Configure traditional warm transfer modes in the Vapi Dashboard or API, including messages, summaries, operator-first timing, TwiML, and timeouts.
- [Configure assistant-based warm transfer](https://docs.vapi.ai/calls/assistant-based-warm-transfer.md): Configure an assistant-based warm transfer in the Vapi Dashboard or API, including operator prompts, fallback behavior, summaries, custom audio, and testing.
- [Handoff tool](https://docs.vapi.ai/squads/handoff.md): Transfer a Vapi call between assistants with the handoff tool, covering destination types, context management, and configuration for multi-agent squads.
- [Configure handoff destinations](https://docs.vapi.ai/squads/handoff/destinations.md): Declare handoff destinations by assistant ID or name, offer the model several options, resolve one at runtime by webhook, or hand off to a whole squad.
- [Pass context and variables](https://docs.vapi.ai/squads/handoff/context-and-variables.md): Choose how much conversation history the receiving assistant sees, and extract variables so structured data follows the caller into the next assistant.
- [Configure messages and rejection rules](https://docs.vapi.ai/squads/handoff/messages-and-rejection.md): Set the messages an assistant speaks at each phase of a handoff, and block handoff attempts using regex, Liquid, or grouped conditions on conversation state.
- [Troubleshoot handoffs](https://docs.vapi.ai/squads/handoff/troubleshooting.md): Fix handoffs that never fire or route to the wrong assistant, starting with the system prompt instructions that tell the model when to call the handoff tool.
- [Voicemail tool](https://docs.vapi.ai/tools/voicemail-tool.md): Give a Vapi assistant direct control over voicemail with the voicemail tool, deciding when it reaches voicemail to leave a message or end the call.
- [Configure the Voicemail tool](https://docs.vapi.ai/tools/voicemail-tool/configure.md): Create a Vapi voicemail tool in the Dashboard or API, attach it to an assistant, prompt for voicemail detection, and set the message for each behavior mode.
- [Client-side tools (Web SDK)](https://docs.vapi.ai/tools/client-side-websdk.md): Handle Vapi tool calls entirely in the browser with the Web SDK, triggering UI side effects like notifications or state changes without a server URL.
- [Knowledge bases](https://docs.vapi.ai/knowledge-base.md): Create and integrate knowledge bases into Vapi voice agents so they retrieve information from your documents to answer questions accurately during a call.
- [Query tool](https://docs.vapi.ai/knowledge-base/using-query-tool.md): Configure the Vapi query tool to give an assistant access to a knowledge base, retrieving information from your files by ID for accurate, grounded responses.
- [Custom knowledge base](https://docs.vapi.ai/knowledge-base/custom-knowledge-base.md): Build a custom knowledge base in Vapi with your own retrieval server, using your vector database or search logic to control how an assistant finds answers.
- [Implement the custom endpoint](https://docs.vapi.ai/knowledge-base/implement-custom-endpoint.md): Handle the Vapi knowledge base request on your own server, return documents or a direct answer, integrate a vector database, and harden the endpoint.
- [Integrations](https://docs.vapi.ai/tools/integrations.md): Connect a Vapi assistant to external services using prebuilt integrations or service guides for API Request, Model Context Protocol (MCP), and Function tools.
- [Choose a Make integration pattern](https://docs.vapi.ai/tools/integrations/make.md): Choose a Make integration pattern for an assistant: API Request for webhooks, Model Context Protocol (MCP) for discovered tools, or Function for call context.
- [n8n](https://docs.vapi.ai/tools/integrations/n8n.md): Connect Vapi to n8n with an API Request tool and a published Webhook workflow. Run the business-hours starter, verify JSON responses, and diagnose setup issues.
- [Google Calendar](https://docs.vapi.ai/tools/google-calendar.md): Connect a Vapi assistant to Google Calendar to create events by voice and check availability, letting it schedule appointments during a call.
- [Google Sheets](https://docs.vapi.ai/tools/google-sheets.md): Connect a Vapi assistant to Google Sheets to add new rows during phone calls, recording caller information and data directly into your spreadsheets.
- [Slack](https://docs.vapi.ai/tools/slack.md): Connect a Vapi assistant to Slack to send messages to a configured channel during phone calls, notifying your team or sharing updates in real time.
- [GoHighLevel](https://docs.vapi.ai/tools/go-high-level.md): Connect a Vapi assistant to GoHighLevel to manage appointments, checking contacts, creating leads, querying calendar availability, and booking events.
- [Static variables and aliases](https://docs.vapi.ai/tools/static-variables-and-aliases.md): Inject server-controlled values into Vapi tool calls without the LLM, using static variables and aliases to chain data across calls deterministically.
- [How tool variables work](https://docs.vapi.ai/tools/static-variables-and-aliases/how-variables-work.md): Compare a tool's function.parameters schema against its top-level parameters array, and classify every variable source with Vapi's three-tier trust model.
- [Set static parameters](https://docs.vapi.ai/tools/static-variables-and-aliases/static-parameters.md): Add static parameters to API Request and Function tools, use them as a security boundary against prompt injection, and set Static Body Fields in the dashboard.
- [Extract and chain values](https://docs.vapi.ai/tools/static-variables-and-aliases/extract-and-chain.md): Define a variableExtractionPlan with aliases, chain tools so one tool's output feeds the next deterministically, and forward trusted values across handoffs.
- [Troubleshoot tool variables](https://docs.vapi.ai/tools/static-variables-and-aliases/troubleshooting.md): Fix static parameter and alias failures caused by trusted fields declared in function.parameters, values in body schema defaults, or system prompt passing.
- [Dynamic tool messages](https://docs.vapi.ai/tools/dynamic-tool-messages.md): Configure bot_say for Function and Handoff tools so an assistant speaks a context-aware message before execution and handles multiple tool calls correctly.
- [Tool rejection plan](https://docs.vapi.ai/tools/tool-rejection-plan.md): Prevent unintended Vapi tool calls with a rejection plan that evaluates recent conversation state and blocks a tool when your conditions are met.
- [Tool argument encryption](https://docs.vapi.ai/tools/encryption.md): Encrypt sensitive tool arguments like SSNs and card numbers in Vapi, protecting specific fields before they are sent to your server during a tool call.
- [Troubleshoot tools](https://docs.vapi.ai/tools/custom-tools-troubleshooting.md): Troubleshoot Function tool integrations in Vapi, including trigger failures, response errors, token truncation, multiple tool responses, and async behavior.