Proactive Callback Use Case

Enable agents to call customers back with full context of previous conversation and open issues.

Business Problem

Scenario: Agent needs to call customer back

Without Context:

Agent: "Hi, this is John from support. I'm calling you back."
Customer: "About what?"
Agent: "Let me look up your account... what was your issue again?"
Customer: Frustrated, repeats entire story
Poor experience

With Sticky Calls:

Agent pulls up caller's context before dialing
Agent: "Hi Sarah, this is John from billing. I'm calling about the refund request you made yesterday. I have good news - it's been approved!"
Customer: Impressed by proactive, informed service
Excellent experience

ROI:

📉 40% reduction in escalations
📈 55% improvement in callback CSAT
⏱️ 50% faster callback resolution
💰 Higher first-call resolution

Implementation

1. Agent Initiates Callback

Agent Workflow:

1. Agent opens CRM/dialer
2. Enters customer phone number
3. System calls: GET /v1/calls/start with ANI
4. System displays context before call connects:
   
   ┌─ Caller Context ──────────────────────┐
   │ Name: Sarah Johnson                    │
   │ Phone: +1 (415) 555-1234               │
   │                                        │
   │ Last Contact: Yesterday at 2:30 PM     │
   │                                        │
   │ Context:                               │
   │ "Customer requested refund for         │
   │  duplicate charge ($50). Submitted     │
   │  to billing team for approval."        │
   │                                        │
   │ Open Issues:                           │
   │ • Refund pending approval              │
   │                                        │
   │ Confidence: 98%                        │
   └────────────────────────────────────────┘

5. Agent reviews context
6. Agent places call fully informed

2. API Call Before Dialing

POST /v1/calls/start
{
  "call_id": "callback_001",
  "identity_hints": {
    "ani": "+14155551234",
    "external_ids": {
      "agent_id": "agent_john_123"
    }
  }
}

Response:

{
  "call_id": "callback_001",
  "customer_ref": "cust_abc123",
  "call_start": "2026-02-06T15:30:00.000Z",
  "identity": {
    "confidence": 0.98,
    "level": "very_high",
    "sources": ["ani:mobile", "recency:1day"],
    "recommendation": "reuse"
  },
  "open_intents": [
    {
      "intent": "refund_pending",
      "status": "open",
      "attempt_count": 1
    }
  ],
  "variables": {
    "last_issue": {
      "value": "Customer requested refund for duplicate charge ($50). Submitted to billing for approval.",
      "source": null,
      "ttl_seconds": 2592000
    }
  }
}

3. Informed Opening

Agent Script:

Opening: "Hi \{customer_name\}, this is \{agent_name\} from \{department\}. 
          I'm calling about \{context_summary\}."

Example: "Hi Sarah, this is John from our billing department. 
          I'm calling about the refund request you submitted yesterday."

NOT: "Hi, I'm calling you back."
NOT: "Can you remind me what this was about?"

4. Save Updated Context

After callback:

POST /v1/calls/end
{
  "call_id": "callback_001",
  "customer_ref": "cust_abc123",
  "intent": "refund_request",
  "intent_status": "resolved",
  "variables": {
    "resolution": "Callback completed. Refund approved and processed ($50). Customer satisfied.",
    "refund_amount": "50.00",
    "callback_date": "2026-02-06"
  }
}

Use Cases

Scenario 1: Follow-Up on Pending Issue

Initial Call:

Customer: "I need a refund for a duplicate charge"
Agent: "I'll submit this to billing and call you back tomorrow"
Context saved: "Refund request submitted - pending approval"
Open intent: refund_pending

Callback Next Day:

Agent pulls context before calling
Sees: Refund pending, submitted yesterday
Calls customer: "Hi Sarah, I'm calling about your refund request from yesterday. Good news - it's been approved!"
Customer: Delighted by proactive follow-up

Result: CSAT 9.5/10, issue resolved

Scenario 2: Escalation Follow-Up

Initial Call:

Customer frustrated with technical issue
Tier 1 agent: "Let me escalate this to our senior team"
Context: "Router configuration issue - needs tier 2 support"

Escalation Callback:

Senior agent reviews context
Sees full troubleshooting history
Calls customer: "Hi, I'm calling about your router issue. I've reviewed the troubleshooting you already completed..."
No repeated steps, immediate advanced support

Result: Escalation resolved, prevented churn

Scenario 3: Appointment Reminder

Scheduled Callback:

Customer scheduled technical support callback for 3 PM
At 2:55 PM, agent pulls context
Sees: "Customer needs help setting up new device"
Agent calls at 3:00 PM sharp: "Hi, I'm calling for your scheduled tech support session. I understand you need help setting up your new device?"

Result: Customer impressed by punctuality and preparation

Integration Examples

Salesforce + Five9

// Salesforce clicks dial button
// Trigger: Before call placed

