Developer documentation

// Create a contact
const contact = await fetch('https://api.thoughtly.com/contact/create', {
  method: 'POST',
  headers: {
    'x-api-token': 'your_api_token',
    'team_id': 'your_team_id',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    phone_number: '+15551234567',
    name: 'John Doe',
    email: 'john@example.com'
  })
});

// Trigger the call
const call = await fetch('https://api.thoughtly.com/contact/call', {
  method: 'POST',
  headers: {
    'x-api-token': 'your_api_token',
    'team_id': 'your_team_id',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    contact_id: contact.id,
    agent_id: 'your_agent_id'
  })
});

{
  'x-api-token': 'your_api_token',      // Found in dashboard settings
  'team_id': 'your_team_id'              // Your team identifier
}

async function apiCallWithRetry(url, options, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    const response = await fetch(url, options);
    
    if (response.status === 429) {
      // Wait before retrying
      await new Promise(resolve => setTimeout(resolve, Math.pow(2, i) * 1000));
      continue;
    }
    
    return response;
  }
  throw new Error('Max retries exceeded');
}

// Webhook from CRM (e.g., Salesforce)
app.post('/webhook/new-lead', async (req, res) => {
  const { phone, name, email, company } = req.body;
  
  // Create contact in Thoughtly
  const contact = await thoughtly.createContact({
    phone_number: phone,
    name: name,
    email: email,
    custom_fields: { company }
  });
  
  // Trigger call with qualification agent
  await thoughtly.triggerCall({
    contact_id: contact.id,
    agent_id: 'qualification_agent_id'
  });
  
  res.status(200).send('Call triggered');
});

// Daily cron job
cron.schedule('0 9 * * *', async () => {
  const tomorrow = new Date();
  tomorrow.setDate(tomorrow.getDate() + 1);
  
  // Get appointments for tomorrow
  const appointments = await getAppointments(tomorrow);
  
  // Trigger reminder call for each
  for (const apt of appointments) {
    await thoughtly.triggerAutomation({
      webhook_url: 'your_automation_webhook',
      payload: {
        contact_phone: apt.phone,
        appointment_time: apt.time,
        service_name: apt.service
      }
    });
  }
});

// When customer requests callback
app.post('/request-callback', async (req, res) => {
  const { phone, issue_type, priority } = req.body;
  
  // Create contact with context
  const contact = await thoughtly.createContact({
    phone_number: phone,
    custom_fields: {
      issue_type,
      priority,
      timestamp: new Date().toISOString()
    }
  });
  
  // Trigger immediate callback
  await thoughtly.triggerCall({
    contact_id: contact.id,
    agent_id: 'support_agent_id',
    priority: priority === 'urgent' ? 'high' : 'normal'
  });
  
  res.json({ message: 'Callback initiated' });
});

// Webhook endpoint to receive call completion data
app.post('/webhook/call-completed', async (req, res) => {
  const { 
    call_id, 
    agent_id, 
    duration, 
    outcome, 
    transcript,
    variables 
  } = req.body;
  
  // Update your CRM
  await crm.updateLead({
    phone: variables.phone,
    call_outcome: outcome,
    call_duration: duration,
    last_contacted: new Date()
  });
  
  // Send notification to sales team
  if (outcome === 'qualified') {
    await slack.notify('#sales', `New qualified lead: ${variables.name}`);
  }
  
  res.status(200).send('Webhook processed');
});

function isValidPhone(phone) {
  // E.164 format: +[country code][number]
  const regex = /^\+[1-9]\d{1,14}$/;
  return regex.test(phone);
}

try {
  await thoughtly.triggerCall({ contact_id, agent_id });
} catch (error) {
  if (error.status === 429) {
    // Rate limited - retry later
    await queueForRetry({ contact_id, agent_id });
  } else if (error.status === 403) {
    // Forbidden - check if outbound calling is disabled
    logger.error('Outbound calling may be disabled for this agent', error);
  } else if (error.status === 400) {
    // Invalid request - log and alert
    logger.error('Invalid API request', error);
  } else {
    // Unexpected error
    throw error;
  }
}

// .env file
THOUGHTLY_API_TOKEN=your_token_here
THOUGHTLY_TEAM_ID=your_team_id_here
THOUGHTLY_AGENT_ID=your_agent_id_here

// In your code
const config = {
  apiToken: process.env.THOUGHTLY_API_TOKEN,
  teamId: process.env.THOUGHTLY_TEAM_ID,
  agentId: process.env.THOUGHTLY_AGENT_ID
};

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  transports: [
    new winston.transports.File({ filename: 'thoughtly.log' })
  ]
});

logger.info('Call triggered', { 
  contact_id, 
  agent_id, 
  timestamp: new Date() 
});