Skip to main content

Configure the outbound caller

Updated this week

This guide explains how partners can configure and launch outbound phone calls from the Newo.ai Platform for their customers. It covers project setup, platform limits, configurable attributes, and how to trigger a call programmatically.

‼️ PLEASE PAY CLOSE ATTENTION TO THE BELOW RATE LIMITS ‼️

The platform currently enforces the following limits:

  • Outbound call duration: 10 minutes

  • Calls to the same phone number: 1 call per 10 minutes

  • Account throughput: 100 calls per hour

  • Concurrency: No more than 5 active calls at the same time

If a customer purchases their own Twilio number, these limits will be removed.

Configure your Newo.ai project

  1. On the Newo.ai Platform, navigate to your customers' Builder.

  2. Go to the Projects page and click the three dots icon in the top-right corner.

  3. Click Create New Project.
    ​

  4. Fill in the following fields and ensure Auto update enabled has been activated:

    • Idn: outbound

    • Title: outbound

    • Module: outbound

  5. Click Create.
    ​

  6. Click the three dots icon next to the newly created Project and Force Update Project.
    ​

Configure outbound attributes

Open the Attributes page and adjust the following outbound attributes as needed:

  • Outbound - Number of Attempts
    Number of retry attempts for the outbound call. Retries occur when the user does not answer, rejects the call, or voicemail is detected.

  • Outbound - Greeting Delay
    Delay (in seconds) before the outbound greeting is played to the customer. Use to fine-tune the start of the greeting after the callee picks up.

  • Conversation - Follow-Up Timer - Voice - Interval - Conversation Started - Outbound
    Time interval (in seconds) after which the agent will follow up if the user has not responded after the conversation has started during an outbound call. Set this to -1 to disable the follow-up timer.

  • Outbound - Payload Schema
    Defines the JSON schema for the payload that will be sent after the outbound call ends. Provide a valid JSON Schema object.

  • Outbound - Request Endpoint
    HTTPS endpoint that receives the post-call payload when an outbound call ends.

  • Outbound - Request Headers
    Additional headers included in the post-call request.

Trigger an outbound call

You can initiate an outbound call by sending a POST request with natural-language instructions in the content argument. The agent will execute the instructions, which may include placing a call and taking additional actions (e.g., sending an email).

Outbound caller endpoint

  1. Navigate to the Integrations page.

  2. Under the "API Integration" section, click the three dots icon next to "webhook."

  3. Click Webhooks.
    ​

  4. On the Incoming tab, under the Idn "outbound_call_webhook," you will find the Url endpoint.
    ​

Request Examples

When sending a POST request to your Url endpoint, the following example payloads can be sent depending on your needs.

Where:

  • content: Natural-language instructions the agent parses into tasks.

  • execute_in: Optional relative delay (in minutes) before executing the task. The backend checks this argument; if present, it schedules the task accordingly. If it’s not provided, the system tries to infer timing from the content; if no time is found, it runs as soon as possible.

  • taskTypes: Optional explicit list of task types to execute, used when you don’t want the LLM to infer tasks solely from content.

  • execute_at: Accepts a date-time in the agent’s timezone. Format: %Y-%m-%d %H:%H.

Call and send an email (include the country code in the phone number): 

{
  "arguments": [
    {
      "name": "content",
      "value": "Call the user at 12345678911. Send an email to the user at [email protected] and just say hello."
    }
  ]
}

Call and have the AI Employee follow a default scenario:

{
  "arguments": [
    {
      "name": "content",
      "value": "Call the user at 12345678911. User name: Ryan. The user want to order food. During the session, follow *Make a Food order via Link* scenario."
    }
  ]
}

Delay tasks (in content):

{
  "arguments": [
    {
      "name": "content",
      "value": "Call the user at 12345678911 in 5 minutes."
    }
  ]
}

Delay tasks (execute_in) and explicit taskTypes:

{
  "arguments": [
    {
      "name": "content",
      "value": "Call the user at 12345678911. Send an email to [email protected] and a confirmation SMS."
    },
    {
      "name": "execute_in",
      "value": "2"
    },
    {
      "name": "taskTypes",
      "value": "[\"send_mail\", \"send_sms\"]"
    }
  ]
}


Execute at a specific date and time (execute_at):
​

{
  "arguments": [
    {
      "name": "content",
      "value": "Call the user at 12345678911. Send an email to [email protected] and a confirmation SMS."
    },
    {
      "name": "execute_at",
      "value": "2025-08-29 07:30"
    },
    {
      "name": "taskTypes",
      "value": "[\"send_mail\", \"send_sms\"]"
    }
  ]
}

Task Types

The following Task Types are available:

  • send_sms

  • send_email

  • make_call

  • create_meeting

Important Note

With the argument, the taskTypes value must be a JSON string (of an array). For example:

{
  "name": "taskTypes",
  "value": "[\"send_mail\", \"send_sms\", \"create_meeting\"]"
}

Callback arguments

callbackArguments will be returned to your system once the call is completed.

For example, you might want to associate the call with a specific record in your system, but the AI executing the call is unaware of this context. In this case, callbackArguments acts as a proxy: whatever values you provide will be sent back to your webhook along with other fields extracted based on the provided schema.

If no Outbound - Payload Schema attribute is defined, but a webhook is configured, the AI will skip value extraction and send only the callbackArguments (if they were included during task triggering), along with metadata such as:

  • phone_number

  • user_id (on our side)

  • task_id (the ID of the executed task)

  • status:

    • finished

    • error

    • failed (indicating the user didn’t pick up)

Example:

{
  "arguments": [
    {
      "name": "content",
      "value": "Call the user at 16505473761. This user wants to order food. Call them, greet them warmly and assist them. During the conversation, follow scenario *Make a Food order via Link*"
    },
    {
      "name": "taskTypes",
      "value": "[\"make_call\"]"
    },
    {
      "name": "callbackArguments",
      "value": "{\"id\": \"superid\"}"
    }
  ]
}

Receive post-call payloads

When an outbound call ends, the platform will POST a JSON payload to the configured Outbound - Request Endpoint. The payload structure is governed by Outbound - Payload Schema.

  • Define your schema (example placeholder):
    ​

    {
      "type": "object",
      "properties": {
        "user_email": {
          "type": "string",
          "format": "email",
          "description": "Email address associated with the user/contact"
        },
        "summary": {
          "type": "string",
          "description": "Concise natural-language summary of the call outcome and next steps"
        }
      },
      "required": [
        "user_email",
        "summary"
      ]
    }

  • Secure the endpoint with Outbound - Request Headers (e.g., a static API key) and validate requests server-side. Example:
    ​

    {
      "SECRET_API_KEY": "AIzaSyDaGmaKa4JsXZ-HjGw7ISLn_2naaBGewQe"
    }

Related Articles
Housecall Pro
Dashboard and session data overview
Agent success classification and assessment
Run outbound caller tests from a Google Sheet
Did this answer your question?