async function prepareCallback(phoneNumber) {
  // Call Sticky Calls API
  const response = await fetch('https://api.stickycalls.com/v1/calls/start', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer sk_prod_abc123',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      call_id: generateCallId(),
      identity_hints: {
        ani: phoneNumber
      }
    })
  });

  const context = await response.json();

  // Display context to agent
  showContextPanel({
    previousContext: context.variables?.last_issue?.value || '',
    openIssues: context.open_intents.filter(i => i.status === 'open').map(i => i.intent),
    customerRef: context.customer_ref,
    confidence: context.identity.confidence
  });

  // Agent reviews before call connects
  return context;
}

NICE CXone Outbound

Outbound Campaign:
  ↓
Before Dial: Call Sticky Calls API
  ↓
Display Context in Agent Desktop
  ↓
Connect Call (agent is prepared)
  ↓
After Call: Save updated context

Custom CRM Integration

def initiate_callback(customer_phone):
    # Get context before calling
    context = sticky_calls.identify_caller(
        call_id=generate_id(),
        identity_hints={
            "ani": customer_phone
        }
    )

    # Show agent the context
    agent_ui.display_context({
        "last_interaction": context['variables'].get('last_issue', {}).get('value', ''),
        "open_issues": [i['intent'] for i in context['open_intents'] if i['status'] == 'open'],
        "confidence": context['identity']['confidence'],
        "customer_ref": context['customer_ref']
    })

    # Wait for agent to review (3 seconds)
    time.sleep(3)

    # Place call
    dialer.call(customer_phone)

    return context

Best Practices

1. Always Pull Context First

Never dial blind:

❌ Dial → Connect → "Can you remind me why I'm calling?"
✅ Pull context → Review → Dial → "I'm calling about \{specific issue\}"

2. Give Agents Time to Review

Don't auto-connect immediately:

# Show context
display_context(context)

# Wait 5 seconds for agent to read
time.sleep(5)

# Then connect call
place_call()

3. Highlight Open Issues

┌─ Callback Context ────────────────┐
│ ⚠️  OPEN ISSUES:                  │
│ • Refund pending (2 days old)     │
│ • Follow-up promised by today     │
│                                   │
│ Previous Context:                 │
│ "Customer was told callback would │
│  happen within 24 hours..."       │
└───────────────────────────────────┘

4. Script Opening Lines

Train agents with templates:

Template 1: Follow-up "Hi {name}, this is {agent} from {company}. I'm following up on {issue} from {date}."

Template 2: Good news "Hi {name}, I'm calling with an update on {issue}. Good news - {resolution}!"

Template 3: Scheduled "Hi {name}, this is your scheduled callback about {issue}."

5. Close the Loop

Always save outcome:

POST /v1/calls/end
{
  "call_id": "callback_001",
  "customer_ref": "cust_abc123",
  "intent": "callback_followup",
  "intent_status": "resolved",  # or "open" if unresolved
  "variables": {
    "resolution": "Callback completed. \{outcome\}. \{next_steps\}.",
    "callback_outcome": "success"
  }
}

Metrics to Track

Metric	Target	Benefit
Callback CSAT	> 9.0/10	Customer delight
Callback Completion Rate	> 90%	Follow-through
Escalation Closure Rate	> 85%	Issue resolution
Avg Callback Duration	< 3 min	Efficiency
Repeat Callback Rate	< 5%	First-time resolution

ROI Example

Company Profile:

500 callbacks/month
Agent cost: $25/hour
Average callback time: 10 minutes

Without Sticky Calls:

2 minutes wasted per call: "What was this about again?"
Total wasted time: 1,000 minutes/month = 16.7 hours
Cost: $417/month = $5,004/year

With Sticky Calls:

Zero wasted time
Callbacks 50% more effective
Escalations reduced 40%
Savings: $5,004/year + prevented escalations

Sticky Calls Cost:

500 callbacks/month × 0 credits (matches) = $0/month

ROI: Infinite (free for returning callers)

Implementation Checklist

Integrate API call before outbound dialing
Create context display UI for agents
Build 3-5 second review period
Train agents on informed callback scripts
Set up automatic context saving after callbacks
Create callback templates for common scenarios
Track callback CSAT separately
Monitor open intent closure rate
Celebrate wins with team

Next Steps

Repeat Caller Use Case - Related scenario
API Reference - Complete documentation
Best Practices - Optimization tips
Contact Support - Get help

Ready to delight customers with informed callbacks? Sign up for free →

Business Problem​

Implementation​

1. Agent Initiates Callback​

2. API Call Before Dialing​

3. Informed Opening​

4. Save Updated Context​

Use Cases​

Scenario 1: Follow-Up on Pending Issue​

Scenario 2: Escalation Follow-Up​

Scenario 3: Appointment Reminder​

Integration Examples​

Salesforce + Five9​

NICE CXone Outbound​

Custom CRM Integration​

Best Practices​

1. Always Pull Context First​

2. Give Agents Time to Review​

3. Highlight Open Issues​

4. Script Opening Lines​

5. Close the Loop​

Metrics to Track​

ROI Example​

Implementation Checklist​

Next Steps​