Call History

Call history provides a comprehensive record of all voice conversations handled by your AI agents. Whether you need to audit recent calls, analyze conversation patterns, investigate customer complaints, or generate reports for compliance, the call history system gives you powerful search, filtering, and export capabilities across your entire call database.

What is Call History?

Call history is your organization’s complete archive of completed voice calls, including: Call Metadata

Call ID, status, and timestamps
Agent assignment and configuration
Endpoint (phone number) and caller information
Duration and completion time
Priority and scheduling details

Conversation Data

Full transcripts with speaker attribution
Audio recordings (if enabled)
Custom metadata from call creation
Webhook delivery status
Error messages and failure reasons

Performance Metrics

Response times and latency
Token usage and costs
Function/tool execution results
Sentiment and satisfaction scores

Data Retention: Call history is retained according to your organization’s data retention policy. Default retention is 90 days for call metadata and 30 days for recordings.

Common Use Cases

Customer Service Analysis

Review customer support calls for quality assurance
Investigate specific customer complaints or issues
Identify common questions and pain points
Train new agents based on successful conversations

Performance Monitoring

Track agent success rates over time
Analyze call duration and response times
Identify agents needing prompt optimization
Monitor tool/function call success rates

Compliance and Auditing

Generate call logs for regulatory compliance
Export call data for legal or HR purposes
Verify proper disclosure and consent procedures
Document agent behavior for audits

Campaign Analytics

Measure outbound campaign effectiveness
Compare different agent configurations
Track conversion rates from calls
Analyze A/B test results

Troubleshooting and Debugging

Investigate failed or problematic calls
Identify patterns in call failures
Debug agent configuration issues
Validate webhook deliveries

Accessing Call History

Call history is available through both the dashboard and API.

Via Dashboard

From Main Navigation:

Click Calls in the sidebar
Select the Past Calls tab
View completed calls across all agents

Past calls table with status indicators From Dashboard:

View Recent Calls widget on dashboard
Click View All to see full history
Filter by time range (24h, 7d, 30d)

From Agent Details:

Navigate to specific agent
View Calls tab
See calls filtered to that agent only

Via API

Use the CallResults search API for programmatic access:

const response = await fetch(
  'https://blackbox.dasha.ai/api/v1/callresults/search',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      page: 0,
      size: 50,
      sortField: "completedTime",
      sortDirection: "Descending"
    })
  }
);

const data = await response.json();
console.log('Total calls:', data.totalCount);
console.log('Results:', data.results);

Response Structure:

{
  "totalCount": 1234,
  "page": 0,
  "size": 50,
  "results": [
    {
      "callId": "660e8400-e29b-41d4-a716-446655440001",
      "agentId": "550e8400-e29b-41d4-a716-446655440000",
      "status": "Completed",
      "endpoint": "+1-555-123-4567",
      "startTime": "2025-10-20T10:36:00Z",
      "completedTime": "2025-10-20T10:41:30Z",
      "duration": 330,
      "inspectorUrl": "https://inspector.dasha.ai/calls/660e8400...",
      "additionalData": {
        "customerId": "cust_789"
      }
    }
  ]
}

API Performance: Use pagination and filters to limit result sets. Requesting thousands of calls without filters can be slow.

Filtering Call History

Narrow down call history using powerful filtering options.

Dashboard Filters

Status Filter

Completed: Successfully finished calls
Failed: Calls that encountered errors
Cancelled: Calls removed before starting
All: Show all statuses

Agent Filter

Select specific agents from dropdown
View calls for one or multiple agents
Option to show all agents

Date Range Filter

Last 24 Hours: Recent calls only
Last 7 Days: Past week
Last 30 Days: Past month
Custom Range: Pick specific start and end dates

Endpoint Filter

Search by phone number
Partial matches supported
Example: “555” finds all numbers containing “555”

Filter panel with multiple filter options

API Filters

Apply filters directly in the search request body: Filter by Status:

{
  page: 0,
  size: 50,
  callStatuses: ["Completed", "Failed"],
  sortField: "completedTime",
  sortDirection: "Descending"
}

Filter by Agent:

{
  page: 0,
  size: 50,
  agentIds: ["550e8400-e29b-41d4-a716-446655440000"],
  sortField: "completedTime",
  sortDirection: "Descending"
}

