FuturifyAutopilot Documentation

Introduction

FuturifyAutopilot is a comprehensive WhatsApp automation platform that enables businesses to manage multiple WhatsApp numbers, send bulk messages, create AI-powered chatbots with multi-auto response capabilities, and track customer interactions—all from one powerful dashboard.

What Makes FuturifyAutopilot Different?

• Multi-Session Management: Connect unlimited WhatsApp numbers from one dashboard
• AI-Powered Chatbots: Advanced multi-auto response system with GPT-4, Gemini, and DeepSeek integration
• Smart Auto-Reply: Keyword-based and context-aware automated responses
• Bulk Campaigns: Send 10,000+ messages with variables and media
• Courier Integration: Auto-track deliveries from TCS, Leopards, PostEx
• REST API: Full programmatic access to all features
• Number Verification: Check if numbers exist on WhatsApp before sending

Quick Start

Get started with FuturifyAutopilot in just a few minutes:

Step 1: Create Your Account

1. Visit FuturifyAutopilot Registration
2. Enter your email and create a password
3. Verify your email address
4. Choose your plan (start with Free forever plan)

Step 2: Connect Your WhatsApp

1. Go to Dashboard → Sessions
2. Click "Add New Session"
3. Enter a session name and click "Create"
4. Scan the QR code with WhatsApp on your phone
5. Wait for connection confirmation

// Connection happens automatically via QR code
// Once connected, you'll receive a webhook notification
{
  "event": "session.connected",
  "sessionId": "your-session-id",
  "phoneNumber": "923001234567",
  "timestamp": "2026-01-27T10:30:00Z"
}

Step 3: Send Your First Message

const axios = require('axios');

const sendMessage = async () => {
  try {
    const response = await axios.post('https://your-domain.com/api/send-message', {
      sessionId: 'your-session-id',
      phoneNumber: '923001234567',
      message: 'Hello from FuturifyAutopilot! 🚀'
    }, {
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY'
      }
    });
    
    console.log('Message sent:', response.data);
  } catch (error) {
    console.error('Error:', error.response.data);
  }
};

sendMessage();

Core Features

Multi-Session Management

The multi-session feature allows you to connect and manage multiple WhatsApp numbers from a single dashboard. Each session operates independently with its own contacts, messages, and settings.

Session States

• Pending: Session created, waiting for QR code scan
• Connected: Active and ready to send/receive messages
• Disconnected: Temporarily offline, can be reconnected
• Failed: Connection error, requires manual intervention

Best Practices

AI Chatbot with Multi-Auto Response

Our AI chatbot feature uses advanced language models to create intelligent conversational experiences. The unique Multi-Auto Response system allows the chatbot to maintain multiple conversation contexts and respond appropriately based on user intent.

Supported AI Models

• OpenAI GPT-4: Most advanced reasoning and context understanding
• Google Gemini: Excellent for multimodal interactions
• DeepSeek: Fast and cost-effective alternative

Multi-Auto Response Feature

This groundbreaking feature allows your chatbot to:

• Maintain separate conversation threads for different topics
• Switch between contexts automatically based on user input
• Provide personalized responses using customer data
• Handle complex multi-step workflows
• Learn from previous interactions

const createChatbot = async () => {
  const response = await axios.post('/api/chatbot/create', {
    name: 'Customer Support Bot',
    welcomeMessage: 'Hi! How can I help you today?',
    aiModel: 'gpt-4',
    systemPrompt: 'You are a helpful customer support agent...',
    features: {
      multiAutoResponse: true,
      contextAware: true,
      learningEnabled: true
    }
  }, {
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
  });
};

API Authentication

All API requests require authentication using an API key. You can find your API key in your dashboard under Settings → API Management.

Adding Authentication Header

// Using axios
axios.defaults.headers.common['Authorization'] = 'Bearer YOUR_API_KEY';

// Using fetch
fetch('https://your-domain.com/api/endpoint', {
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  }
});

Sessions API

Get All Sessions

Retrieve all WhatsApp sessions for your account.

Create New Session

Create a new WhatsApp session.

Request Body

const response = await axios.post('/api/sessions/create', {
  sessionName: 'my-business-number'
}, {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
});

Messaging API

Send Text Message

Request Body

const sendMessage = async () => {
  const response = await axios.post('/api/send-message', {
    sessionId: 'abc123',
    phoneNumber: '923001234567',
    message: 'Hello! Your order #12345 has been shipped.'
  }, {
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
  });
  
  console.log(response.data);
  // { success: true, messageId: 'msg_xyz789' }
};

Send Media Message

const formData = new FormData();
formData.append('sessionId', 'abc123');
formData.append('phoneNumber', '923001234567');
formData.append('caption', 'Check out our new product!');
formData.append('media', fileInput.files[0]);

const response = await axios.post('/api/send-media', formData, {
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'multipart/form-data'
  }
});

Code Examples

Node.js Complete Example

const axios = require('axios');

const API_KEY = 'your-api-key-here';
const BASE_URL = 'https://your-domain.com/api';

const api = axios.create({
  baseURL: BASE_URL,
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json'
  }
});

// 1. Create a new session
async function createSession() {
  const response = await api.post('/sessions/create', {
    sessionName: 'my-whatsapp-business'
  });
  return response.data.sessionId;
}

// 2. Send a message
async function sendMessage(sessionId, phone, message) {
  const response = await api.post('/send-message', {
    sessionId,
    phoneNumber: phone,
    message
  });
  return response.data;
}

// 3. Check number validity
async function checkNumber(phone) {
  const response = await api.post('/number-checker/check', {
    numbers: [phone]
  });
  return response.data;
}

// Main function
async function main() {
  try {
    // Create session
    const sessionId = await createSession();
    console.log('Session created:', sessionId);
    
    // Check if number exists
    const numberCheck = await checkNumber('923001234567');
    console.log('Number check:', numberCheck);
    
    // Send message
    if (numberCheck.results[0].exists) {
      const result = await sendMessage(
        sessionId,
        '923001234567',
        'Hello from FuturifyAutopilot!'
      );
      console.log('Message sent:', result);
    }
  } catch (error) {
    console.error('Error:', error.response?.data || error.message);
  }
}

main();

Python Example

import requests

API_KEY = 'your-api-key-here'
BASE_URL = 'https://your-domain.com/api'

headers = {
    'Authorization': f'Bearer {API_KEY}',
    'Content-Type': 'application/json'
}

def send_message(session_id, phone_number, message):
    url = f'{BASE_URL}/send-message'
    payload = {
        'sessionId': session_id,
        'phoneNumber': phone_number,
        'message': message
    }
    
    response = requests.post(url, json=payload, headers=headers)
    return response.json()

# Send a message
result = send_message('abc123', '923001234567', 'Hello from Python!')
print(result)

Best Practices

WhatsApp Compliance

• Always obtain consent before sending marketing messages
• Respect opt-out requests immediately
• Don't send spam or unsolicited messages
• Use appropriate message templates
• Maintain high-quality content
• Follow rate limits (avoid sending too many messages quickly)

API Usage

• Implement proper error handling
• Use retry logic with exponential backoff
• Cache responses when appropriate
• Monitor API rate limits
• Validate phone numbers before sending
• Log all API interactions for debugging

Security

• Never expose API keys in client-side code
• Use environment variables for sensitive data
• Rotate API keys periodically
• Implement IP whitelisting when possible
• Monitor for unusual activity