Node.JS

npm install ccai-node

CCAI_CLIENT_ID=your-client-id
CCAI_API_KEY=your-api-key

npm install dotenv

import { CCAI } from 'ccai-node';
import 'dotenv/config';

const ccai = new CCAI({
  clientId: process.env.CCAI_CLIENT_ID,
  apiKey: process.env.CCAI_API_KEY
});

ccai.sms.sendSingle(
  "Jane",
  "Smith",
  "+15559876543",
  "Hi ${firstName}, thanks for your interest!",
  "Single Message Test"
)
  .then(response => console.log('Success:', response))
  .catch(error => console.error('Error:', error));

const accounts = [
  { firstName: "John", lastName: "Doe", phone: "+15551234567" },
  { firstName: "Jane", lastName: "Smith", phone: "+15559876543" },
  { firstName: "Bob", lastName: "Johnson", phone: "+15551112222" }
];

ccai.sms.send(
  accounts,
  "Hello ${firstName} ${lastName}, this is a campaign message!",
  "Bulk SMS Campaign"
)
  .then(response => console.log('Campaign sent:', response))
  .catch(error => console.error('Error:', error));

const options = {
  timeout: 60,
  retries: 3,
  onProgress: (status) => console.log(`${new Date().toISOString()} - ${status}`)
};

ccai.sms.send(accounts, message, "Campaign Title", options)
  .then(response => console.log('Success:', response))
  .catch(error => console.error('Error:', error));

const account = {
  firstName: "John",
  lastName: "Doe",
  phone: "+15551234567"
};

const options = {
  timeout: 60,
  onProgress: (status) => console.log(`Progress: ${status}`)
};

ccai.mms.sendWithImage(
  "path/to/your/image.jpg",
  "image/jpeg",
  [account],
  "Hello ${firstName}, check out this image!",
  "MMS Campaign Example",
  options
)
  .then(response => console.log(`MMS sent! Campaign ID: ${response.campaignId}`))
  .catch(error => console.error('Error:', error));

// Step 1: Get a signed URL for uploading
const uploadResponse = await ccai.mms.getSignedUploadUrl("image.jpg", "image/jpeg");
const { signedS3Url, fileKey } = uploadResponse;

// Step 2: Upload the image to the signed URL
const uploadSuccess = await ccai.mms.uploadImageToSignedUrl(
  signedS3Url,
  "path/to/your/image.jpg",
  "image/jpeg"
);

if (uploadSuccess) {
  // Step 3: Send the MMS with the uploaded image
  const response = await ccai.mms.send(
    fileKey,
    accounts,
    "Hello ${firstName}, check out this image!",
    "MMS Campaign Example"
  );
  console.log(`MMS sent! Campaign ID: ${response.campaignId}`);
}

const response = await ccai.mms.sendSingle(
  "your-client-id/campaign/image.jpg",
  "John",
  "Doe",
  "+15551234567",
  "Hello ${firstName}, check out this image!",
  "MMS Campaign"
);

const response = await ccai.email.sendSingle(
  "John",
  "Doe",
  "[email protected]",
  "Welcome to Our Service",
  "<p>Hello ${firstName},</p><p>Thank you for signing up!</p>",
  "[email protected]",
  "[email protected]",
  "Your Company",
  "Welcome Email"
);

console.log(`Email sent with ID: ${response.id}`);

const emailAccounts = [
  { firstName: "John", lastName: "Doe", email: "[email protected]" },
  { firstName: "Jane", lastName: "Smith", email: "[email protected]" }
];

const campaign = {
  subject: "Monthly Newsletter",
  title: "July 2025 Newsletter",
  message: `
    <h1>Monthly Newsletter</h1>
    <p>Hello \${firstName},</p>
    <p>Here are our updates for this month...</p>
  `,
  senderEmail: "[email protected]",
  replyEmail: "[email protected]",
  senderName: "Your Company Newsletter",
  accounts: emailAccounts,
  campaignType: "EMAIL",
  addToList: "noList",
  contactInput: "accounts",
  fromType: "single",
  senders: []
};

const options = {
  onProgress: (status) => console.log(`Progress: ${status}`)
};

const campaignResponse = await ccai.email.sendCampaign(campaign, options);
console.log(`Email campaign sent with ID: ${campaignResponse.id}`);