Filter by Date Range:

{
  page: 0,
  size: 50,
  fromDate: "2025-10-01T00:00:00Z",
  toDate: "2025-10-31T23:59:59Z",
  sortField: "completedTime",
  sortDirection: "Descending"
}

Filter by Endpoint (Phone Number):

{
  page: 0,
  size: 50,
  endpoint: "+1-555-123-4567",
  sortField: "completedTime",
  sortDirection: "Descending"
}

Combine Multiple Filters:

{
  page: 0,
  size: 50,
  agentIds: ["550e8400-e29b-41d4-a716-446655440000"],
  callStatuses: ["Completed"],
  fromDate: "2025-10-20T00:00:00Z",
  toDate: "2025-10-20T23:59:59Z",
  sortField: "duration",
  sortDirection: "Descending"
}

Search Functionality

Find specific calls using search capabilities.

Dashboard Search

Quick Search:

Use search bar above call history table
Search by:
- Call ID (exact match)
- Phone number (partial match)
- Agent name (partial match)
Results update as you type

Advanced Search:

Click Advanced button
Combine multiple criteria:
- Status + Date range
- Agent + Phone number
- Custom metadata fields
Save common searches as filters

API Search with Text Query

Search call transcripts and metadata:

const response = await fetch(
  'https://blackbox.dasha.ai/api/v1/callresults/search',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      page: 0,
      size: 50,
      searchText: "order status",
      sortField: "completedTime",
      sortDirection: "Descending"
    })
  }
);

const data = await response.json();
console.log('Calls mentioning "order status":', data.results.length);

Search by Custom Metadata

Find calls using custom additionalData via the additionalDataFilters parameter:

{
  page: 0,
  size: 50,
  additionalDataFilters: {
    "campaignId": "fall_2025_survey",
    "segment": "high_value"
  },
  sortField: "completedTime",
  sortDirection: "Descending"
}

Search Performance: Text searches across transcripts can be slower than metadata searches. Use specific filters when possible.

Call List View

Understand the information displayed in call history tables.

Table Columns

Call ID

Unique identifier (UUID)
Click to view call details
Copy to clipboard with click

Status

Completed (green): Successful call
Failed (red): Error or failure
Cancelled (yellow): Removed from queue
Hover for status details

Agent

Agent name and ID
Click to view agent details
Shows agent configuration version

Endpoint

Phone number or SIP URI called
Formatted for readability
Click to search all calls to this number

Duration

Total call length (MM:SS)
Excludes queue time
Only shown for completed calls

Completed Time

When call finished
Displayed in your local timezone
Hover for exact timestamp

Actions

Inspect: Open call inspector for details
Play: Listen to recording (if available)
Export: Download call data

Complete call history table view

Row Details Expansion

Click any row to expand and see: Additional Metadata:

Created time and scheduled time
Priority level
Deadline (if set)
Custom additionalData fields

Quick Metrics:

Response time average
Token usage and cost
Sentiment score (if available)
Function calls executed

Quick Actions:

View full transcript
Download recording
Copy call ID
Delete call record

Sorting Options

Organize call history by different fields.

Available Sort Fields

Completed Time (default)

Most recently completed calls first
Useful for monitoring recent activity
Default sort: Descending (newest first)

Duration

Longest or shortest calls first
Identify unusually long/short conversations
Useful for analyzing call efficiency

Created Time

When call was originally scheduled
Different from completion time
Useful for tracking scheduling patterns

Status

Alphabetically by status
Groups all completed, failed, etc.
Useful for reviewing failures together

Dashboard Sorting

Click column header to sort by that field
Click again to reverse sort direction
Arrow indicator shows current sort
Default: Completed Time (newest first)

Column headers with sort indicators

API Sorting

Specify sort field and direction in request: Sort by Completion Time (newest first):

{
  page: 0,
  size: 50,
  sortField: "completedTime",
  sortDirection: "Descending"
}

Sort by Duration (longest first):

{
  page: 0,
  size: 50,
  sortField: "duration",
  sortDirection: "Descending"
}

Sort by Status:

{
  page: 0,
  size: 50,
  sortField: "status",
  sortDirection: "Ascending"
}

