# Create agent
Source: https://docs.callrounded.com/api-reference/agents/create-agent
/api-reference-v1/openapi.json post /v1/agents
Create a new agent with the specified configuration. The agent can be used to handle phone and web calls. The response includes headers about rate limiting.
# Delete agent
Source: https://docs.callrounded.com/api-reference/agents/delete-agent
/api-reference-v1/openapi.json delete /v1/agents/{agent_id}
Delete an existing agent by its ID. This action is irreversible and will permanently remove the agent and all its configurations. The response includes headers about rate limiting.
# Deploy agent
Source: https://docs.callrounded.com/api-reference/agents/deploy-agent
/api-reference-v1/openapi.json post /v1/agents/{agent_id}/deploy
Deploy a specific version or the latest draft configuration of an agent by setting it as the published configuration. This makes the specified configuration live and active for agent's phone and web calls. The response includes headers about rate limiting.
# Get agent
Source: https://docs.callrounded.com/api-reference/agents/get-agent
/api-reference-v1/openapi.json get /v1/agents/{agent_id}
Retrieve the active configuration of an agent by its ID. Returns the complete agent configuration including all variables, states, voice, transcriber and LLM settings. The response includes headers about rate limiting.
# Get agent versions
Source: https://docs.callrounded.com/api-reference/agents/get-agent-versions
/api-reference-v1/openapi.json get /v1/agents/{agent_id}/versions
Retrieve a list of all configuration versions for a specific agent, including both draft and published versions. The response includes headers about rate limiting.
# Update agent
Source: https://docs.callrounded.com/api-reference/agents/update-agent
/api-reference-v1/openapi.json patch /v1/agents/{agent_id}
Update an existing agent with a new configuration. You can update any of the agent's properties including name, language, voice settings, and states. The update will generate a new version of the latest draft configuration of the agent. The response includes headers about rate limiting.
# Delete call
Source: https://docs.callrounded.com/api-reference/calls/delete-call
/api-reference-v1/openapi.json delete /v1/calls/{call_id}
Delete a call by its ID. The call can be either a phone call or a web call. Returns an empty response with a 204 status code when successful.
# Get call details
Source: https://docs.callrounded.com/api-reference/calls/get-call-details
/api-reference-v1/openapi.json get /v1/calls/{call_id}
Get detailed information about a specific call, including its transcript and variable values. The call can be either a phone call or a web call. The transcript can contain user/agent messages, tool invocations, or tool responses.
# List calls
Source: https://docs.callrounded.com/api-reference/calls/list-calls
/api-reference-v1/openapi.json get /v1/calls
List calls with filtering options. Results are paginated and can be filtered by various parameters.
Pagination Options:
1. Cursor-based pagination (default):
- Set `use_cursor=true`.
- Provide `limit` parameter to control results per page (default: 50, max: 1000).
- Response includes `next_cursor` for subsequent requests.
- Best for efficiently paging through large datasets.
2. Page-based pagination:
- Set `use_cursor=false`.
- Provide `page` and `limit` parameters.
- Response includes `current_page`, `total_pages`, and `total_items`.
- Best for UIs that need to jump to specific pages.
# Stage an inbound SIP call
Source: https://docs.callrounded.com/api-reference/calls/stage-an-inbound-sip-call
/api-reference-v1/openapi.json post /v1/calls/stage
Pre-initialize a call (agent configuration, variables initialization, and resources) before an inbound SIP call arrives, reducing cold-start latency to near zero.
**Async:** Returns the `call_id` immediately. Poll `GET /v1/calls/{call_id}` and wait for the status to become `staged` before triggering the SIP call.
**Sync:** Blocks until the call is ready (status `staged`) or a timeout occurs (HTTP 408).
Once staged, trigger the inbound SIP call with the header:
```
X-Rounded-Call-Id: {call_id}
```
This ensures the call is routed to the staged agent.
**Call status flow:** `initiated` → `staged` → `ringing` → `in_progress` → `completed`
If no SIP call arrives within the staging timeout (60s), the call is marked `no_answer` and cleaned up.
**Tip:** If your agent uses *Call context: Variables initialization* to load data when processing a call, prefer using this endpoint to prepare it beforehand.
# Start a new phone call
Source: https://docs.callrounded.com/api-reference/calls/start-a-new-phone-call
/api-reference-v1/openapi.json post /v1/calls/phone
Start a new phone call with the specified parameters. The response includes headers about rate limiting.
# Start Phone Call
Source: https://docs.callrounded.com/api-reference/calls/start-phone-call
POST /v0/calls/phone
Starts an outbound phone call (private beta, restricted access)
# Description
Starts a new phone call. This endpoint is in private beta, email us at [team@callrounded.com](mailto:team@callrounded.com) to get access.
# Terminate call
Source: https://docs.callrounded.com/api-reference/calls/terminate-call
/api-reference-v1/openapi.json post /v1/calls/{call_id}/terminate
Terminate an ongoing call. Currently only supported for phone calls. Returns a message indicating the result of the operation.
# Update call
Source: https://docs.callrounded.com/api-reference/calls/update-call
/api-reference-v1/openapi.json patch /v1/calls/{call_id}
Update a call with additional metadata. The call can be either a phone call or a web call. The response includes the updated call details. If override is True, existing metadata will be completely replaced with new metadata, including `None` values.
# Add sources to a knowledge base
Source: https://docs.callrounded.com/api-reference/knowledge-bases/add-sources-to-a-knowledge-base
/api-reference-v1/openapi.json post /v1/knowledge-bases/{knowledge_base_id}/sources
Add PDF files or text content as sources to an existing knowledge base.
# Delete sources from a knowledge base
Source: https://docs.callrounded.com/api-reference/knowledge-bases/delete-sources-from-a-knowledge-base
/api-reference-v1/openapi.json delete /v1/knowledge-bases/{knowledge_base_id}/sources
Delete sources from a knowledge base.
# Get knowledge base details
Source: https://docs.callrounded.com/api-reference/knowledge-bases/get-knowledge-base-details
/api-reference-v1/openapi.json get /v1/knowledge-bases/{knowledge_base_id}
Get detailed information about a specific knowledge base, including its sources.
# List phone numbers
Source: https://docs.callrounded.com/api-reference/phone-numbers/list-phone-numbers
/api-reference-v1/openapi.json get /v1/phone-numbers
List phone numbers with pagination. The response includes headers about rate limiting.
Pagination Options:
1. Page-based pagination (default):
- Provide `page` and `limit` parameters.
- Response includes `current_page`, `total_pages`, and `total_items`.
- Best for UIs that need to jump to specific pages.
2. Cursor-based pagination:
- Based on phone number `created_at` property (ISO 8601 datetime of last seen record).
- Set `use_cursor=true`.
- Provide `limit` parameter to control results per page (default: 50, max: 1000).
- Response includes `next_cursor` for subsequent requests.
- Best for efficiently paging through large datasets.
# Update phone number
Source: https://docs.callrounded.com/api-reference/phone-numbers/update-phone-number
/api-reference-v1/openapi.json patch /v1/phone-numbers/{phone_number_id}
Update a phone number properties, this can be used to change the name, assign an inbound agent or enable/disable redirect.
The response includes the updated phone number details and headers about rate limiting.
# Create post-call questions
Source: https://docs.callrounded.com/api-reference/post-call-questions/create-post-call-questions
/api-reference-v1/openapi.json post /v1/agents/{agent_id}/post-call-questions
Create multiple post-call questions for an agent in a single request. Post-call questions can be of different types (text, boolean, number, selector, multi-selector) and are used to collect structured feedback after calls. Selector types require at least 2 options. Maximum 50 questions per batch.
# Delete post-call question
Source: https://docs.callrounded.com/api-reference/post-call-questions/delete-post-call-question
/api-reference-v1/openapi.json delete /v1/agents/{agent_id}/post-call-questions/{question_id}
Delete a post-call question. This will stop generating its respective responses in post-call analysis.
# Get post-call question
Source: https://docs.callrounded.com/api-reference/post-call-questions/get-post-call-question
/api-reference-v1/openapi.json get /v1/agents/{agent_id}/post-call-questions/{question_id}
Retrieve a specific post-call question by ID. Returns the complete question configuration including options, examples, and metadata.
# List post-call questions
Source: https://docs.callrounded.com/api-reference/post-call-questions/list-post-call-questions
/api-reference-v1/openapi.json get /v1/agents/{agent_id}/post-call-questions
Retrieve all post-call questions configured for a specific agent. Post-call questions are used to collect structured feedback and data after calls.
# Update post-call questions
Source: https://docs.callrounded.com/api-reference/post-call-questions/update-post-call-questions
/api-reference-v1/openapi.json patch /v1/agents/{agent_id}/post-call-questions
Update agent post-call questions in a single request. If an item has no ID, a new post-call question will be created. Only description can be updated. Maximum 50 questions per batch.
# Webhook Events Reference
Source: https://docs.callrounded.com/api-reference/webhooks/webhook-events-reference
Here you'll find details about each event our system emits, including attributes, examples, and usage notes. These events are typically sent to your configured webhook endpoint whenever relevant actions occur in a call's lifecycle.
## Overview
Our platform uses a series of events to convey real-time updates about call statuses, transcripts, variable resolution, tool usage, and more. Each event has a consistent JSON structure and includes:
* A **`type`** field, e.g., `event_call_status_updated`
* A **`timestamp`** (Unix time)
* A unique **`call_id`** to identify the call
* Event-specific attributes
Below is a breakdown of each event type, detailing its attributes and when it's fired. Click an event name to jump directly to its details.
## Event List
1. [event\_call\_status\_updated](#a-event_call_status_updated)
2. [event\_call\_answer\_type\_updated](#b-event_call_answer_type_updated)
3. [event\_transcript](#c-event_transcript)
4. [event\_tool](#d-event_tool)
5. [event\_task\_transition](#e-event_task_transition)
6. [event\_variable\_value\_updated](#f-event_variable_value_updated)
7. [event\_all\_variables\_resolved](#g-event_all_variables_resolved)
8. [event\_recording\_status\_updated](#h-event_recording_status_updated)
9. [event\_post\_call](#i-event_post_call)
***
### A. `event_call_status_updated`
**Description**
Emitted whenever a call's status changes, from initial reception/dialing up to completion or redirection.
**Attributes**
| Attribute | Type | Values | Description | Example |
| ------------------------------------ | --------------- | -------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- | ------------------- |
| **call\_type** | `String` | `phone_call`, `web_call` | Indicates whether the call is a traditional phone call or a web-based call. | `phone_call` |
| **direction** | `String` | `inbound`, `outbound` | Specifies if the call was received (inbound) or made (outbound). | `inbound` |
| **status** | `String` | `initiated`, `ringing`, `connected`, `completed`, `redirection_completed`, `failed`, `busy`, `no_answer`, `canceled` | Describes the current state of the call. | `ringing` |
| **from\_phone\_number** *(Optional)* | `String` | — | The phone number that initiated the call. | `+1234567890` |
| **to\_phone\_number** *(Optional)* | `String` | — | The phone number receiving the call. | `+0987654321` |
| **redirect\_duration** *(Optional)* | `int` (seconds) | — | Duration for which the call was redirected before final status. | `42` |
| **timestamp** | `float` | — | Unix timestamp indicating when the event was recorded. | `1633035802.123` |
| **call\_id** | `String(uuid4)` | — | Unique identifier for the call. | `d8016985-e492-...` |
**Final Call Status Details**
The following statuses indicate the final state of a call:
* `completed`: Call was answered and ended normally.
* `redirection_completed`: Call was redirected to another number and completed successfully.
* `busy`: Destination returned a busy signal.
* `no_answer`: Call rang, but no one answered (or the call was declined) before timeout.
* `failed`: Call could not be routed (invalid number, unreachable, or network error).
* `canceled`: Call was canceled while still queued or ringing.
***
### B. `event_call_answer_type_updated`
**Description**
Emitted when the system (e.g. via Twilio's Answering Machine Detection) identifies what answered an outbound call (human, machine, voicemail, etc.). Used to drive call-handling logic and analytics.
**Attributes**
| Attribute | Type | Values | Description | Example |
| ---------------- | --------------- | ------------------------------- | --------------------------------------------------------------- | ---------------------------------- |
| **call\_type** | `String` | `phone_call` | Specifies this is a phone call (particularly for outbound AMD). | `phone_call` |
| **direction** | `String` | `inbound`, `outbound` | Typically `outbound` for AMD, but included for consistency. | `outbound` |
| **answer\_type** | `String` | `human`, `machine`, `voicemail` | The identified entity that answered the call. | `human` |
| **timestamp** | `float` | — | Unix timestamp indicating when the event was recorded. | `1633035802.123` |
| **call\_id** | `String(uuid4)` | — | Unique identifier for the call. | `d8016985-e492-4710-b288-97229...` |
***
### C. `event_transcript`
**Description**
Captures real-time transcripts of spoken audio or messages during an active call or session. It can fire multiple times as the conversation progresses, allowing continuous tracking of the dialogue.
**Attributes**
| Attribute | Type | Values | Description | Example |
| ------------- | --------------- | ---------------- | ----------------------------------------------------------- | -------------------------------- |
| **text** | `String` | — | The recognized speech or chat text. | `"Hello, how can I assist you?"` |
| **timestamp** | `float` | — | Unix timestamp indicating when the transcript was recorded. | `1633035802.123` |
| **sender** | `String` | `human`, `agent` | Indicates who sent the message (human or agent). | `human` |
| **call\_id** | `String(uuid4)` | — | Unique identifier for the call. | `d8016985-e492-...` |
***
### D. `event_tool`
**Description**
Emitted whenever a tool is called within a session. This includes actions like API calls, database queries, or any action performed by an integrated tool during the call/session.
**Attributes**
| Attribute | Type | Description | Example |
| -------------------------- | --------------- | -------------------------------------------------------------------- | ---------------------------------- |
| **name** | `String` | The name of the tool or action invoked. | `"check_order_status"` |
| **type** | `String` | The category of the tool (e.g., `api_call`, `database_query`, etc.). | `"custom_tool"` |
| **arguments** *(Optional)* | `dict` | Arguments or parameters provided to the tool. | `{"order_id": "67890"}` |
| **response** *(Optional)* | `dict` | If the tool/action returned data, it may appear here. | `{"status": "Order in transit"}` |
| **timestamp** | `float` | Unix timestamp indicating when the tool was called. | `1633035802.123` |
| **call\_id** | `String(uuid4)` | Unique identifier for the call associated with this tool event. | `d8016985-e492-4710-b288-97229...` |
***
### E. `event_task_transition`
**Description**
Fired whenever the system transitions from one "task" (or conversational state) to another, including references to the models used and how long the previous task lasted.
**Attributes**
| Attribute | Type | Description | Example |
| --------------------------------------- | --------------- | --------------------------------------------------------- | -------------------------- |
| **source\_task\_name** | `String` | The name of the current/previous task. | `"initial_greeting"` |
| **target\_task\_name** *(Optional)* | `String` | The name of the next task the system is transitioning to. | `"collecting_information"` |
| **source\_task\_model** | `ModelType` | The model used for the source task. | `"model123"` |
| **target\_task\_model** *(Optional)* | `ModelType` | The model used for the target task, if applicable. | `"model456"` |
| **source\_task\_duration** *(Optional)* | `int` (seconds) | How long the source task lasted before transitioning. | `30` |
| **timestamp** | `float` | Unix timestamp indicating when the transition occurred. | `1633035802.123` |
| **call\_id** | `String(uuid4)` | Unique identifier for the call. | `d8016985-e492-...` |
***
### F. `event_variable_value_updated`
**Description**
Emitted whenever a variable's value is updated during a call/session. This enables tracking changes in real-time to important metrics or states.
**Attributes**
| Attribute | Type | Description | Example |
| ------------------ | --------------- | -------------------------------------------------------- | ---------------------------------- |
| **variable\_name** | `String` | The name of the variable being updated. | `"customer_status"` |
| **value** | `String` | The new value of the variable. | `"VIP"` |
| **timestamp** | `float` | Unix timestamp indicating when the variable was updated. | `1633035802.123` |
| **call\_id** | `String(uuid4)` | Unique identifier for the call. | `d8016985-e492-4710-b288-97229...` |
***
### G. `event_all_variables_resolved`
**Description**
Indicates that all call/session variables (e.g., extracted data) have been finalized or saved. Typically fired when the system finishes collecting or confirming needed information.
**Attributes**
| Attribute | Type | Description | Example |
| -------------------- | --------------- | ------------------------------------------------------------------------------- | ---------------------------------- |
| **variable\_values** | `dict` | A dictionary containing the resolved variables relevant to the call or session. | `{"customer_id": "12345"}` |
| **timestamp** | `float` | Unix timestamp indicating when the event was recorded. | `1633035802.123` |
| **call\_id** | `String(uuid4)` | Unique identifier for the call. | `d8016985-e492-4710-b288-97229...` |
***
### H. `event_recording_status_updated`
**Description**
Emitted when the status of a call recording changes, such as when recording is completed or fails. This event provides information about the recording's availability and a presigned URL to access it when available.
**Attributes**
| Attribute | Type | Values | Description | Example |
| ------------------ | --------------- | ------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------- |
| **status** | `String` | `completed`, `absent`, `failed` | The current status of the recording. | `completed` |
| **recording\_url** | `String` | — | A presigned URL to access the call recording, if available. The URL is valid for one hour. | `"https://..."` |
| **timestamp** | `float` | — | Unix timestamp indicating when the event was recorded. | `1633035802.123` |
| **call\_id** | `String(uuid4)` | — | Unique identifier for the call. | `d8016985-e492-4710-b288-97229...` |
***
### I. `event_post_call`
**Description**
Emitted after a call is completed and post-processing is complete, providing comprehensive call data and details. This event contains the complete information about the call, including all of its metadata, transcripts, variable values, and other relevant information.
**Attributes**
| Attribute | Type | Description | Example |
| -------------- | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------- |
| **timestamp** | `float` | Unix timestamp indicating when the event was recorded. | `1633035802.123` |
| **call\_id** | `String(uuid4)` | Unique identifier for the call. | `d8016985-e492-4710-b288-97229...` |
| **call\_data** | `dict` | Complete call data matching the response from the [Get call details](https://roundedtechnologies.mintlify.app/api-reference/calls/get-call-details) API endpoint. | `{"id": "d8016985-e492-...", ...}` |
***
## Additional Notes
* **Optional Fields**: If a field is not relevant or was not captured in a particular scenario (e.g., `redirect_duration` when no redirect occurred), it may be omitted from the payload.
***
## Getting Started with Webhooks
1. **Set up your webhook endpoint** in your agent's dashboard.
2. **Receive and parse events** from our platform using the details above.
3. **Respond** with a 2xx status code to confirm receipt.
If you have any questions or need help integrating these events into your workflow, feel free to reach out to our support team for additional guidance.
# 1. General settings
Source: https://docs.callrounded.com/documentation/build/general-settings
### LLM Settings
For now, you have a choice between five models from the OpenAI suite. Depending on the complexity of your agent, it will be more judicious to use one over the others. You can change the model by clicking on the button **circled in red** on the screen below.
Some guidelines:
* **GPT-4o mini** and **GPT-3.5 Turbo** will work very well for very simple use cases—interactions of less than 30 seconds—that do not require multi-prompts or an extensive prompt.*Example: A temp agency agent tasked with calling temporary workers to check their availability.*
* **GPT-4o** is the default model we recommend. Its latency-reliability ratio is excellent and it applies to all use cases.
* **GPT-4 Turbo (legacy)**: We recommend GPT-4 Turbo for tasks that require processing a very large context. For example, we still use it to interpret a large amount of raw data that would be returned as context to an agent. *Example: An appointment scheduling agent that queries the availability of a calendar returning thousands of time slots.*
The improvement in GPT-4o performance and the increasing accessibility of o1 models will soon render GPT-4 obsolete.
Coming soon: Integration of GPT-4o mini real-time.
**Temperature**: Temperature it a parameter that controls how “deterministic” or “creative” the model’s output is when generating text. Lower temperatures (close to 0) make the output more deterministic and focused. You can change the temperature by clicking on the button **circled in blue** on the screen below.
### Voice Settings
For the moment, the platform offers voices in French, English, Italian, German and Spanish. Contact us at [team@callrounded.com](mailto:team@callrounded.com) to request support for other languages.
Important elements to consider when choosing voices:
* **Reliability**: While voice models are improving rapidly, they are still very imperfect in French. For example, intonations are much less natural than in English. Other issues include unexpected switching to English pronunciation for words written in French and poor pronunciation of numbers and dates.
* **Latency**: The better the voice quality, the slower the speech synthesis.
* **Stability**: The tone between two sentences can change completely. These strong variations are not acceptable in most production use cases.
* **Cost**: There is a 7x difference between the two providers we have currently selected:
We have tested a plethora of different providers. In French, we have currently selected two:
* **Azure**: Azure voices are by far the most stable and generally induce the least latency. Choose Yvette for a medical reception agent or appointment scheduling, for example.
Coming soon: Integration of other neural voices
* **ElevenLabs**: ElevenLabs voices are among the most natural on the market. The multilingual models are also the most advanced. For French, we monitor the regular outputs and select the most convincing ones.
If you want us to integrate new voices you have discovered, make a request on the Discord server.
You can change the agent's voice by clicking on the button **circled in red** in the screen below. You can listen to the chosen voice by pressing the **blue button**.
**Specific settings for ElevenLabs**:
* **Stability** slider determines how stable the voice is and the randomness between each generation. Lowering this slider introduces a broader emotional range for the voice.
* **Similarity Boost**: The similarity slider dictates how closely the AI should adhere to the original voice when attempting to replicate it.
* **Fast Option**: We currently do not recommend using fast voices as they are less reliable and less stable. However, they may be necessary for certain use cases.
* **Other settings**:
* **Initial Message**: The first message never requires generation. What first phrase do you want your agent to say when it answers/the caller answers? You can customize this message in the text box circled in red in the screen below.
* **Interruptible (beta)**: When enabled, your agent will stop speaking when interrupted. We do not recommend this setting for now and advise against it for telephone agents.
* **Agent Base Prompt**: The base prompt is the persistent prompt throughout the conversation. If you are using multi-prompt, regardless of the task you are in, the base prompt will apply. In single prompt, the base prompt is not required. We use it internally to define the general behavior of the agent.
Below is an example for a city hall receptionist. We recommend following this structure for your agents. Be sure to keep the script clear and concise, separating its sections with markers such as "####" to improve readability.
* **Webhook URL**:
The **Webhook URL** is a critical integration point that allows your system to send real-time events to users or other services. By configuring a webhook URL, you enable your application to notify external systems about various events.
**Setting Up the Webhook URL:**
1. **Provide the URL**: Enter the endpoint URL where you want to receive the events.
2. **Configure Event Types**: Specify which events you want to subscribe to.
3. **Authentication**: If required, set up authentication to secure the webhook.
4. **Testing**: Ensure that your endpoint correctly receives and processes the events.
**Example Usage:**
Suppose you have an external CRM system that needs to log all incoming calls. By setting up a webhook URL pointing to your CRM's API endpoint, every time a phone\_call\_connected event occurs, the CRM can automatically receive the call details without manual intervention.
Ensure that your webhook endpoint is secure and can handle the expected load of incoming events to prevent data loss or service interruptions.
# 5. Integrations
Source: https://docs.callrounded.com/documentation/build/integrations
Rounded allows you to connect more than **1,500 applications** via **Pipedream** to enrich your voice agents: calendars, CRMs, messaging platforms, internal tools, and much more.
This guide explains, step-by-step, how to:
* Connect your accounts
* Add integrations to a task
* Configure all fields
* Write clear instructions for the agent
***
## 1. Connecting an Integration
Before you can use an integration in an agent, you must first connect your account. One way is to do it in the dedicated **Integrations** page.
### Steps
1. Click the **Integrations** tab in the left-hand menu.
2. Search for the application you want (e.g. **Gmail**, **Slack**, **Telegram**).
3. Click **Connect** on the application card.
***
## 2. Authorising via Pipedream
A pop-up window opens to securely authorise access to your third-party account.
### Steps
* Click **Continue**.
* Log in to the external service and authorise access.
* The application now appears in **My Connections** with the status **Active**.
***
## 3. Adding the Integration to an Agent
Once your account is connected, you can use it inside your agents.
### Steps
1. Open the **Agents** tab.
2. Select the agent in which you want to add the integration.
3. Click the relevant **task** to open its settings.
4. Scroll to the bottom and click **+ Add tool**.
5. In the window that appears, click **Integrations Catalog**.
6. Select the application you have connected.
***
## 4. Configuring the Integration
After selecting the application, a configuration form appears. Below is a detailed description of each field and best practices for writing your instructions.
### App
* **What it is:** The name of the selected application. This field is automatically populated.
### Account
* **What it is:** The connected account that will be used for the action. If you have several accounts, select the one that corresponds to this integration.
### Action
* **What it is:** The operation the agent will perform.
* **Common examples:** `Add Quick Event` (Google Calendar), `Send Message` (Slack, Telegram).
* **Tip:** Choose the simplest action if you are starting out.
### Filler Sentence
* **What it is:** The sentence spoken by the agent while the action is processing.
* **Examples:** "One moment, I am preparing your reservation." • "I am sending your message, please hold on."
### Tool Definition: Name
* **What it is:** The internal, technical name of the tool.
* **Recommendations:** Use a short, lower-case name without spaces – e.g. `send_text_message_or_reply`, `book_calendar_event`.
### Tool Definition: Description
*This is the most important field.* The description acts as the **guiding prompt** the agent will follow word-for-word to prepare and execute the action.
#### Writing Recommendations
Be precise and actionable. Always include:
* Default values (duration, title, channel, identifier, …)
* Mandatory fields
* Verifications or confirmations
* What to do if information is missing
##### Detailed Description Examples
**Slack**
```md theme={null}
If the user wants to send a message, post it in the #support channel.
The message must include:
- the user's first name
- the content of the request
If no channel is specified, default to #support.
Before sending, repeat the message to the user for confirmation.
```
**Telegram**
```md theme={null}
If the user wants to send a Telegram notification, post a message in the group with chat_id -123456789.
The message must include:
- the client's name
- the phone number
- the call date
If the user specifies another chat_id, use it instead.
Before sending, repeat the message to the user for confirmation.
```
**Google Calendar**
```md theme={null}
If the user requests an appointment, create an event in the main calendar.
The title should be "Confirmed Appointment".
The default duration is 1 hour.
Before creating it, ask the user to confirm the date and time.
If no duration is specified, use 1 hour.
```
In the description, always explicitly mention the channel or chat\_id and any default values.
### Tool Definition: Parameters
* **What it is:** Parameters provided by the agent to execute the action.
Some parameters of type `enum` require the agent to first retrieve the list of possible values. This is done using a special tool named `CONFIGURE_COMPONENT`, automatically added to the agent's context. When necessary, you can instruct the agent to call the `CONFIGURE_COMPONENT` tool to obtain the list of valid parameter values before executing the action.
***
## 5. Complete Configuration Example (Telegram)
Here is a concrete example of a fully configured **Telegram** integration:
* **App:** Telegram
* **Account:** Your connected Telegram account
* **Action:** Send Message
* **Filler Sentence:** One moment, I am sending the notification.
* **Tool Definition Name:** `send_text_message_or_reply`
* **Tool Definition Description:**
```md theme={null}
If the user wants to send a Telegram notification, post a message in the group with chat_id -123456789.
The message must include:
- the client's name
- the phone number
If the user specifies another chat_id, use it.
Before sending, repeat the message to the user for confirmation.
```
***
## 6. Testing the Integration
Before going live:
1. Launch a test call.
2. Verify that:
* The action executes properly.
* Default values work as expected.
* Confirmations are correctly handled.
***
## Best Practices
* Always be explicit in the description.
* Mention the channel or group identifier.
* Indicate default values.
* Request confirmation before executing any action.
* Test multiple scenarios before moving to production.
# 3. Task
Source: https://docs.callrounded.com/documentation/build/tasks
Configuring a task involves defining a procedure to follow using a prompt, optionally utilizing tools to execute the procedure, and potentially extracting data. Depending on the procedure and the mission to accomplish, you will choose a specific model.
You can choose a different model than the default model defined in the general terms of use.
### Task Configuration
#### The Task Prompt
This section involves describing to the agent what you expect from it and the steps to follow for the conversation segment related to the task. We recommend limiting instructions here to those specific to the task. Remember, you have likely defined a base prompt in the [general settings](/documentation/build/general-settings).
To ensure reliable interactions with your agent, we recommend following the format below:
1. **Objective:**\
Define the overall goal that the agent should accomplish in this specific task. This is the broader outcome the agent is working towards, such as scheduling an appointment, answering a query, or confirming details. **2 lines maximum.**
2. **Instructions:**\
Provide a step-by-step breakdown of the actions the agent must take to achieve the objective. This includes things to say and actions to perform. Ensure the instructions are clear and precise to guide the agent effectively through the task.
3. **Response Instructions:**\
Establish a list of Dos and Don'ts for your agent in this section. This is the most empirical part of the prompt. By testing your agent, you might identify undesired behaviors.
> **Example**: A town hall agent helping a client book a room.
>
> #### Objective:
>
> In this phase of the conversation, your goal is to assist the caller in booking a room at the town hall.
>
> #### Instructions:
>
> 1. Ask the caller from which date they are looking to make a reservation.
> 2. Call the function get\_rooms\_availabilities to check room availability.
> 3. Present the available options naturally to the caller and help them choose a suitable time slot.
>
> #### Response Instructions:
>
> 1. Use the get\_rooms\_availabilities function before proposing any options.
> 2. Confirm the date only after ensuring the caller’s availability.
***
#### Variables to Extract
There is a high likelihood that you will want to automatically extract information/data from the conversation. Variables allow you to plan for this extraction.
**Example:** You create an agent for a medical office tasked with calling patients the next day who have not confirmed their appointments. Without reading all call logs, you want to have a presence list.
1. **Create a Boolean Variable:** `presence_confirmed?`. To learn how to create a variable, check the [variables section](/documentation/build/variables#getting-started-with-variables).
2. **In the Task,** under ‘Variables to extract during the conversation’, select `presence_confirmed`. To do this, press the button **circled in red** on the screen below and select the variable to be extracted.
3. **Enter a Clear Extraction Instruction:** For example, “Will the patient be present for their appointment?”. You can enter the instructions on the text bloc **highlighted in blue** in the screen below.
4. **At the End of the Task,** an extraction agent will search for the information in the conversation and store `Yes` or `No` in the `presence_confirmed` variable.
The data extracted in this way can be utilized by the agent in the subsequent procedure.\
Parameter extraction for function calls is unrelated.
***
### Adding a Task
#### Calling the Next Task
After configuring the current task, you can set up the agent to proceed to the next task in the workflow. This allows for seamless transitions between different procedures and ensures that the agent can handle complex sequences of actions efficiently.
**Steps to Call the Next Task:**
1. **Define the Next Task:**\
Ensure that the next task is already created and properly configured in your task list. To create a new task, click on the "Add task" button highlighted in red on the screen below. Once the task is created, connect it to other tasks as follows:
Use the circles at the top and bottom of the task block (see screenshot).
* The top circle (highlighted in green) represents an incoming task (another task connects to this one).
* The bottom circle (highlighted in blue) represents an outgoing task (this task leads to another one).
2. **Configure the Transition:**\
In the current task settings, locate the section for task transitions or workflow.
3. **Set Transition Conditions**\
If the transition to the next task depends on certain conditions provide the condition in the transition section.
4. **Mention the Next Task in the Task Prompt**\
You should mention the next task in the task prompt. This will help the agent to know what to do next.
**Example**:
> If the client wants to book a room, proceed to *book\_room*.
5. **Test the Workflow:**\
After setting up the transition, test the workflow to ensure that the agent correctly moves to the next task under the defined conditions.\
To test your agent, read the [test your agent section](/documentation/getting_started/build_your_first#5-test-your-agent).
# 4. Tools
Source: https://docs.callrounded.com/documentation/build/tools
Voice agents on the Rounded studio can leverage external tools and APIs to perform specific actions, improving efficiency and user experience. It's essential to clearly specify when and how these tools should be invoked, ensuring seamless integration into conversations.
### Using Predefined Tools
Rounded offers predefined tools:
* **Transfer Call** – Used to seamlessly redirect a call to another agent or department.
* **Hang Up** – Ends the call politely once the interaction is complete.
* **Press keys** – Allows the agent to press phone keypad buttons to generate DTMF tones for interacting with automated systems or entering information.
* **Wait** – Allows the agent to wait, and to skip its turn.
Clearly indicate in your prompts when these tools should be used. For instance:
> "If the user asks to speak to a manager, invoke the **'Transfer Call'** tool."
> "Once all information is collected, invoke the **'Hang Up'** tool."
> "If you are interacting with an IVR system, you can use **press keys**, and wait tools to navigate the IVR properly."
#### Transfer Calls Based on Custom Time Slots
This feature allows builders to configure call transfers based on specific time slots, defined through a JSON variable. The agent will refer to this file to determine when to transfer the call — or, if configured, hang up outside of transfer hours.
**To create the JSON Variable, follow these steps:**
1. Go to the Variables section:
* Click on **Add variable**
* In the Type dropdown, select **JSON**
2. Add the variable to the Call Context:
* Add the variable under **Variables from CSV or API (outbound calls)** or **Variables from API calls**
* You must initialize this variable with either:
* A CSV document (uploaded during outbound call setup)
* An API call that initializes the variable at call start
* Through `dynamic_variables_values` parameter if the call is started using Rounded's API
The variable content must respect the following JSON structure to be correctly interpreted by the agent.
Make sure the JSON follows this exact structure, with all times in UTC:
```json theme={null}
{
"monday": [
{"start": "08:00", "end": "12:00"},
{"start": "14:00", "end": "18:00"}
],
"tuesday": [
{"start": "09:00", "end": "17:00"}
],
"wednesday": [
{"start": "08:00", "end": "12:00"},
{"start": "14:00", "end": "18:00"}
],
"thursday": [
{"start": "09:00", "end": "17:00"}
],
"friday": [
{"start": "08:00", "end": "16:00"}
],
"saturday": [],
"sunday": []
}
```
**Important:** If the JSON is not properly formatted or not injected, the agent will assume it should transfer the call at all times.
##### Configure the Task
1. Add the "transfer call" tool:
* In the relevant task, insert the "transfer call" tool
2. Enable "set transfer hours":
* Toggle "set transfer hours"
* Link the previously created JSON variable to the input field on screen
3. (Optional) Hang up outside of transfer hours:
* If "hang up outside of transfer hours" is enabled, the agent will end the call and say a customizable filler phrase before doing so
### Creating Custom Functions
For more complex tasks, you can create custom functions that allow the agent to interact with APIs, process information, and seamlessly integrate the results into the conversation. Rounded's platform interprets API responses, enabling the agent to deliver clear, human-friendly outputs without extensive scripting for all outcomes.
#### 1. Name
Start by providing a name to your tool. It should describe the operations made by the tool, so it's more natural for the agent to call it at the appropriate time. For instance: `get_availabilities`, `book_appointment`.
#### 2. Description
Provide a description of the tool to the agent. For instance, the tool `get_availabilities` allows you to retrieve the medical practice availabilities.
#### 3. Filler Sentence
A sentence that is said by the agent each time it's calling the tool. It helps decrease the perceived latency linked to the use of the tool.
#### 4. Tool Parameters
These are the parameters that need to be filled by the agent to call the tool. A tool parameter can be optional. Adding a description to the parameter allows the agent to have more context about the information to provide. These values will be used in the API Call settings described in the next section.
#### 5. API Call Settings
* **HTTP Method**: Select the appropriate HTTP method based on the action you want the API to perform.
* **Endpoint URL**: Provide the full URL of the API endpoint that the tool will interact with. Ensure that the URL is correct and accessible.
* **Content Types**: Specify the format of the data being sent to and expected from the API. Authorized content types include: JSON and URL Parameters.
* **Headers**: Define any necessary HTTP headers required by the API. Headers can include authentication tokens, content types, and other metadata.
* **API Parameters**: Configure the parameters that the API requires to execute the request. Parameters can be constants, variables, or tool parameters.
* **API Response Mapping**: If you need the tool to fill in variable values, map your API response to variables. Associate a value to the API response by providing its path from the response root using JSONPath.
#### 6. Special API Response Fields
* **Instructions (optional)**: If your API response contains an `instructions` field at the root, only this field will be provided to the agent as a tool return. This helps the agent focus and avoids unnecessary noise in the conversation. This field cannot be mapped for the moment.
* **agent\_message (optional)**: If your API response contains an `agent_message` field at the root, the agent will directly say the content of this field. This field cannot be mapped for the moment.
Ensure that your webhook endpoint is secure and can handle the expected load of incoming events to prevent any data loss or service interruptions.
# Getting Started with Variables
Source: https://docs.callrounded.com/documentation/build/variables/getting-started-with-variables
Variables in Rounded are like in programming containers that allow you to store and manipulate data. In the context of voice agents, variables primarily serve two functions:
* Provide the agent with contextual data.
* Store data generated during the conversation.
Some variables are configured by default: the caller's number, the called number, the date and time the call started, and the call ID.
# Custom Variables
### Step 1: Declaring variables in the "Variables" tab
Before assigning values, variables must be declared to be recognized by the voice agent.
**1. Click on the black "Variables" button** (highlighted in red in the screenshot below).
**2. Select "Add a variable"** (highlighted in red in the screenshot below).
**3. Provide the following details:**
* **Variable Name** : Choose a clear and descriptive name (e.g., location\_name, location\_address, or location\_hours).
* **Type** : Specify the type of data to store (Boolean, String, Number, or Date).
**Source**: a searchable field that indicates where the stored data comes from. Three possible values:
* **API Call**: originating from an API call.
* **CSV**: when you initialize your variables at the start of a call from a CSV (see next section), or you want to initialize them from your payload when starting a call via API.
* **Extracted**: if the data is extracted from the conversation. [Learn more about variables to extract](/documentation/build/tasks#variables-to-extract).
### Step 2: Variable initialization block ("Call Context")
Once the variables are declared, you can assign values to them using the Call Context block (highlighted in red in the screenshot). This block allows you to send contextual data to the agent before the call starts, using a CSV file or an API.
#### Variables from a CSV
You initialize variables from a CSV only for agents designed to conduct call campaigns.
This involves declaring variables that will be automatically retrieved from the CSV you upload to start a call campaign. To do this, press the **‘Add a variable’** button (circled in red on the screen below), then specify the variable associated with this data. To see how to launch a call campaign, see the [Campaign](/documentation/resources/launch_a_call_campaign) section.
#### Variables from API Calls
Variables can be initialized from API requests executed before the start of each call. Each API request allows you to initialize several variables simultaneously. To assign values to variables based on API calls, you must fill in the following parameters in the following section (highlighted in red in the screen below):
* **HTTP Method**: Select the appropriate HTTP method (GET, POST, PUT, DELETE) based on the action you want the API to perform.
* **Endpoint URL**: Provide the full URL of the API endpoint that the tool will interact with. Ensure that the URL is correct and accessible.
* **Content Types**: Specify the format of the data sent and expected from the API. Allowed content types include: JSON and URL parameters.
* **Headers**: Define the necessary HTTP headers required by the API. Headers may include authentication tokens, content types, and other metadata.
* **API Parameters**: Configure the parameters required by the API to execute the request. Parameters can be constants, variables, or tool parameters.
* **API Response Mapping**: To populate variable values, map your API response to the variables. Associate a value with the API response by providing its path from the root of the response using JSONPath.
Once assigned, you can use a variable within `{{ }}` to make its value available to the agent.
Ensure that your webhook endpoint is secure and can handle the expected load of incoming events to prevent any data loss or service interruptions.
# Variable Referencing
Source: https://docs.callrounded.com/documentation/build/variables/variable-referencing
The Rounded Studio supports dynamic content insertion through variable references using `{{variable_name}}`. This feature enables personalized, context-aware conversation flows by embedding variable values where needed.
## Variable Reference Syntax
To reference any variable, wrap its name in double curly braces: `{{variable_name}}`
## Variable Types and Formatting
Variables are automatically formatted according to their defined types, but when inserted into conversation text, **all variables are ultimately rendered as strings**:
Plain text
True/false (converted to a string like `true` or `false`)
Numeric value (rendered as a string)
Formatted as `Monday, YYYY-MM-DD HH:MM:SS` (returned as a string)
Complex data structures (serialized to JSON, then inserted as a string)
## Variable Scoping
### Global Variables
Global variables are set in the call context and are accessible throughout the entire conversation flow. They can be initialized through:
Variables initialized through API requests before the call starts
Variables loaded from CSV files for call campaigns
Global variables are perfect for static context that needs to be available throughout the entire conversation, such as:
* Customer identification (`customer_id`, `account_number`)
* Contact information (`phone_number`, `email`)
* Session data (`call_id`, `timestamp`)
### Task-Specific Variables
Task-specific variables are created within a specific task and may be derived from:
Capturing user input during the task
Parsing JSON paths after an API call
Task-specific variables:
* Only become accessible **after** the task in which they are defined completes
* Cannot be referenced in the same task where they are first defined
* In a parent-child task structure, child tasks can inherit parent variables, but not vice versa
## Usage Locations
Variables can be referenced in the following places:
* Initial message
* Base prompt
* State-specific prompts
**Important Transition Scoping Rules:**
* **Conditions** can only reference variables that are available before or in the previous (origin) task
* **Filler Sentences** may include variables that were updated during the current (origin) task
* Variables must be carefully scoped to avoid undefined variable errors
## Best Practices
Map out when and how each variable will be introduced and referenced. Always ensure variables are used only after they have been assigned or mapped.
Select the appropriate data type (STRING, BOOLEAN, NUMBER, DATETIME, or JSON) for each variable to ensure proper formatting and behavior.
Reference variables only after they become available in the conversation flow. Task-specific variables cannot be referenced in the same task where they are defined.
Use consistent, correctly spelled variable names to prevent referencing errors or missing data issues.
Avoid disclosing private or confidential information in prompts, logs, or transitions.
Verify correct JSON path syntax in API response mappings. Ensure any mapped variables are used only in subsequent tasks, after the API call completes.
# Rounded Affiliation
Source: https://docs.callrounded.com/documentation/community/Rounded_Affiliation
# Rounded Affiliate Program
The **Rounded Affiliate Program** is open to anyone who wants to promote Rounded and earn rewards. Whether you’re a creator, developer, or just passionate about AI voice agents, you can share Rounded with your network and get paid for each customer you refer.
Affiliates benefit from a transparent and generous commission model, tracking dashboard, and ready-to-use assets to help them succeed.
***
## How to Apply
To join the program, simply sign up on our affiliate platform. It only takes a minute.
Apply to the Rounded Affiliate Program →
# Rounded Partner
Source: https://docs.callrounded.com/documentation/community/Rounded_Partner
# Rounded Partner Program
Welcome to the **Rounded Partner Program**, designed for agencies and developers who build end-to-end AI voice agents with our platform. Join the movement, grow your visibility, and access exclusive benefits.
***
## How to Apply
To join the Rounded Partner Program, submit your blog posts or video content that showcase how you use Rounded. We’d be happy to feature them to our growing community.
***
## What Is the Rounded Partner Program?
The Rounded Partner Program is made for agencies and developers who specialize in designing and deploying AI voice agents on our platform. Members enjoy exclusive benefits to boost their visibility, credibility, and business growth.
***
## Why Join?
The voice AI market is growing fast. By partnering with Rounded, you position yourself at the forefront of this transformation and gain access to real opportunities to grow your business. Let’s innovate together.
***
## Partnership Tiers
Reach new milestones and unlock exclusive benefits. Each level is maintained for at least six months after qualification.
***
### 🔥 Rookie
**Requirements**
* Successfully onboard 1 client in production\
or
* Publish 1 piece of content (blog or technical video)
**Benefits**
* 100 free minutes
* Marketing starter kit
* Sales and onboarding toolkit (benchmarks, slides, strategy docs)
* Access to webinars
***
### 🏆 Insider
**Requirements**
* 4 clients in production within 6 months\
or
* 4 published content pieces
**Benefits**
* Featured on Rounded website (partner profile)
* "Insider" partner badge
* Qualified leads from the Rounded team (small businesses)
* Sales strategy session with the Rounded team
* Insider goodies pack
***
### 🚀 Expert
**Requirements**
* 10 clients in production within 6 months\
or
* 10 published content pieces
**Benefits**
* "Expert" partner badge
* LinkedIn spotlight post (portrait format)
* Preferential pricing (outside affiliate program)
* Slack support channel (Enterprise)
* Qualified leads (medium businesses)
* Access to beta features (whitelist)
* Invitations to Rounded events
* Extended goodies pack
***
### 👑 Elite Agency
**Requirements**
* 20+ clients in production within 6 months\
or
* 20+ published content pieces
**Benefits**
* Full visibility: video interview and promotional feature
* Qualified leads (corporate segment)
* Strategic production support
* Platform co-branding (50+ clients)
* Elite goodies pack
* "Elite" partner badge
# 2. Build your first agent in a few minutes on Rounded
Source: https://docs.callrounded.com/documentation/getting_started/build_your_first
Take-off checklist
# Build your first agent in a few minutes on Rounded
Let’s walk through the essential steps to create, test, and deploy your first AI voice agent using Rounded.
***
## 1. Create your account
Go to the [login terminal](https://app.callrounded.com) to create your Rounded account. You can sign up with your email or Google account.
***
## 2. Choose how to start
Once inside the platform, you can either:
* Start with an existing template (recommended for first-time users)
* Start from scratch
***
## 3. Select a template
Choose the **Lab Reception** template as a starting point.\
Even if you're not building a lab receptionist, it's a good base to explore and customize.
***
## 4. Adapt the flow
Modify the flow to match your use case. You can edit the procedures, tasks, and wording to fit your needs.
***
## 5. Test your agent
To test how your agent behaves:
1. Click the chat bubble in the top-right corner of the screen
2. Then click the **Start test** button
***
## 6. Deploy your agent
Once you’re happy with the behavior, deploy your agent to make it live.
***
## 7. Assign a phone number
To make your agent reachable by phone:
* Go to the **Phone Numbers** tab
* Click **Add Phone Number**
Then:
* Select your agent under **Inbound Call Agent**
* Click **Save**
***
## 8. Call your new agent
Your agent is now ready to take calls!
By default, your account includes one phone number.\
To request more, contact us at [team@callrounded.com](mailto:team@callrounded.com).
# 1. What are Voice Agents?
Source: https://docs.callrounded.com/documentation/getting_started/what_are_voice_agents
Comprehensive overview of voice agents, their differences from callbots, key features, and how to build them using Rounded.
### 1. What are Voice Agents
* **Voice Agents vs. Callbots**: Unlike callbots and other more traditional Interactive Voice Response (IVR) systems, voice agents generate the content of each interaction on the fly. They’re powered by **large language models** (LLMs)—a type of AI popularized by ChatGPT.
* **What’s the difference?** Because the content is **generated in real time** throughout the conversation, a well-configured voice agent delivers interactions that feel far **more fluid**, **natural**, and **personalized**.
Another key difference between a voice agent and a basic voicebot lies in the agent’s ability to **perform actions**. For example, if you set up a reception agent at your car dealership and grant it access to your calendar, it can autonomously schedule appointments with callers.
Although there have been major strides in direct voice-to-voice AI models (where both input and output are voice), most voice agents still rely on a combination of different models. Coordinating these models effectively isn’t always straightforward.
* **What Makes a Good Voice Agent?** Deploying a reliable, fully functional voice agent usually requires combining four distinct building blocks:
Rounded provides the tools you need to address all four of these production challenges.
1. **Precise orchestration of the agent’s workflows (LLMs).**
2. **Integration with the right company data** to give the conversational agent more accurate context and/or to retrieve relevant data for the business.
3. **Monitoring and oversight of conversations:** tools that let you supervise and manage interactions.
4. **Telephony connectivity** (for phone-based agents): ensuring that an agent running on servers can actually answer your company’s incoming calls.
* **Can I Build an Agent on My Own?** Absolutely! This documentation is designed to help you do just that, and you’ll find additional resources on the Rounded Discord server.If you’d rather not spend the time, you can also reach out to one of our partners to handle it for you.
# Deploying an inbound agent on an existing phone line
Source: https://docs.callrounded.com/documentation/resources/deploy_on_existing_line
Deploying an inbound agent on an existing phone line can significantly enhance your customer support operations. This guide explores three principal options to achieve this, each with its unique advantages and challenges. Choose the approach that best aligns with your organization's needs, infrastructure, and operational requirements.
## Option 1: Direct Redirection to Another Line
### Overview
This option involves redirecting incoming calls from the existing phone line directly to another designated phone line where the inbound agent operates. This is the most straightforward method to route calls to an agent.
### Advantages
* **Preservation of Existing Number:** Maintains continuity for callers who are familiar with the original number.
* **Simplicity:** Easy to set up without requiring significant changes to existing infrastructure.
* **Immediate Implementation:** Quick deployment with minimal technical adjustments.
* **Flexibility:** Useful for temporary redirection needs, such as during peak times or out of office hours.
### Challenges
* **Single Use of Existing Line:** Once redirected, the original phone line cannot receive any other calls, which can be problematic for critical operations such as medical secretariats.
### Implementation Steps
1. **Identify the Target Agent Line:**
* Determine which phone line will handle the redirected calls. This is the phone line associated with the agent on the agent.
2. **Configure Call Forwarding:**
* Access your phone system settings.
* Set up call forwarding from the existing phone line to the agent's designated line.
3. **Test the Redirection:**
* Make test calls to ensure that calls are properly redirected to the agent's line.
4. **Monitor and Adjust:**
* Continuously monitor call flow and adjust settings as necessary to maintain optimal performance.
If you are limited by the number of phone channels available, redirecting calls to an agent's phone line will reduce the number of channels available. Two channels are required for the agent to be able to handle calls.
***
## Option 2: Digitalizing the Old Phone Number
### Overview
Digitalizing the old phone number involves working with phone operators or integrators to redirect incoming calls from the existing number to a new phone line provided for the inbound agent. This approach maintains the original phone number while enabling call management through a digital platform.
### Advantages
* **Preservation of Existing Number:** Maintains continuity for callers who are familiar with the original number.
* **Enhanced Call Management:** Allows for more sophisticated call routing and management.
* **Flexibility:** Agents can redirect calls back to phones used to answer calls.
### Challenges
* **Coordination with Providers:** Requires collaboration with phone operators or integrators.
* **Potential Costs:** May involve additional fees from the phone operator or integrator for the service (can be negotiated).
### Implementation Steps
1. **Consult with Phone Operators/Integrators:**
* Engage with your current phone service provider or a third-party integrator to discuss digitalizing your phone number.
2. **Set Up Digital Forwarding:**
* Configure the redirection settings to forward calls from the old number to the new agent-provided phone line.
3. **Obtain and Configure the New Number:**
* If you require a human operator to continue to answer redirected calls for instance, you can associate the phones that were associated with the older number to a new phone number.
Then you can set up a transfer tool on the agent, in order to transfer calls back to the human operator.
4. **Test the System:**
* Conduct thorough testing to ensure calls are properly redirected and managed.
***
## Option 3: Redirecting via Existing IVR Rules
### Overview
If your organization already utilizes an Interactive Voice Response (IVR) system, you can configure it to redirect calls to the inbound agent based on specific rules or criteria. This method leverages existing telephony infrastructure to manage call routing dynamically.
### Advantages
* **Utilizes Existing Infrastructure:** Builds upon your current IVR setup without requiring significant changes.
* **Advanced Call Routing:** Enables sophisticated routing based on caller input, time of day, or other predefined rules.
* **Scalability:** Easily accommodates additional agents or departments by updating IVR rules.
### Challenges
* **Complex Configuration:** Setting up advanced IVR rules can be technically challenging and may require assistance from your IVR provider.
### Implementation Steps
1. **Review Existing IVR Capabilities:**
* Assess your current IVR system's features and limitations regarding call redirection.
2. **Define Redirection Rules:**
* Determine the criteria for redirecting calls to the inbound agent (e.g., specific menu selections, caller input).
3. **Configure IVR Settings:**
* Update the IVR configuration to include rules that redirect appropriate calls to the agent's phone line.
4. **Test the Redirection Workflow:**
* Perform comprehensive testing to verify that calls are correctly routed based on the defined rules.
***
## Conclusion
Deploying an inbound agent on an existing phone line offers various approaches, each suited to different organizational needs and technical capabilities.
* **Direct Redirection** is ideal for simple, immediate call forwarding but may disrupt existing call handling.
* **Digitalizing the Old Phone Number** maintains continuity and offers advanced call management, suitable for organizations seeking flexibility and scalability.
* **Redirecting via Existing IVR Rules** leverages existing telephony infrastructure for sophisticated call routing, best for organizations with established IVR systems.
Evaluate your organization's specific requirements, resources, and long-term goals to select the most appropriate deployment option. Proper implementation and continuous monitoring will ensure that your inbound call system operates efficiently, enhancing customer satisfaction and operational effectiveness.
***
# Integrate a Knowledge Base into your Voice Agent
Source: https://docs.callrounded.com/documentation/resources/integrate_a_Knowledge_Base
The Knowledge Base allows your voice agent to access a large repository of knowledge, enabling it to answer client questions effectively without including all the information in the prompt. For example, it can be particularly useful for integrating Q\&As or detailed documents.
***
### 1. Access the Knowledge Bases Section
Go to the **"Knowledge Bases"** section, highlighted in red on the screenshot below.
***
### 2. Create a Knowledge Base
Click on the black button labeled **"Create a knowledge base"** (highlighted in blue on the screenshot).
***
### 3. Add Documents to the Knowledge Base
1. Once the new Knowledge Base is created, click on the **"Add"** button (highlighted in red on the screen below) within its section.
2. Upload the desired file by clicking on the area highlighted in blue on the screenshot. Accepted formats include PDF and TXT.
3. After uploading the documents, wait for the status to change to **"added to index"** (as shown in red on the screenshot). This confirms that the document is successfully added to the Knowledge Base and is ready for use.
You can upload multiple documents to the same Knowledge Base.
***
### 4. Using a Knowledge Base in Tasks
To enable your agent to consult the Knowledge Base, you need to configure it in the [**Tasks**](/documentation/build/tasks) section.
***
#### Step 1: Go to the Task Settings
Open the task where the agent may need to access the Knowledge Base.
***
#### Step 2: Link the Knowledge Base
Click on **"Add a knowledge base"** (highlighted in red on the screenshot below) and select the Knowledge Base you wish to associate.
***
#### Define Usage Conditions in the Prompt
Specify in the prompt when the agent should consult the Knowledge Base.\
For example:
> "If you’re unsure about the procedure for handling a lost card, consult the 'Q\&A' Knowledge Base."
# Launch a call campaign
Source: https://docs.callrounded.com/documentation/resources/launch_a_call_campaign
### 1. Declare variables
Declare the variables associated with the data in your CSV file in the [**Custom Variables**](/documentation/build/variables/getting-started-with-variables#custom-variables) section, then define them in the [**Call Context**](/documentation/build/variables/getting-started-with-variables#step-2-variable-initialization-block-call-context) section.
***
### 2. Navigate to the Campaigns section
* First, go to the **"Campaigns (outbound)"** section (highlighted in red in the screenshot below).
* Then, click on the **"Add Campaign"** black button (highlighted in blue).
***
### 3. Associate a phone number and agent
* Assign a phone number to the campaign (highlighted in red below). If you don’t have a phone number yet, refer to the [**Associate your agent with a phone number**](/documentation/getting_started/build_your_first#associate-your-agent-with-a-phone-number) section.
* Link the correct agent to the campaign (highlighted in blue).
***
### 4. Upload the CSV file
Upload your CSV to the block highlighted in red below. The file must include:
* A column named **`phone_number`** with the numbers to call.
* Columns with the exact names of the variables declared in Step 1, with appropriate values.
Use this [**CSV template**](https://rounded-studio-dev.vercel.app/files/campaign_data_example.csv) as a reference.
***
### 5. Start the campaign
To test your agent with a single number:
* Click on **"Single test"** (highlighted in blue below).
* Fill in the variables manually.
To launch the full call campaign:
* Click on the **"Start campaign"** button (highlighted in red below).
***
Calls will be processed one at a time.\
For simultaneous calls, please contact: **[team@callrounded.com](mailto:team@callrounded.com)**
# Prompting Guide
Source: https://docs.callrounded.com/documentation/resources/prompting_guide
## What is a Prompt?
A **prompt** is the instruction provided to an AI model, such as GPT-4, to generate a response. For voice agents, it defines how they interpret user intent and deliver accurate, context-aware answers. Crafting effective prompts is essential to ensure clear, efficient, and engaging interactions, as poorly designed prompts can lead to confusion or irrelevant responses.
This guide will equip you with the principles and best practices to design prompts perfectly aligned with your objectives.
## What is a Good Prompt?
A **good prompt** is concise, clear, and structured to guide the AI effectively.
* **Conciseness and Clarity**: Short, straightforward sentences are essential to avoid ambiguity, especially for voice agents operating in real-time. Precise instructions ensure the AI understands the task fully and minimize the risk of irrelevant or incomplete responses.
* **Structure**: Well-organized prompts help the model identify the distinct elements of the script, improving coherence and accuracy.
### Example
**Bad Prompt:**
> “Ask the client for his name and ask him if his available tomorrow, if not ask him for the day after tomorrow, and after the meeting is booked ask for his number”
**Improved Prompt:**
> “First, ask the client for their name. Then, check if they are available tomorrow. If they’re not, ask about their availability the day after. Once the meeting is scheduled, request their phone number.”
## Rounded Recommended Format
### 1. Global Settings Configuration for the Voice Agent
In the Global Settings section, we recommend configuring the voice agent according to the following plan:
#### Role
This defines the voice agent’s identity and the persona it should adopt. Whether the agent is acting as a helpful assistant, a customer service representative, or a more specific character, this sets the foundation for how the agent interacts with users.
#### Personality
Here, you define the tone of the agent. For example, it might be friendly, polite, professional, persuasive when necessary, or even empathetic depending on the context. The personality shapes how the agent’s responses feel to the user.
#### Style of Language
This refers to how the agent should communicate, including the formality of the language. Should the agent use formal language (like "vous" in French), be more casual, or perhaps use informal language with a conversational style? Specify if there are any specific phrasing preferences or any phrasing types to avoid.
#### Conversation Context
This section sets the stage for the conversation. For example, if the conversation occurs on a specific date, or if the agent is responding to a client call for a particular purpose (e.g., scheduling a meeting or answering a query), this context will ensure the agent tailors its responses accordingly.
These sections must be distinct, with signs indicating the start of a new section, for example: `#### Role:`
These Global Settings establish the framework for your voice agent. The instructions provided here will apply to all prompts associated with the agent, ensuring consistency and alignment throughout its interactions.
### 2. Task-Specific Prompting Format for the Voice Agent
For each task your voice agent is responsible for, use the following format to ensure clarity and consistency in its actions:
#### Objective
Define the overall goal that the agent should accomplish in this specific task. This is the broader outcome the agent is working towards, such as scheduling an appointment, answering a query, or confirming details.
#### Instructions
Provide a step-by-step breakdown of the actions the agent must take to achieve the objective. This includes things to say and actions to perform. Ensure the instructions are clear and precise to guide the agent effectively through the task.
#### In Case of Misunderstanding (Optional)
Explain what the agent should do if it encounters confusion or a misunderstanding from the user. This could involve asking for clarification, rephrasing, or providing a fallback response. Anticipating potential misunderstandings helps ensure that the agent can handle unexpected situations smoothly.
> **Example**: "Hum…I’m sorry, I didn’t quite catch that. Could you please repeat?"
These sections must be distinct, with signs indicating the start of a new section, for example: `#### Objective:`
By following this structure, you ensure that the voice agent remains focused on the objective, can perform tasks efficiently, and is prepared to handle any uncertainties that may arise during the conversation.
### 3. Separate Tasks and Use Step-by-Step Interactions
To ensure the voice agent operates smoothly and doesn’t overwhelm the user by asking multiple questions at once, it’s essential to clearly separate tasks and present them in a logical, step-by-step manner.
#### Best Practices
* **List Tasks Distinctly**: Structure each task or question as a separate instruction in the prompt. This avoids confusion and helps the agent prioritize and execute tasks in the correct order.
* **Include “Wait for User Response” (If Needed)**: If the agent doesn’t naturally pause for user input, explicitly include a directive like “Wait for user response before proceeding.” This ensures the interaction feels natural and interactive, allowing the user time to respond. However, if the agent already handles pauses naturally, this step can be omitted.
* **Logical Flow**: Arrange tasks in a sequence that mirrors a typical human conversation, progressing naturally from one topic to the next.
#### Example
**Instead of:**
> "Ask the user for their name, email, and phone number."
**Use this approach:**
1. **Ask the user’s name**: “What’s your name?”
* *Wait for user response (if necessary).*
2. **Ask for their email**: “Can you share your email address, please?”
* *Wait for user response (if necessary).*
3. **Ask for their phone number**: “Finally, what’s your phone number?”
By applying this method, the interaction becomes more user-friendly and reduces the risk of overwhelming the user or causing confusion.
## Best Practices Guides
### 1. Single-Prompt vs Multi-Prompt Approach
When designing voice agents, two prompting approaches are commonly used: the **single-prompt approach** and the **multi-prompt approach**.
#### Single-Prompt Approach
The single-prompt approach involves using a single, complete prompt to define the entire voice agent. It is simple to implement and works well for simpler agents, but it comes with limitations for more complex agents. As the prompt grows in length, it can become harder to maintain consistent responses, instructions can become less precise, and function calls may become less reliable. This can lead to answers deviating from expectations, ultimately affecting the user experience.
#### Multi-Prompt Approach
The multi-prompt approach involves structuring the agent as a tree of prompts, where each node contains its own specific prompt, custom function call instructions, and clear logic for transitioning between nodes. This method is ideal for more sophisticated agents because it improves accuracy, modularity, and maintainability. By isolating each task in its own specific prompt, the agent can execute more targeted and consistent actions, while also making it easier to update and manage interactions.
#### When to Use Each Approach
* **Single-Prompt Approach**: Use for simple agents with limited tasks, where managing a single prompt does not interfere with efficiency.
* **Multi-Prompt Approach**: Preferred for more complex voice agents, where smooth transitions between tasks and greater control are needed. It allows for better handling of varied scenarios, providing greater flexibility and simplifying long-term maintenance.
### 2. Frequent Testing and Iterations
Regularly testing the voice agent in different situations is crucial to ensure the prompt is effective. It’s important to put the agent in challenging scenarios to evaluate how it handles unexpected or complex interactions. This helps identify weaknesses or areas for improvement. By adjusting the prompt based on these tests, you can refine its performance until the agent consistently achieves a satisfactory success rate—completing tasks autonomously without requiring human intervention. Frequent testing and iteration are vital to ensure the agent responds reliably, adapts to various situations, and continues to meet user expectations over time.
### 3. Prepare a Custom Message for Misunderstandings
It’s important to prepare a clear and polite response in case the voice agent encounters a misunderstanding or is unsure about what the user is asking. Instead of the agent giving an inappropriate or vague answer, it should use a phrase like, **“Hum…I’m sorry, I didn’t quite catch that. Could you please repeat?”** This ensures the agent remains professional and avoids confusion. Having a pre-defined message for these situations helps maintain a smooth conversation flow and improves the overall user experience, as it gives users the chance to clarify their requests without feeling frustrated.
### 4. Optimize Number and Date Pronunciation
If the voice agent struggles to pronounce numbers correctly, consider writing them out in full (e.g., “twenty-four” instead of “24”) to reduce diction errors.
For dates or phone numbers, provide specific pronunciation instructions. When reading French phone numbers, the agent should:
* **Read two digits together**: (e.g., “quarante-deux” for 42) unless the pair begins with a zero, in which case each digit should be pronounced separately (e.g., 05 as “zéro cinq”).
* **Insert a short pause between each pair of digits** for better clarity.
**Example:**
> The phone number 06 05 42 should be read as: “zero six, \[pause], zero cinq, \[pause], quarante-deux.”
This ensures clear communication and minimizes misunderstandings, contributing to a professional and seamless user experience.
### 5. Add Human-Like Elements to the Agent’s Speech
To make the voice agent sound more natural and relatable, incorporate human-like speech patterns into its responses. These subtle elements can enhance the conversational experience:
* **Hesitations**: Include phrases like “Euuuh…” to simulate natural thinking pauses.
* **Slight Stutters**: For example, “I-I-I would say” can make the agent feel less robotic.
* **Ellipses for Pauses**: Use “...” to create natural breaks in speech and convey a thoughtful tone.
* **Strategic Punctuation**: Employ commas, exclamation points, or question marks to shape the agent's tone and express emotions appropriately.
These touches make the agent’s voice feel more dynamic and human, improving user engagement and creating a more authentic conversational experience.
### 6. Spell Words Phonetically for Better Pronunciation
To ensure the voice agent pronounces words correctly, don’t hesitate to spell them phonetically, reflecting how they sound rather than their standard written form. This can be particularly useful for proper nouns, uncommon words, or regional terms.
**Example:**
> Instead of writing “Montpellier,” which might be mispronounced, use “Mon-Peu-Lié.”
This approach guarantees clearer and more accurate pronunciation, improving the user experience and avoiding confusion, especially for critical information like names or locations.
### 7. Adjust the Temperature
**Temperature** in a Language Model (LLM) controls the randomness of its responses. A low temperature (close to 0) results in more predictable and focused answers, while a high temperature (closer to 1) generates more creative and varied responses.
Adjusting the temperature can help tailor the agent’s behavior:
* **Lower Temperatures**: Ideal for consistency and accuracy.
* **Higher Temperatures**: Better for creativity and flexibility.
Rounded lets you customize this setting to optimize your agent’s responses for different situations.
## Utilizing Tools Effectively
Voice agents on the Rounded studio can leverage external tools and APIs to perform specific actions, improving efficiency and user experience. It’s essential to clearly specify when and how these tools should be invoked, ensuring seamless integration into conversations.
#### Utilizing Tools Effectively
To maximize the efficiency and clarity of your agent's workflow, consider the following best practices when utilizing tools:
* **Meaningful Tool Names:** Always provide meaningful names to your tools that clearly describe their functionality. This helps the model understand the purpose of each tool and reduces ambiguity during task execution.
* **Use comprehensive tool descriptions:** Provide detailed descriptions for each tool to ensure the model understands their functionality and usage. This helps the model make informed decisions and execute tasks more effectively.
* **Use clear parameters names and descriptions:** Provide clear names and descriptions for each parameter to ensure the model understands their functionality and usage. This helps the model provide the correct information to the tool.
* **Limit the Number of Tools per Task:** Avoid using too many tools within a single task to prevent confusing the model. Tools are often linked to specific phases of the conversation, and an overload can disrupt the flow and effectiveness of the agent.
* **Strategic Tool Usage:** Use tools to provide additional variables that can be utilized in subsequent tasks. Tools can also assist the agent in choosing the next appropriate task based on the conversation's context and extracted data.
* **Organize Tools by Conversation Phases:** Structure your tools in a way that aligns with different phases of the conversation. This organization helps maintain clarity and ensures that each tool is used in the appropriate context.
* **Instructions in the api response:** Use the field `instructions` at the root of the api response to provide instructions to the agent after the tool call, instead of providing the agent with the whole api response.
* **Determistic response message:** Use the field `agent_message` at the root of the api response to provide a deterministic response to the agent after the tool call.
For more detailed information on configuring and managing tools, refer to the [Tools](/documentation/build/tools)
section.
***
# Telephony and SIP Trunking
Source: https://docs.callrounded.com/documentation/telephony/overview
Configure your phone numbers and telephony services with Rounded
# Telephony and SIP Trunking
Rounded offers you several options to manage your inbound and outbound calls. Whether you want to use our integrated numbers or connect your own telephony services, we have the solution adapted to your needs.
## Available telephony options
### 1. Rounded Numbers (Recommended to get started)
The simplest solution to begin:
* Automatic configuration
* No technical configuration required
* Support included
* Transparent billing
### 2. SIP Trunk - Connect your numbers
Use your own phone numbers via SIP trunking:
* Keep your existing numbers
* Preferential rates from your operator
* Full control over infrastructure
* Integration with existing systems
[**→ Complete SIP Trunk Guide**](/documentation/telephony/sip-trunk)
## Supported SIP providers
We have tested and validated integration with these major providers. **Other SIP providers are also compatible** - these are just our documented examples:
Twilio
The global leader in cloud communications. Simple interface and robust API.
**Advantages:**
* Excellent documentation
* 24/7 worldwide support
* Easy integration
Telnyx
Global private network with competitive rates. Ideal for high volumes.
**Advantages:**
* Very competitive rates
* Quality private network
* Modern API
Zadarma
European SIP provider with competitive international rates and flexible configuration.
**Advantages:**
* Competitive international rates
* IP and credential authentication
* Multiple server locations
### Other SIP providers
**Any SIP provider that supports standard SIP trunking will work with Rounded.** The providers above are documented examples, but you can use:
* **Local telecom operators** in your country
* **Regional SIP providers**
* **Enterprise SIP services**
* **Cloud PBX providers** with SIP trunk capabilities
* **Any RFC 3261 compliant SIP service**
Need help with a different provider? [Contact our team](mailto:team@callrounded.com) for configuration assistance.
## Provider comparison
| Provider | Ease of use | Pricing | Support | Recommended for |
| ----------- | ----------- | ------- | ------- | --------------- |
| **Twilio** | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | Startups, SMBs |
| **Telnyx** | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | High volumes |
| **Zadarma** | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐ | European market |
## Custom integrations
Using another SIP provider? **It will work!** Standard SIP trunking is universally compatible.
**Contact our technical team if you need help:**
📧 **[team@callrounded.com](mailto:team@callrounded.com)**
We can assist you with:
* Configuration guidance for any SIP provider
* Integrations with existing PBX systems
* Multi-tenant configurations
* Enterprise deployments
* Custom SIP trunk setups
## SIP Architecture
### Inbound call flow
```mermaid theme={null}
graph LR
A[Caller] --> B[Your SIP provider]
B --> C[sip.callrounded.com]
C --> D[Rounded Agent]
D --> E[Voice response]
```
### Outbound call flow
```mermaid theme={null}
graph LR
A[Rounded Agent] --> B[sip.callrounded.com]
B --> C[Your SIP provider]
C --> D[Recipient]
```
## Technical configuration
### Rounded SIP origination URI
```
sip:sip.callrounded.com;transport=tcp
```
### Recommended parameters
* **Protocol**: TCP (recommended) or UDP
* **Codecs**: G.722, G.711A, G.711U
* **DTMF**: RFC 2833
* **Port**: 5060 (standard SIP)
## Security and compliance
### Encryption
* TLS 1.2+ for signaling
* SRTP for audio streams
* Authentication by IP or credentials
### Compliance
* GDPR compliant
* European hosting available
* Secure call logs
## Next steps
1. **Beginners**: Start with integrated Rounded numbers
2. **Advanced users**: Configure a SIP trunk with your preferred provider
3. **Enterprises**: Contact us for custom configuration
💡 **Tip**: You can mix both approaches - use Rounded numbers for testing, then migrate to your SIP trunk for production.
## Support
Our team is here to support you:
* 📧 Technical support: [team@callrounded.com](mailto:team@callrounded.com)
* 📖 Complete documentation in this section
* 🎯 Configuration examples for each provider
# Connect a SIP Trunk
Source: https://docs.callrounded.com/documentation/telephony/sip-trunk
Configure your own phone number via SIP trunking for inbound and outbound calls
SIP trunking allows you to connect your own phone number to Rounded to receive and make calls. This solution is ideal for:
* Using your existing numbers
* Benefiting from preferential rates from your operator
* Keeping control over your telephony infrastructure
## Rounded SIP origination URI
To configure your SIP trunk, you will need to use this origination URI:
```
sip:sip.callrounded.com;transport=tcp
```
## Configuration methods
### Method 1: Elastic SIP Trunk (Recommended)
This method uses standard SIP trunk services from major providers. It's simple to configure and compatible with most operators.
**Documented providers:**
* [Twilio](/documentation/telephony/twilio-setup)
* [Telnyx](/documentation/telephony/telnyx-setup)
* [Zadarma](/documentation/telephony/zadarma-setup)
**Other providers:** Any standard SIP trunk provider will work with Rounded. The above are just our documented examples.
### Method 2: Custom configuration
For specific needs or advanced configurations, contact our technical team:
📧 **[team@callrounded.com](mailto:team@callrounded.com)**
Our team will support you with:
* Custom SIP configurations
* Integrations with existing PBX systems
* Multi-tenant configurations
* Dedicated technical support
## Configuration in Rounded
### 1. Phone number settings
* **Phone number**: Your number in international format (e.g.: +33156273645)
* **Friendly name**: A descriptive name to easily identify this number
### 2. SIP Trunk settings
* **Termination URI**: Your provider's SIP address (e.g.: sip.myprovider.com)
* **Username**: Optional, provided by your SIP operator
* **Password**: Optional, provided by your SIP operator
## Call flows
### Outbound calls
When your Rounded agent makes a call:
1. Rounded routes the call to your termination URI
2. Your SIP provider routes the call to the recipient
3. The caller ID displayed is the one configured
### Inbound calls
When someone calls your number:
1. Your SIP provider receives the call
2. It transfers it to the Rounded URI: `sip:sip.callrounded.com;transport=tcp`
3. Rounded triggers your voice agent
## SIP Trunk advantages
**Reduced costs**: Use your negotiated rates\
**Flexibility**: Keep your existing numbers\
**Scalability**: Easily add new numbers\
**Reliability**: Redundancy and high availability
## Next steps
1. Choose your SIP provider - use our documented guides ([Twilio](/documentation/telephony/twilio-setup), [Telnyx](/documentation/telephony/telnyx-setup), [Zadarma](/documentation/telephony/zadarma-setup)) or **any other SIP provider**
2. Configure your SIP trunk according to the provider's guide
3. Test the configuration with a test call
4. Deploy your voice agents
**Using a different provider?** No problem! Any standard SIP trunk will work - just use the Rounded origination URI: `sip:sip.callrounded.com;transport=tcp`
💡 **Tip**: Start with a test number before migrating your production numbers.
# Telnyx Configuration
Source: https://docs.callrounded.com/documentation/telephony/telnyx-setup
Step-by-step guide to configure a SIP trunk with Telnyx
## Prerequisites
* An active Telnyx account
* A Telnyx phone number or SIP trunk
* Access to the Telnyx portal
## Step 1: Create a SIP Connection
1. Log in to the [Telnyx Portal](https://portal.telnyx.com)
2. Navigate to **Voice > SIP Trunking** (or search for "SIP Connection")
3. Click **Create SIP Connection**
## Step 2: Configure Details
1. Enter connection details:
* **Name**: "TELNYX SIP TRUNK ROUNDED" (or your preferred name)
* **Type**: Select **FQDN** (recommended for Rounded integration)
## Step 3: Authentication and Routing
Choose your authentication method for outbound calls:
### Method A: Credentials (Username/Password)
* Select **Credentials**
* Enter **Username** and **Password**
* Note these credentials for Rounded configuration
### Method B: IP Address Authentication
* Select **IP Addresses**
* Add Rounded server IPs (contact [team@callrounded.com](mailto:team@callrounded.com) for IPs)
## Step 4: Inbound Configuration
Configure inbound call routing:
1. **Add FQDN** for Rounded routing:
* **DNS record type**: SRV
* **FQDN**: `sip.callrounded.com`
2. Configure other inbound settings:
* **SIP transport protocol**: TCP (recommended)
* **SIP region**: Europe (or closest to your location)
* **Codecs**: G722, G711U, G711A (recommended)
## Step 5: Outbound Configuration
Configure outbound call settings:
Key settings:
* **Outbound voice profile**: Default
* **Localization country**: Select your country
* **Channel limit**: Set according to your needs
* **Caller ID Override**: Configure if needed
## Step 6: Associate Numbers
After creating the connection, assign phone numbers:
1. Go to the **Numbers** tab in your SIP connection
2. Click **Assign number** to add existing numbers
3. Or purchase new numbers if needed
## Step 7: Configuration in Rounded
In the Rounded interface, configure your SIP trunk:
### Number settings
* **Phone number**: Your Telnyx number (e.g., +15551234567)
* **Friendly name**: "My Telnyx number"
### SIP Trunk settings
* **Termination URI**: `sip.telnyx.com`
* **Username**: Your Telnyx username (if credential authentication selected)
* **Password**: Your Telnyx password (if credential authentication selected)
## Step 8: Test the Configuration
1. In Rounded, create a simple voice agent
2. Assign it to your Telnyx number
3. Test:
* **Inbound call**: Call your Telnyx number
* **Outbound call**: Initiate a call from your agent
## Troubleshooting
### "401 Unauthorized" error
* Check authentication credentials
* Verify that authentication is correctly configured
### Inbound calls don't pass
* Check the inbound routing configuration
* Ensure the Rounded URI is correctly configured
### Audio quality issues
* Check authorized codecs
* Test different codecs (G.722 recommended)
### "403 Forbidden" error
* Check the authorized IP list
* Contact Telnyx to confirm the configuration
## Pricing
Telnyx offers:
* Competitive rates for international calls
* No monthly fixed fees for SIP connections
* Per-second billing
* Volume-based discounts
See [Telnyx pricing grid](https://telnyx.com/pricing) for more details.
## Support
For help:
* 📧 Rounded Support: [team@callrounded.com](mailto:team@callrounded.com)
* 📖 Telnyx Documentation: [Telnyx SIP Trunking](https://developers.telnyx.com/docs/v2/sip-trunking)
* 🎫 Telnyx Support: Telnyx Portal > Support
## Telnyx Advantages
**Competitive rates**: Among the cheapest on the market\
**Global coverage**: Over 150 countries\
**Modern API**: Easy integration via REST API\
**Private network**: Dedicated infrastructure for quality
💡 **Tip**: Telnyx offers excellent quality/price ratio, particularly suited for high volumes.
# Twilio Configuration
Source: https://docs.callrounded.com/documentation/telephony/twilio-setup
Step-by-step guide to configure a SIP trunk with Twilio
## Prerequisites
* An active Twilio account
* A Twilio phone number
* Access to the Twilio console
## Step 1: Create a SIP Trunk in Twilio
1. Log in to the [Twilio Console](https://console.twilio.com)
2. Search for **SIP Trunk** in the search bar
3. Click **Create new SIP Trunk**
4. Give your trunk a name (e.g., "Rounded-Trunk")
## Step 2: Configure Origination
Origination defines how Twilio handles outbound calls from Rounded.
1. In your SIP Trunk, go to the **Origination** tab
2. Click **Add new Origination URI**
3. Configure:
* **SIP URI**: `sip:sip.callrounded.com;transport=tcp`
* **Priority**: 10
* **Weight**: 10
## Step 3: Configure Termination
Termination defines how Rounded can send calls via Twilio.
1. Go to the **Termination** tab
2. Note the displayed **Termination URI** (e.g., `your-trunk.pstn.twilio.com`)
3. Configure authentication (choose one method):
### Method A: IP Access Control List (Recommended)
1. Click **+** next to **IP Access Control Lists**
2. Create a new Access Control List:
* **Friendly Name**: "Rounded ACL"
* **CIDR Network Address**: Contact [team@callrounded.com](mailto:team@callrounded.com) for Rounded IPs
### Method B: Credential Lists
1. Click **+** next to **Credential Lists**
2. Create new credentials:
* **Friendly Name**: "Rounded Credentials"
* **Username**: Choose a username
* **Password**: Generate a secure password
## Step 4: Associate your numbers
1. Go to **Numbers** tab in your SIP Trunk
2. If you don't have numbers yet, click **Add a number** > **Buy a Number**
3. Or go to **Phone Numbers > Manage > Active numbers**
4. Select the number you want to connect
5. In the number configuration:
* **A call comes in**: Select "SIP Trunk"
* Choose your previously created trunk
## Step 5: General Settings (Optional)
Configure additional trunk settings in the **General** tab:
Key settings to review:
* **Friendly name**: Descriptive name for your trunk
* **Call Recording**: Enable if needed
* **Secure Trunking**: Enable for TLS/SRTP
* **Call Transfer (SIP REFER)**: Enable for call transfers
## Step 6: Configuration in Rounded
In the Rounded interface, configure your SIP trunk:
### Number settings
* **Phone number**: Your Twilio number (e.g., +15551234567)
* **Friendly name**: "My Twilio number"
### SIP Trunk settings
* **Termination URI**: `your-trunk.pstn.twilio.com` (from step 3)
* **Username**: Leave empty (optional)
* **Password**: Leave empty (optional)
## Step 7: Test the configuration
1. In Rounded, create a simple voice agent
2. Assign it to your Twilio number
3. Test:
* **Inbound call**: Call your Twilio number
* **Outbound call**: Initiate a call from your agent
## Troubleshooting
### "403 Forbidden" error
* Check that the origination URI is correctly configured
* Make sure the trunk is active
### Inbound calls don't work
* Verify that the number is properly associated with the SIP trunk
* Check the webhook configuration in Twilio
### Degraded audio quality
* Check your internet connection
* Test with UDP protocol if TCP is problematic
## Pricing
Twilio charges:
* Inbound calls according to your plan
* Outbound calls at Twilio international rates
* Monthly fees for the SIP trunk (consult Twilio pricing)
## Support
For help:
* 📧 Rounded Support: [team@callrounded.com](mailto:team@callrounded.com)
* 📖 Twilio Documentation: [Twilio SIP Trunking](https://www.twilio.com/docs/sip-trunking)
* 🎫 Twilio Support: Twilio Console > Help & Support
⚠️ **Important**: Always test your configuration with non-critical calls before going into production.
# Zadarma Configuration
Source: https://docs.callrounded.com/documentation/telephony/zadarma-setup
Simple guide to connect Zadarma with Rounded via SIP trunk
This guide shows you how to connect your Zadarma phone numbers to Rounded using SIP trunk configuration.
## Prerequisites
* Active Zadarma account
* Zadarma phone number
* Rounded account with AI agents
## Step 1: Create SIP Trunk in Zadarma
1. Log in to your Zadarma account
2. Go to **Settings > SIP Connection**
3. Click **"ADD SIP TRUNK"**
4. Configure your SIP trunk settings
## Step 2: Get SIP Credentials
From your Zadarma SIP connection page, note:
* **SIP Server**: `sip.zadarma.com`
* **Username**: Your SIP login
* **Password**: Your SIP password
* **Port**: `5060`
## Step 3: Configure in Rounded
In Rounded, add your phone number:
### SIP Trunk Settings
* **SIP Server**: `sip.zadarma.com`
* **Port**: `5060`
* **Username**: Your Zadarma SIP username
* **Password**: Your Zadarma SIP password
* **Transport**: UDP
### Phone Number
* **Number**: Your Zadarma number (e.g., +33123456789)
* **Provider**: Zadarma
## Step 4: Test
1. Assign an AI agent to your number in Rounded
2. Call your Zadarma number to test inbound calls
3. Use Rounded to make test outbound calls
## Troubleshooting
**Connection issues**: Verify your SIP credentials are correct
**No audio**: Check firewall allows port 5060
**Call quality**: Try TCP transport instead of UDP
## Support
* 📧 Rounded: [team@callrounded.com](mailto:team@callrounded.com)
* 📞 Zadarma: +44 204 577 00 77