const tomorrow = new Date();
tomorrow.setDate(tomorrow.getDate() + 1);
tomorrow.setHours(10, 0, 0, 0);

const scheduledCampaign = {
  subject: "Upcoming Event Reminder",
  title: "Event Reminder Campaign",
  message: `
    <h1>Reminder: Upcoming Event</h1>
    <p>Hello \${firstName},</p>
    <p>This is a reminder about our upcoming event tomorrow.</p>
  `,
  senderEmail: "[email protected]",
  replyEmail: "[email protected]",
  senderName: "Your Company Events",
  accounts: emailAccounts,
  scheduledTimestamp: tomorrow.toISOString(),
  scheduledTimezone: "America/New_York"
};

const scheduledResponse = await ccai.email.sendCampaign(scheduledCampaign);
console.log(`Email campaign scheduled with ID: ${scheduledResponse.id}`);

// Create a short link
const shortLink = await ccai.shortlink.create(
  "https://www.yourcompany.com/promo?utm_source=sms",
  "Summer Promo Link"
);

console.log(`Short URL: ${shortLink.url}`);
console.log(`Link ID: ${shortLink.id}`);

// Use in an SMS campaign
ccai.sms.send(
  accounts,
  `Hi \${firstName}, check out our summer deals: ${shortLink.url}`,
  "Summer Promo Campaign"
);

// Send a voice message
const response = await ccai.voice.send(
  accounts,
  "Hello, this is a reminder about your appointment tomorrow at 3 PM.",
  "Appointment Reminder"
);

console.log(`Voice campaign sent: ${response.campaignId}`);

// Get conversation history for a phone number
const conversations = await ccai.inbox.getConversation("+15551234567");

conversations.forEach(msg => {
  console.log(`[${msg.direction}] ${msg.timestamp}: ${msg.message}`);
});

// Get inbox messages
const inbox = await ccai.inbox.list();

inbox.forEach(thread => {
  console.log(`From: ${thread.from}, Last Message: ${thread.lastMessage}`);
});

const brand = await ccai.compliance.registerBrand({
  legalName: "Your Company LLC",
  taxId: "12-3456789",
  taxIdCountry: "US",
  website: "https://www.yourcompany.com",
  vertical: "TECHNOLOGY",
  entityType: "PRIVATE_PROFIT",
  address: {
    street: "123 Main St",
    city: "San Francisco",
    state: "CA",
    postalCode: "94105",
    country: "US"
  },
  contactEmail: "[email protected]",
  contactPhone: "+14155551234"
});

console.log(`Brand ID: ${brand.brandId}`);
console.log(`Brand Status: ${brand.status}`);

const campaign = await ccai.compliance.registerCampaign({
  brandId: brand.brandId,
  useCase: "MARKETING",
  description: "Promotional messages for opted-in customers",
  messageFlow: "Customers opt-in via web form and receive promotional SMS",
  sampleMessages: [
    "Hi ${firstName}, check out our latest deals at https://example.com",
    "Your order #12345 has shipped! Track it here: https://example.com/track"
  ],
  helpMessage: "Reply HELP for assistance. Contact [email protected]",
  optOutMessage: "You have been unsubscribed. Reply START to re-subscribe."
});

console.log(`Campaign ID: ${campaign.campaignId}`);
console.log(`Campaign Status: ${campaign.status}`);

// Check brand status
const brandStatus = await ccai.compliance.getBrandStatus(brand.brandId);
console.log(`Brand Status: ${brandStatus.status}`); // PENDING, APPROVED, REJECTED

// Check campaign status
const campaignStatus = await ccai.compliance.getCampaignStatus(campaign.campaignId);
console.log(`Campaign Status: ${campaignStatus.status}`); // PENDING, APPROVED, REJECTED

// Poll until approved
async function waitForApproval(brandId, intervalMs = 30000) {
  let status = 'PENDING';
  while (status === 'PENDING') {
    const result = await ccai.compliance.getBrandStatus(brandId);
    status = result.status;
    if (status === 'PENDING') {
      console.log('Still pending, checking again in 30s...');
      await new Promise(resolve => setTimeout(resolve, intervalMs));
    }
  }
  return status;
}

