Integrations

Connect Callab AI to external systems with custom workflows and automations.

User can create custom integrations to connect Callab AI with external systems. Integrations automate workflows between calls and third-party platforms.

Integrations are advanced workflows that execute automatically based on call events. Different from webhooks which send data to a single endpoint.

What are Integrations?

Integrations allow user to:

• Connect to external APIs
• Trigger multi-step workflows
• Transform and route data
• Integrate with CRM, calendar, email
• Automate business processes
• Build custom logic flows

Use Cases:

• Update CRM after calls
• Send emails to leads
• Create calendar appointments
• Post to Slack/Teams
• Update databases
• Trigger marketing automation
• Sync with helpdesk systems

Integrations vs Webhooks

Webhooks:

• Simple POST request
• Single endpoint
• One-way data send
• User handles all logic
• Good for simple cases

Integrations:

• Multi-step workflows
• Multiple actions
• Built-in transformations
• No-code logic builder
• Good for complex automation

Create Integration

User can create integration:

1. Navigate to Integrations section
2. Click “Create Integration” button
3. Configure integration steps

Step 1: Integration Configuration

User must configure integration basics:

Integration Name:

• Enter descriptive name
• Example: “Update CRM on Call End”
• Example: “Send Welcome Email”
• Example: “Create Support Ticket”
• Helps identify integration

Trigger Event:

User selects which event triggers integration:

Call Started:

• Fires when call begins
• Use for: Call notifications, live updates
• Available data: Caller info, agent info

Call Answered:

• Fires when contact answers
• Use for: Answer tracking, real-time alerts
• Available data: Call start time, caller info

Call Ended:

• Fires when call completes (most common)
• Use for: CRM updates, follow-ups
• Available data: Full call details, outcomes

Call Outcome Extracted:

• Fires when outcomes processed
• Use for: Data routing, conditional logic
• Available data: Extracted outcomes, transcript

Voicemail Detected:

• Fires when voicemail detected
• Use for: Voicemail notifications
• Available data: Voicemail status

Transfer Completed:

• Fires when call transferred
• Use for: Transfer tracking
• Available data: Transfer details

Filter Conditions:

User can filter which calls trigger integration:

By Campaign:

• Select specific campaigns
• Example: Only “Sales Outbound”
• Narrows trigger scope

By Agent:

• Select specific agents
• Example: Only “Support Agent”
• Filters by agent type

By Outcome:

• Filter by call outcomes
• Example: Only if interested == true
• Conditional execution

By Call Duration:

• Filter by call length
• Example: Only calls > 60 seconds
• Excludes short/dropped calls

By Phone Number:

• Filter by caller/recipient number
• Example: Only specific area codes
• Geographic filtering

Filter Example:

Trigger: Call Ended
Campaign: Sales Outbound Q1
Outcome Condition: interested == true
Minimum Duration: 120 seconds

Click “Next” to configure actions.

Step 2: Add Actions

User must add actions to execute:

Action Types:

HTTP Request:

• Call external API
• POST/GET/PUT/DELETE
• Send data to any endpoint
• Most flexible option

Email:

• Send email notification
• To customer or team
• Use templates
• Include call data

Slack:

• Post message to Slack
• Specific channel
• Rich formatting
• Team notifications

CRM Integration:

• Update Salesforce
• Update HubSpot
• Create/update records
• Sync call data

Calendar:

• Create calendar event
• Update appointment
• Send invites
• Book meetings

Database:

• Insert record
• Update record
• Query data
• Store call info

Conditional Logic:

• If/then/else branches
• Multiple conditions
• Different actions per outcome
• Complex workflows

Configure Action: HTTP Request

User configures HTTP request action:

Request URL:

• Enter endpoint URL
• Example: https://api.crm.com/leads
• Must be valid URL
• HTTPS recommended

HTTP Method:

• GET: Retrieve data
• POST: Create resource (most common)
• PUT: Update resource
• DELETE: Remove resource
• PATCH: Partial update

Headers:

• Add HTTP headers
• Authorization tokens
• Content-Type
• Custom headers

Headers Example:

Authorization: Bearer sk_abc123xyz
Content-Type: application/json
X-API-Key: your_api_key

Request Body:

User can build request body with call data:

Available Variables:

• {{call_id}} - Unique call ID
• {{caller_number}} - Caller phone number
• {{duration}} - Call duration (seconds)
• {{timestamp}} - Call timestamp
• {{agent_name}} - Agent name
• {{campaign_name}} - Campaign name
• {{transcript}} - Call transcript
• {{recording_url}} - Recording URL
• {{outcome.field_name}} - Extracted outcomes
• {{contact.field_name}} - Contact data

Body Template Example:

{
  "phone": "{{caller_number}}",
  "call_duration": {{duration}},
  "interested": {{outcome.interested}},
  "notes": "{{outcome.notes}}",
  "source": "Callab AI - {{campaign_name}}",
  "call_recording": "{{recording_url}}"
}

Response Handling:

• Save response data
• Use in subsequent actions
• Error handling
• Retry logic

Add Multiple Actions

User can add multiple sequential actions:

Click “Add Action”:

• Add another action
• Executes after previous
• Can use previous response data
• Build complex workflows

Action Sequence Example:

Action 1: HTTP Request to CRM
  → Save response as {{lead_id}}

Action 2: Send Email
  → To: {{contact.email}}
  → Subject: "Follow-up from Call"
  → Body: Include {{lead_id}}

Action 3: Post to Slack
  → Channel: #sales
  → Message: "New lead {{lead_id}} created"

Conditional Actions

User can add conditional logic:

If/Then/Else Branches:

Condition:

• Check outcome value
• Example: outcome.interested == true
• Example: duration > 180
• Example: outcome.appointment_booked == true

Then Actions:

• Execute if condition true
• Example: Send to sales team
• Can have multiple actions

Else Actions:

• Execute if condition false
• Example: Add to nurture campaign
• Optional branch

Conditional Example:

IF outcome.interested == true
THEN:
  - HTTP Request: Create lead in CRM
  - Email: Send to sales team
  - Slack: Post to #hot-leads
ELSE:
  - HTTP Request: Add to nurture list
  - Email: Send thank you note

Multiple Conditions:

• AND logic: All must be true
• OR logic: Any can be true
• Nested conditions
• Complex decision trees

Click “Next” to review.

Step 3: Review and Test

User reviews integration configuration:

Review Summary:

• Integration name
• Trigger event
• Filter conditions
• All actions listed
• Action sequence

Test Integration:

• Click “Test” button
• Uses sample data
• Executes all actions
• Shows results
• Verifies connectivity

Test Results:

• Each action status
• HTTP response codes
• Error messages (if any)
• Execution time
• Success/failure indicators

Save Integration:

• Click “Create” to save
• Integration activates immediately
• Triggers on matching calls
• Logs all executions

Integration Examples

Example 1: CRM Lead Creation

Goal: Create lead in CRM when interested prospect calls

Configuration:

Name: Create CRM Lead - Interested Callers
Trigger: Call Ended
Filters:
  - Campaign: Sales Outbound
  - Outcome: interested == true
  - Duration: > 60 seconds

Actions:
1. HTTP Request to CRM
   URL: https://api.crm.com/leads
   Method: POST
   Headers:
     Authorization: Bearer {{api_key}}
   Body:
     {
       "first_name": "{{contact.first_name}}",
       "last_name": "{{contact.last_name}}",
       "phone": "{{caller_number}}",
       "company": "{{contact.company}}",
       "source": "AI Sales Call",
       "interest_level": "{{outcome.interest_level}}",
       "notes": "{{outcome.notes}}",
       "call_recording": "{{recording_url}}"
     }

2. Send Email to Sales
   To: [e-mail]
   Subject: New Hot Lead from AI Call
   Body: Lead {{contact.first_name}} showed interest...

3. Post to Slack
   Channel: #sales-leads
   Message: 🔥 New lead: {{contact.first_name}} from {{contact.company}}

Example 2: Appointment Booking

Goal: Create calendar event when appointment booked

Configuration:

Name: Book Calendar Appointment
Trigger: Call Outcome Extracted
Filters:
  - Outcome: appointment_booked == true

Actions:
1. HTTP Request to Calendar API
   URL: https://api.calendar.com/events
   Method: POST
   Body:
     {
       "title": "Meeting with {{contact.first_name}} {{contact.last_name}}",
       "date": "{{outcome.appointment_date}}",
       "time": "{{outcome.appointment_time}}",
       "attendees": ["{{contact.email}}"],
       "notes": "{{outcome.meeting_notes}}"
     }

2. Send Email Confirmation
   To: {{contact.email}}
   Subject: Appointment Confirmed
   Body: Your appointment is confirmed for {{outcome.appointment_date}}...

3. HTTP Request to CRM
   URL: https://api.crm.com/contacts/{{contact.id}}/update
   Method: PUT
   Body:
     {
       "next_appointment": "{{outcome.appointment_date}}",
       "status": "appointment_scheduled"
     }

Example 3: Support Ticket Creation

Goal: Create support ticket for issues reported during call

Configuration:

Name: Create Support Ticket
Trigger: Call Ended
Filters:
  - Campaign: Customer Support
  - Outcome: issue_reported == true

Actions:
1. HTTP Request to Helpdesk
   URL: https://api.helpdesk.com/tickets
   Method: POST
   Body:
     {
       "customer_phone": "{{caller_number}}",
       "customer_name": "{{contact.first_name}} {{contact.last_name}}",
       "issue_type": "{{outcome.issue_type}}",
       "priority": "{{outcome.priority}}",
       "description": "{{outcome.issue_description}}",
       "call_transcript": "{{transcript}}",
       "recording_url": "{{recording_url}}"
     }

2. IF outcome.priority == "high"
   THEN:
     - Send Email to Manager
     - Post to Slack #urgent-support
   ELSE:
     - Add to regular queue

Example 4: Multi-Step Sales Workflow

Goal: Complex workflow with multiple systems

Configuration:

Name: Complete Sales Workflow
Trigger: Call Ended
Filters:
  - Campaign: Sales Outbound
  - Duration: > 90 seconds

Actions:
1. HTTP Request: Check if lead exists in CRM
   URL: `https://api.crm.com/leads/search?phone={{caller_number}}`
   Method: GET
   Save response as: `{{existing_lead}}`

2. IF `{{existing_lead}}` exists
   THEN:
     - Update existing lead
     - Add call notes
     - Update status
   ELSE:
     - Create new lead
     - Set source as AI call

3. IF `outcome.interested == true`
   THEN:
     - Assign to sales rep
     - Create follow-up task
     - Send internal notification
     - Add to hot leads list

4. IF `outcome.appointment_booked == true`
   THEN:
     - Create calendar event
     - Send confirmation email
     - Add to upcoming meetings
     - Notify assigned rep

5. Always:
   - Log call to database
   - Update analytics
   - Send summary email to team

Managing Integrations

View Integrations:

• Navigate to Integrations section
• See all active integrations
• Filter by trigger event
• Search by name

Edit Integration:

• Click integration name
• Modify any settings
• Update actions
• Change conditions
• Save changes

Enable/Disable:

• Toggle integration on/off
• Keeps configuration
• Stops execution
• Can re-enable anytime

Delete Integration:

• Permanently removes
• Cannot be undone
• Execution logs preserved

Duplicate Integration:

• Copy existing integration
• Modify for new use case
• Saves configuration time

Integration Logs

User can view execution logs:

Log Information:

• Timestamp of execution
• Trigger event details
• Call information
• Each action result
• Success/failure status
• Error messages
• Execution time
• Response data

Filter Logs:

• By integration
• By status (success/failed)
• By date range
• By campaign

Debug Failed Integrations:

• View error details
• Check request/response
• Identify issues
• Test fixes

Variables Reference

Call Variables:

• {{call_id}} - Unique call identifier
• {{caller_number}} - Caller phone number
• {{recipient_number}} - Recipient phone number
• {{duration}} - Call duration in seconds
• {{timestamp}} - ISO 8601 timestamp
• {{call_status}} - answered/no-answer/voicemail
• {{recording_url}} - Call recording URL
• {{transcript}} - Full call transcript