Exporting Call Data

Download call history for offline analysis, archiving, or integration.

Dashboard Export

Export Current View:

Apply desired filters to call history
Click Export button above table
Select export format:
- CSV: Spreadsheet format
- JSON: Structured data format
- Excel: XLSX with formatting
Download begins automatically

Export Options:

Current Page: Only visible calls
All Results: All calls matching current filters
Include Transcripts: Add full conversation text
Include Recordings: Add audio file links

Export dialog with format and options

API Export

Export to CSV:

const response = await fetch(
  'https://blackbox.dasha.ai/api/v1/callresults/search',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json',
      'Accept': 'text/csv'
    },
    body: JSON.stringify({
      page: 0,
      size: 1000,
      fromDate: "2025-10-01T00:00:00Z",
      toDate: "2025-10-31T23:59:59Z"
    })
  }
);

const csvData = await response.text();
console.log('CSV export:', csvData);

Export to JSON:

const response = await fetch(
  'https://blackbox.dasha.ai/api/v1/callresults/search',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      page: 0,
      size: 1000,
      agentIds: ["550e8400-e29b-41d4-a716-446655440000"],
      includeTranscripts: true
    })
  }
);

const jsonData = await response.json();

// Save to file
const fs = require('fs');
fs.writeFileSync('call-history.json', JSON.stringify(jsonData, null, 2));

Automated Daily Export:

// Scheduled job to export previous day's calls
async function dailyExport() {
  const yesterday = new Date();
  yesterday.setDate(yesterday.getDate() - 1);
  const startOfDay = new Date(yesterday.setHours(0,0,0,0)).toISOString();
  const endOfDay = new Date(yesterday.setHours(23,59,59,999)).toISOString();

  const response = await fetch(
    'https://blackbox.dasha.ai/api/v1/callresults/search',
    {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        page: 0,
        size: 10000,
        fromDate: startOfDay,
        toDate: endOfDay,
        includeTranscripts: true
      })
    }
  );

  const data = await response.json();
  const filename = `calls_${yesterday.toISOString().split('T')[0]}.json`;

  // Upload to S3, send to data warehouse, etc.
  await uploadToS3(filename, data);
}

Automation Best Practice: Schedule automated exports to your data warehouse or analytics platform for long-term analysis and reporting.

Call Details Inspection

Click into individual calls for comprehensive analysis.

Opening Call Details

From Dashboard:

Locate call in history table
Click Inspect button or click the row
Call inspector opens in new tab

From API:

const callId = "660e8400-e29b-41d4-a716-446655440001";

// Search for specific call using callIds filter
const response = await fetch(
  'https://blackbox.dasha.ai/api/v1/callresults/search',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      page: 0,
      size: 1,
      callIds: [callId]
    })
  }
);

const data = await response.json();
if (data.results.length > 0) {
  const call = data.results[0];
  console.log('Call details:', call);
  console.log('Inspector URL:', call.inspectorUrl);
} else {
  console.log('Call not found');
}

Call Inspector Features

The call inspector provides deep analysis: Conversation Tab:

Full transcript with timestamps
Speaker attribution (agent vs user)
Audio playback controls
Download transcript option

Performance Tab:

Response time breakdown
Token usage and costs
Latency analysis (STT, LLM, TTS)
Network performance

Tools Tab:

Function/tool executions
Parameters and results
Execution time
Error details (if any)

Webhooks Tab:

Webhook delivery status
Request/response payloads
Retry attempts
Delivery errors

See Call Inspector Deep Dive for complete inspector documentation.

Pagination

Handle large call volumes efficiently with pagination.

Dashboard Pagination

Page Controls:

Page Size: 10, 25, 50, 100 calls per page
Page Navigation: First, Previous, Next, Last buttons
Jump to Page: Enter page number directly
Total Count: Shows total matching calls

Pagination controls showing current page and total

API Pagination

Basic Pagination:

{
  page: 0,      // First page (zero-indexed)
  size: 50,     // Calls per page
  sortField: "completedTime",
  sortDirection: "Descending"
}

Fetching All Pages:

async function getAllCalls(filters) {
  const allCalls = [];
  let page = 0;
  const size = 100;
  let hasMore = true;

  while (hasMore) {
    const response = await fetch(
      'https://blackbox.dasha.ai/api/v1/callresults/search',
      {
        method: 'POST',
        headers: {
          'Authorization': 'Bearer YOUR_API_KEY',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          page,
          size,
          callStatuses: filters.callStatuses,
          fromDate: filters.fromDate,
          toDate: filters.toDate,
          agentIds: filters.agentIds,
          sortField: "completedTime",
          sortDirection: "Descending"
        })
      }
    );

    const data = await response.json();
    allCalls.push(...data.results);

    hasMore = data.results.length === size;
    page++;
  }

  return allCalls;
}

// Usage
const calls = await getAllCalls({
  callStatuses: ["Completed"],
  fromDate: "2025-10-01T00:00:00Z",
  toDate: "2025-10-31T23:59:59Z"
});

console.log('Total calls retrieved:', calls.length);

Performance: Fetching all pages for large datasets can be slow. Use filters to reduce result size or implement cursor-based pagination for better performance.

API Access Patterns

Common patterns for working with call history via API.

Find Calls by Campaign

Track all calls for a specific marketing campaign:

const response = await fetch(
  'https://blackbox.dasha.ai/api/v1/callresults/search',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      page: 0,
      size: 1000,
      additionalDataFilters: {
        "campaignId": "fall_2025_survey"
      }
    })
  }
);

const data = await response.json();

// Calculate campaign metrics
const total = data.totalCount;
const completed = data.results.filter(c => c.status === 'Completed').length;
const failed = data.results.filter(c => c.status === 'Failed').length;
const avgDuration = data.results
  .filter(c => c.duration)
  .reduce((sum, c) => sum + c.duration, 0) / completed;

console.log('Campaign Results:');
console.log(`Total calls: ${total}`);
console.log(`Completed: ${completed} (${(completed/total*100).toFixed(1)}%)`);
console.log(`Failed: ${failed} (${(failed/total*100).toFixed(1)}%)`);
console.log(`Avg duration: ${Math.round(avgDuration)}s`);

Analyze Failed Calls

Investigate patterns in call failures:

const response = await fetch(
  'https://blackbox.dasha.ai/api/v1/callresults/search',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      page: 0,
      size: 500,
      callStatuses: ["Failed"],
      fromDate: "2025-10-20T00:00:00Z",
      toDate: "2025-10-20T23:59:59Z"
    })
  }
);

const data = await response.json();

// Group by failure reason
const failureReasons = {};
data.results.forEach(call => {
  const reason = call.failureReason || 'Unknown';
  failureReasons[reason] = (failureReasons[reason] || 0) + 1;
});

console.log('Failure breakdown:');
Object.entries(failureReasons)
  .sort((a, b) => b[1] - a[1])
  .forEach(([reason, count]) => {
    console.log(`${reason}: ${count} calls`);
  });

Generate Daily Report

Create automated daily performance reports:

async function generateDailyReport(date) {
  const startOfDay = new Date(date);
  startOfDay.setHours(0, 0, 0, 0);
  const endOfDay = new Date(date);
  endOfDay.setHours(23, 59, 59, 999);

  const response = await fetch(
    'https://blackbox.dasha.ai/api/v1/callresults/search',
    {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        page: 0,
        size: 10000,
        fromDate: startOfDay.toISOString(),
        toDate: endOfDay.toISOString(),
        includeTranscripts: false
      })
    }
  );

  const data = await response.json();

  const report = {
    date: date.toISOString().split('T')[0],
    totalCalls: data.totalCount,
    completed: data.results.filter(c => c.status === 'Completed').length,
    failed: data.results.filter(c => c.status === 'Failed').length,
    avgDuration: calculateAvgDuration(data.results),
    byAgent: groupByAgent(data.results),
    topIssues: extractTopIssues(data.results)
  };

  return report;
}

Best Practices

Data Retention and Archiving

Implement Retention Policies:

Export calls older than 90 days to cold storage
Delete personal data per GDPR/privacy regulations
Keep aggregated metrics for longer periods
Archive critical calls separately

Automated Archiving:

// Daily job to archive old calls
async function archiveOldCalls() {
  const cutoffDate = new Date();
  cutoffDate.setDate(cutoffDate.getDate() - 90);

  const response = await fetch(
    'https://blackbox.dasha.ai/api/v1/callresults/search',
    {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        page: 0,
        size: 1000,
        toDate: cutoffDate.toISOString(),
        includeTranscripts: true
      })
    }
  );

  const data = await response.json();

  // Archive to S3, Glacier, etc.
  await archiveToLongTermStorage(data.results);

  // Optionally delete from Dasha BlackBox
  // (check your compliance requirements first)
}

Performance Optimization

Use Specific Filters:

// Good: Narrow date range and specific agent
{
  agentIds: ["550e8400-e29b-41d4-a716-446655440000"],
  fromDate: "2025-10-20T00:00:00Z",
  toDate: "2025-10-20T23:59:59Z"
}

// Avoid: Fetching all calls without filters
{
  page: 0,
  size: 10000
  // No filters - slow query
}

Limit Page Size:

Use reasonable page sizes (50-100)
Don’t request thousands of calls per page
Implement cursor pagination for large datasets

Cache Common Queries:

// Cache frequently accessed data
const cache = new Map();

async function getCachedCallHistory(cacheKey, filters) {
  if (cache.has(cacheKey)) {
    const cached = cache.get(cacheKey);
    if (Date.now() - cached.timestamp < 5 * 60 * 1000) { // 5 min cache
      return cached.data;
    }
  }

  const data = await fetchCallHistory(filters);
  cache.set(cacheKey, { data, timestamp: Date.now() });
  return data;
}

Security and Privacy

PII Handling:

Redact sensitive information before sharing
Implement role-based access to call history
Audit access to call recordings
Encrypt exports containing personal data

API Key Security:

// Good: Use environment variables
const API_KEY = process.env.BLACKBOX_API_KEY;

// Bad: Hard-coded API keys
// const API_KEY = "bb_live_1234567890abcdef"; // NEVER DO THIS

Access Control:

Limit call history access to authorized users
Use read-only API keys for reporting
Implement audit logs for sensitive data access
Separate production and staging API keys

Troubleshooting

Missing Calls in History

Symptoms:

Expected calls don’t appear in history
Call count lower than expected
Recent calls not showing up

Possible Causes:

Calls still in progress (not completed yet)
Date range filter excluding calls
Agent filter excluding calls
Calls deleted or archived
Database sync delay

Solution:

Check date range filters (expand to wider range)
Remove agent filters (show all agents)
Verify calls actually completed (check status)
Wait 1-2 minutes for database sync
Check call queue for in-progress calls

// Verify call exists by ID using search
const callId = "660e8400-e29b-41d4-a716-446655440001";

const response = await fetch(
  'https://blackbox.dasha.ai/api/v1/callresults/search',
  {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      page: 0,
      size: 1,
      callIds: [callId]
    })
  }
);

const data = await response.json();
if (data.results.length > 0) {
  const call = data.results[0];
  console.log('Call status:', call.status);
  console.log('Completed:', call.completedTime);
} else {
  console.error('Call not found');
}

Slow Search Performance

Symptoms:

Search takes longer than 5 seconds
Dashboard becomes unresponsive
API requests timeout

Possible Causes:

Searching across too many calls
Text search on transcripts (slow)
No filters applied
Very large page size

Solution:

Add date range filters to narrow results
Use metadata filters instead of text search
Reduce page size to 50 or less
Search specific agents only
Avoid searching transcripts when possible

Optimized Query:

// Slow: Text search across all calls
{
  searchText: "order status",
  page: 0,
  size: 1000
}

// Fast: Metadata search with date filter
{
  agentIds: ["550e8400-e29b-41d4-a716-446655440000"],
  fromDate: "2025-10-20T00:00:00Z",
  toDate: "2025-10-20T23:59:59Z",
  additionalDataFilters: {
    "topic": "order_status"
  },
  page: 0,
  size: 50
}

Export Failures

Symptoms:

Export downloads are empty
Export process hangs or times out
Corrupted export files

Possible Causes:

Too many calls in export (timeout)
Network interruption during download
Insufficient permissions
Server-side timeout

Solution:

Reduce export size (add filters)
Export in smaller batches
Use API instead of dashboard for large exports
Check network connection stability

Batch Export:

async function exportInBatches(searchParams, batchSize = 1000) {
  const exports = [];
  let page = 0;
  let hasMore = true;

  while (hasMore) {
    const response = await fetch(
      'https://blackbox.dasha.ai/api/v1/callresults/search',
      {
        method: 'POST',
        headers: {
          'Authorization': 'Bearer YOUR_API_KEY',
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          page,
          size: batchSize,
          callStatuses: searchParams.callStatuses,
          fromDate: searchParams.fromDate,
          toDate: searchParams.toDate,
          agentIds: searchParams.agentIds,
          additionalDataFilters: searchParams.additionalDataFilters
        })
      }
    );

    const data = await response.json();
    exports.push(...data.results);

    hasMore = data.results.length === batchSize;
    page++;

    // Save batch to disk to avoid memory issues
    if (exports.length >= 5000) {
      await saveToDisk(`export_batch_${page}.json`, exports);
      exports.length = 0; // Clear array
    }
  }

  return exports;
}

Next Steps

Now that you understand call history:

Call Inspector: Call Inspector Deep Dive - Detailed call analysis
Call Transcripts: Call Transcripts - Working with conversation data
Analytics: Performance Analytics - Aggregate metrics and trends
Post-Call Analysis: Post-Call Analysis - Advanced analytics workflows
Exporting Data: Data Export Guide - Comprehensive export strategies

For monitoring and management:

Call Management: Call Management - Managing active calls
Dashboard Overview: Dashboard Overview - Understanding dashboard metrics
Agent Performance: Agent Performance - Optimizing agents

API Cross-Refs

Call history related API endpoints:

POST /api/v1/callresults/search - Search call history with filters and aggregations
GET /api/v1/calls/{callId} - Get detailed call information
GET /api/v1/calls/list - List all calls in organization
GET /api/v1/calls/media/{recordId} - Stream call audio recording
GET /api/v1/calls/statistics/statuses - Get call statistics by status

Introduction

Build

Deploy

Monitor

Webhooks & Events

Advanced

WebSockets

​Call History

​What is Call History?

​Common Use Cases

​Customer Service Analysis

​Performance Monitoring

​Compliance and Auditing

​Campaign Analytics

​Troubleshooting and Debugging

​Accessing Call History

​Via Dashboard

​Via API

​Filtering Call History

​Dashboard Filters

​API Filters

​Search Functionality

​Dashboard Search

​API Search with Text Query

​Search by Custom Metadata

​Call List View

​Table Columns

​Row Details Expansion

​Sorting Options

​Available Sort Fields

​Dashboard Sorting

​API Sorting

​Exporting Call Data

​Dashboard Export

​API Export

​Call Details Inspection

​Opening Call Details

​Call Inspector Features

​Pagination

​Dashboard Pagination

​API Pagination

​API Access Patterns

​Find Calls by Campaign

​Analyze Failed Calls

​Generate Daily Report

​Best Practices

​Data Retention and Archiving

​Performance Optimization

​Security and Privacy

​Troubleshooting

​Missing Calls in History

​Slow Search Performance

​Export Failures

​Next Steps

​API Cross-Refs

Call History

What is Call History?

Common Use Cases

Customer Service Analysis

Performance Monitoring

Compliance and Auditing

Campaign Analytics

Troubleshooting and Debugging

Accessing Call History

Via Dashboard

Via API

Filtering Call History

Dashboard Filters

API Filters

Search Functionality

Dashboard Search

API Search with Text Query

Search by Custom Metadata

Call List View

Table Columns

Row Details Expansion

Sorting Options

Available Sort Fields

Dashboard Sorting

API Sorting

Exporting Call Data

Dashboard Export

API Export

Call Details Inspection

Opening Call Details

Call Inspector Features

Pagination

Dashboard Pagination

API Pagination

API Access Patterns

Find Calls by Campaign

Analyze Failed Calls

Generate Daily Report

Best Practices

Data Retention and Archiving

Performance Optimization

Security and Privacy

Troubleshooting

Missing Calls in History

Slow Search Performance

Export Failures

Next Steps

API Cross-Refs