const webhookConfig = {
  url: "https://your-webhook-endpoint.com/webhook",
  events: ["MESSAGE_SENT", "MESSAGE_RECEIVED"],
  secret: "your-webhook-secret"
};

const registration = await ccai.webhook.register(webhookConfig);
console.log(`Webhook registered with ID: ${registration.id}`);

const webhooks = await ccai.webhook.list();
webhooks.forEach(wh => {
  console.log(`Webhook ID: ${wh.id}, URL: ${wh.url}`);
});

const updatedWebhook = await ccai.webhook.update(registration.id, {
  url: "https://your-updated-endpoint.com/webhook",
  events: ["MESSAGE_SENT"],
  secret: "your-updated-secret"
});

const deleteResponse = await ccai.webhook.delete(registration.id);
console.log(`Webhook deleted: ${deleteResponse.success}`);

{
  "message": "Hello John! We are testing the CCAI SMS functionality",
  "segments": 1,
  "smsSid": 141321,
  "messageStatus": "SENT",
  "totalPrice": 0.03,
  "to": "+15551234567"
}

{
  "campaign": {
    "id": 141293,
    "title": "Default Campaign",
    "message": "",
    "senderPhone": null,
    "createdAt": "2025-08-13T21:20:50.212623Z",
    "runAt": "null"
  },
  "from": "+15551234567",
  "to": "+14158735045",
  "message": "Reply text here"
}

import express from 'express';
import crypto from 'crypto';

const app = express();
app.use(express.json());

function verifyWebhookSignature(payload, signature, secret) {
  const expectedSignature = crypto
    .createHmac('sha256', secret)
    .update(JSON.stringify(payload))
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSignature)
  );
}

app.post('/webhook', (req, res) => {
  const signature = req.headers['x-ccai-signature'];
  const secret = process.env.WEBHOOK_SECRET;

  if (!verifyWebhookSignature(req.body, signature, secret)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  // Process the event
  const event = req.body;
  console.log('Received event:', event);

  if (event.messageStatus) {
    console.log(`Delivery receipt: ${event.messageStatus} for ${event.to}`);
  } else if (event.from && event.message) {
    console.log(`Inbound message from ${event.from}: ${event.message}`);
  }

  res.status(200).json({ received: true });
});

app.listen(3000, () => console.log('Webhook server running on port 3000'));

brew install ngrok

// webhook-server.js
import express from 'express';
import 'dotenv/config';

const app = express();
app.use(express.json());

app.post('/webhook', (req, res) => {
  console.log('Received webhook event!');
  console.log('Headers:', JSON.stringify(req.headers, null, 2));
  console.log('Body:', JSON.stringify(req.body, null, 2));
  res.status(200).json({ received: true });
});

app.listen(3000, () => {
  console.log('Webhook server listening on http://localhost:3000');
});

node webhook-server.js

ngrok http 3000

import { CCAI } from 'ccai-node';
import 'dotenv/config';

const ccai = new CCAI({
  clientId: process.env.CCAI_CLIENT_ID,
  apiKey: process.env.CCAI_API_KEY
});

await ccai.sms.sendSingle(
  "John",
  "Doe",
  "+15551234567",
  "Hello ${firstName}! Testing webhooks.",
  "Webhook Test"
);

try {
  const response = await ccai.sms.sendSingle(
    "John", "Doe", "+15551234567",
    "Test message", "Test"
  );
} catch (error) {
  console.error(`Error Code: ${error.code}`);
  console.error(`Message: ${error.message}`);
  console.error(`Status: ${error.status}`);
  console.error(`Details: ${JSON.stringify(error.details)}`);
}

async function sendWithRetry(fn, maxRetries = 3) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (attempt === maxRetries || error.code === 40101) {
        throw error;
      }
      const delay = Math.pow(2, attempt) * 1000;
      console.log(`Attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
      await new Promise(resolve => setTimeout(resolve, delay));
    }
  }
}

// Usage
const response = await sendWithRetry(() =>
  ccai.sms.sendSingle("John", "Doe", "+15551234567", "Hello!", "Test")
);

{
  timeout: 60,          // Request timeout in seconds
  retries: 3,           // Number of retry attempts
  onProgress: (status) => {}  // Progress callback function
}

{
  onProgress: (status) => {}  // Progress callback function
}