Agent Variables:

• {{agent_id}} - Agent identifier
• {{agent_name}} - Agent name
• {{agent_language}} - Agent language

Campaign Variables:

• {{campaign_id}} - Campaign identifier
• {{campaign_name}} - Campaign name
• {{campaign_type}} - inbound/outbound

Contact Variables:

• {{contact.first_name}} - Contact first name
• {{contact.last_name}} - Contact last name
• {{contact.email}} - Contact email
• {{contact.company}} - Contact company
• {{contact.*}} - Any custom contact field

Outcome Variables:

• {{outcome.field_name}} - Any extracted outcome
• Example: {{outcome.interested}}
• Example: {{outcome.appointment_date}}
• Example: {{outcome.notes}}

Dynamic Variables:

• {{variable_name}} - Agent dynamic variables
• Populated from contact mapping
• Used during call

System Variables:

• {{workspace_id}} - Workspace identifier
• {{workspace_name}} - Workspace name
• {{execution_id}} - Integration execution ID

Best Practices

Integration Design:

• Keep integrations focused
• One clear purpose per integration
• Use descriptive names
• Document complex logic
• Test thoroughly

Error Handling:

• Add retry logic for failures
• Handle API errors gracefully
• Log all errors
• Set up error notifications
• Monitor execution logs

Performance:

• Minimize API calls
• Use batch operations when possible
• Avoid long-running actions
• Optimize request payloads
• Cache data when appropriate

Security:

• Use HTTPS for all requests
• Store API keys securely
• Rotate credentials regularly
• Follow least privilege principle
• Audit integration access

Maintenance:

• Review logs regularly
• Monitor success rates
• Update API endpoints as needed
• Test after changes
• Keep documentation current

Troubleshooting

Integration not triggering:

• Is integration enabled?
• Do filter conditions match?
• Is trigger event correct?
• Check integration logs
• Verify call matches filters

Action failing:

• Is API endpoint correct?
• Are credentials valid?
• Is request format correct?
• Check API rate limits
• Review error in logs

Variables not populating:

• Is variable name correct?
• Does field exist in call data?
• Check variable syntax (double braces)
• Review outcome extraction
• Test with sample data

Slow execution:

• Check API response times
• Reduce number of actions
• Optimize request payloads
• Remove unnecessary steps
• Check external service status

Advanced Topics

Transformations:

• Format data before sending
• Convert timestamps
• Calculate values
• String manipulations
• Data mapping

Loops:

• Iterate over arrays
• Process multiple items
• Batch operations
• Repeat actions

Error Recovery:

• Automatic retries
• Fallback actions
• Error notifications
• Graceful degradation

Rate Limiting:

• Respect API limits
• Queue actions
• Throttle requests
• Batch when possible

Testing:

• Use test mode
• Sample data testing
• Dry run executions
• Validate before production

Integration Templates

Callab provides pre-built templates:

CRM Templates:

• Salesforce lead creation
• HubSpot contact update
• Pipedrive deal creation

Communication Templates:

• Slack notifications
• Email workflows
• SMS follow-ups

Calendar Templates:

• Google Calendar booking
• Outlook appointment
• Calendly integration

Custom Templates:

• Save your integrations as templates
• Share with team
• Reuse across workspaces

Next Steps

After creating integration:

1. Test thoroughly - Verify all actions work
2. Monitor logs - Check execution success
3. Optimize performance - Improve speed
4. Document workflow - Record integration purpose
5. Train team - Ensure team understands flow

Related Documentation

• Setup Inbound Agent - Configure inbound campaigns
• Setup Outbound Agent - Configure outbound campaigns
• Webhooks Documentation - Simple webhook setup
• API Reference - Callab API details

Start with simple integrations (single HTTP request) before building complex multi-step workflows. Test each action independently first.

Rate Limits:

Integrations execute in real-time during calls. Ensure external APIs can handle your call volume. Add error handling for rate limit errors.