Faites des campagnes SMS avec Twilio

Introduction

Pas besoin de rentrer dans les détails, l'automatisation d'envoi des SMS c'est génial quand t'es commercial (même si c'est aussi utilisé dans le phishing) ou auto-entrepreneur pour envoyer tes prestations à une masse de personne, on va voir comment faire ça avec Twilio ici.

Qu'est-ce que Twilio ?

Twilio est une plateforme cloud qui permet d'intégrer facilement des fonctionnalités de communication dans tes applications. SMS, appels vocaux, messagerie instantanée... tout y passe. Pour nous, on va se concentrer sur l'API SMS qui est simple et efficace.

Prérequis

Avant de commencer, assure-toi d'avoir :

• Un compte Twilio (gratuit pour débuter)
• Python 3.6+ installé
• Une carte de crédit pour valider ton compte (même en version gratuite)
• Un numéro de téléphone vérifié

Configuration du compte Twilio

Étape 1 : Créer ton compte

Rends-toi sur twilio.com et crée ton compte. Après vérification, tu auras accès à :

• Un Account SID (identifiant unique)
• Un Auth Token (clé d'authentification)
• 15$ de crédit gratuit pour tester

Tout se trouve dans la section API keys de Twilio

Étape 2 : Obtenir un numéro Twilio

Dans la console Twilio, va dans "Phone Numbers" et achète un numéro. Ça coûte environ 1-6$ par mois. Ce numéro sera l'expéditeur de tes SMS.

Étape 3 : Installer les bibliothèques

Pour Python :

bash
pip install twilio

Pour Node.js :

bash
npm install twilio

Envoi d'un SMS simple

Version Python

python
from twilio.rest import Client

# Tes identifiants Twilio
account_sid = 'ton_account_sid'
auth_token = 'ton_auth_token'
twilio_number = '+33123456789'  # Ton numéro Twilio

# Initialiser le client
client = Client(account_sid, auth_token)

# Envoyer un SMS
message = client.messages.create(
    body="Salut ! Voici ton message automatisé 📱",
    from_=twilio_number,
    to='+33612345678'  # Numéro du destinataire
)

print(f"Message envoyé ! SID: {message.sid}")

Version Node.js

javascript
const twilio = require('twilio');

// Tes identifiants Twilio
const accountSid = 'ton_account_sid';
const authToken = 'ton_auth_token';
const twilioNumber = '+33123456789';  // Ton numéro Twilio

// Initialiser le client
const client = twilio(accountSid, authToken);

// Envoyer un SMS
client.messages
    .create({
        body: 'Salut ! Voici ton message automatisé 📱',
        from: twilioNumber,
        to: '+33612345678'  // Numéro du destinataire
    })
    .then(message => console.log(`Message envoyé ! SID: ${message.sid}`))
    .catch(error => console.error('Erreur:', error));

Automatisation pour l'envoi en masse

Gestion d'une liste de contacts

Version Python

python
import csv
import time
from twilio.rest import Client

# Configuration
account_sid = 'ton_account_sid'
auth_token = 'ton_auth_token'
twilio_number = '+33123456789'

client = Client(account_sid, auth_token)

# Lire les contacts depuis un fichier CSV
def lire_contacts(fichier_csv):
    contacts = []
    with open(fichier_csv, 'r', encoding='utf-8') as file:
        reader = csv.DictReader(file)
        for row in reader:
            contacts.append({
                'nom': row['nom'],
                'telephone': row['telephone'],
                'prenom': row['prenom']
            })
    return contacts

# Personnaliser le message
def creer_message(nom, prenom, service="mes services"):
    return f"Bonjour {prenom} {nom} ! Je vous propose {service}. Contactez-moi pour plus d'infos. Cordialement."

# Envoyer à tous les contacts
def envoyer_sms_masse(contacts, delai=2):
    for contact in contacts:
        try:
            message_personnalise = creer_message(
                contact['nom'], 
                contact['prenom'], 
                "une consultation gratuite"
            )
            
            message = client.messages.create(
                body=message_personnalise,
                from_=twilio_number,
                to=contact['telephone']
            )
            
            print(f"✅ SMS envoyé à {contact['prenom']} {contact['nom']}")
            time.sleep(delai)  # Pause entre les envois
            
        except Exception as e:
            print(f"❌ Erreur pour {contact['nom']}: {e}")

# Utilisation
contacts = lire_contacts('mes_contacts.csv')
envoyer_sms_masse(contacts)

Version Node.js

javascript
const twilio = require('twilio');
const fs = require('fs');
const csv = require('csv-parser');

// Configuration
const accountSid = 'ton_account_sid';
const authToken = 'ton_auth_token';
const twilioNumber = '+33123456789';

const client = twilio(accountSid, authToken);

// Lire les contacts depuis un fichier CSV
function lireContacts(fichierCsv) {
    return new Promise((resolve, reject) => {
        const contacts = [];
        fs.createReadStream(fichierCsv)
            .pipe(csv())
            .on('data', (row) => {
                contacts.push({
                    nom: row.nom,
                    telephone: row.telephone,
                    prenom: row.prenom
                });
            })
            .on('end', () => resolve(contacts))
            .on('error', reject);
    });
}

// Personnaliser le message
function creerMessage(nom, prenom, service = "mes services") {
    return `Bonjour ${prenom} ${nom} ! Je vous propose ${service}. Contactez-moi pour plus d'infos. Cordialement.`;
}

// Envoyer à tous les contacts
async function envoyerSmsmasse(contacts, delai = 2000) {
    for (const contact of contacts) {
        try {
            const messagePersonnalise = creerMessage(
                contact.nom,
                contact.prenom,
                "une consultation gratuite"
            );
            
            const message = await client.messages.create({
                body: messagePersonnalise,
                from: twilioNumber,
                to: contact.telephone
            });
            
            console.log(`✅ SMS envoyé à ${contact.prenom} ${contact.nom}`);
            await new Promise(resolve => setTimeout(resolve, delai));
            
        } catch (error) {
            console.error(`❌ Erreur pour ${contact.nom}:`, error);
        }
    }
}

// Utilisation
(async () => {
    try {
        const contacts = await lireContacts('mes_contacts.csv');
        await envoyerSmsmasse(contacts);
    } catch (error) {
        console.error('Erreur:', error);
    }
})();

Installation des dépendances Node.js :

bash
npm install csv-parser

Fonctionnalités avancées

Programmation d'envois

Version Python

python
import schedule
import time
from datetime import datetime

def envoyer_rappel_quotidien():
    # Ton code d'envoi SMS ici
    print(f"Rappel envoyé à {datetime.now()}")

# Programmer l'envoi tous les jours à 9h
schedule.every().day.at("09:00").do(envoyer_rappel_quotidien)

# Boucle d'exécution
while True:
    schedule.run_pending()
    time.sleep(60)

Installation :

bash
pip install schedule

Version Node.js

javascript
const cron = require('node-cron');

function envoyerRappelQuotidien() {
    // Ton code d'envoi SMS ici
    console.log(`Rappel envoyé à ${new Date()}`);
}

// Programmer l'envoi tous les jours à 9h
cron.schedule('0 9 * * *', envoyerRappelQuotidien);

console.log('Planificateur SMS démarré...');

Installation :

bash
npm install node-cron

Gestion des erreurs et limitations

Version Python

python
def envoyer_sms_securise(numero, message):
    try:
        # Vérifier le format du numéro
        if not numero.startswith('+'):
            numero = '+33' + numero.lstrip('0')
        
        # Limiter la taille du message
        if len(message) > 160:
            message = message[:157] + "..."
        
        # Envoyer le SMS
        result = client.messages.create(
            body=message,
            from_=twilio_number,
            to=numero
        )
        
        return True, result.sid
        
    except Exception as e:
        print(f"Erreur d'envoi: {e}")
        return False, str(e)

Version Node.js

javascript
async function envoyerSmsSecurise(numero, message) {
    try {
        // Vérifier le format du numéro
        if (!numero.startsWith('+')) {
            numero = '+33' + numero.replace(/^0+/, '');
        }
        
        // Limiter la taille du message
        if (message.length > 160) {
            message = message.substring(0, 157) + "...";
        }
        
        // Envoyer le SMS
        const result = await client.messages.create({
            body: message,
            from: twilioNumber,
            to: numero
        });
        
        return { success: true, sid: result.sid };
        
    } catch (error) {
        console.error('Erreur d\'envoi:', error);
        return { success: false, error: error.message };
    }
}

Optimisation des coûts

• Un SMS coûte environ 0,075€ de France à France, si c'est de USA à France ca fait 0.2€ c'est pas la même.
• Utilise des messages courts (160 caractères max)
• Groupe tes envois pour éviter les pics de trafic
• Surveille ton crédit Twilio régulièrement

Sécurité

Version Python

python
import os
from dotenv import load_dotenv

# Utiliser des variables d'environnement
load_dotenv()

account_sid = os.getenv('TWILIO_ACCOUNT_SID')
auth_token = os.getenv('TWILIO_AUTH_TOKEN')
twilio_number = os.getenv('TWILIO_PHONE_NUMBER')

Installation :

bash
pip install python-dotenv

Version Node.js

javascript
require('dotenv').config();

// Utiliser des variables d'environnement
const accountSid = process.env.TWILIO_ACCOUNT_SID;
const authToken = process.env.TWILIO_AUTH_TOKEN;
const twilioNumber = process.env.TWILIO_PHONE_NUMBER;

Installation :

bash
npm install dotenv

Fichier .env (pour les deux versions) :

TWILIO_ACCOUNT_SID=ton_account_sid
TWILIO_AUTH_TOKEN=ton_auth_token
TWILIO_PHONE_NUMBER=+33123456789

Exemples d'utilisation business

Pour un auto-entrepreneur

Version Python

python
def envoyer_devis_rappel(clients_en_attente):
    message_template = """
    Bonjour {nom} !
    
    Votre devis expire dans 48h.
    Confirmez rapidement : {lien_devis}
    
    Cordialement,
    {signature}
    """
    
    for client in clients_en_attente:
        message = message_template.format(
            nom=client['nom'],
            lien_devis=client['lien_devis'],
            signature="John Doe"
        )
        
        envoyer_sms_securise(client['telephone'], message)

Version Node.js

javascript
function envoyerDevisRappel(clientsEnAttente) {
    const messageTemplate = `
    Bonjour {nom} !
    
    Votre devis expire dans 48h.
    Confirmez rapidement : {lien_devis}
    
    Cordialement,
    {signature}
    `;
    
    clientsEnAttente.forEach(async (client) => {
        const message = messageTemplate
            .replace('{nom}', client.nom)
            .replace('{lien_devis}', client.lienDevis)
            .replace('{signature}', 'John Doe');
        
        await envoyerSmsSecurise(client.telephone, message);
    });
}

Pour une campagne commerciale

Version Python

python
def campagne_promotion(prospects, offre_speciale):
    message = f"""
    🎉 Offre spéciale {offre_speciale['nom']} !
    
    Réduction de {offre_speciale['pourcentage']}% 
    jusqu'au {offre_speciale['date_fin']}
    
    Code: {offre_speciale['code']}
    
    STOP pour se désabonner
    """
    
    for prospect in prospects:
        envoyer_sms_securise(prospect['telephone'], message)

Version Node.js

javascript
function campagnePromotion(prospects, offreSpeciale) {
    const message = `
    🎉 Offre spéciale ${offreSpeciale.nom} !
    
    Réduction de ${offreSpeciale.pourcentage}% 
    jusqu'au ${offreSpeciale.dateFin}
    
    Code: ${offreSpeciale.code}
    
    STOP pour se désabonner
    `;
    
    prospects.forEach(async (prospect) => {
        await envoyerSmsSecurise(prospect.telephone, message);
    });
}

Surveillance et analytics

Suivi des envois

Version Python

python
from datetime import datetime, timedelta

def analyser_campagne(date_debut, date_fin):
    messages = client.messages.list(
        date_sent_after=date_debut,
        date_sent_before=date_fin
    )
    
    stats = {
        'total_envoyes': len(messages),
        'livres': sum(1 for m in messages if m.status == 'delivered'),
        'echecs': sum(1 for m in messages if m.status == 'failed'),
        'cout_total': sum(float(m.price or 0) for m in messages)
    }
    
    return stats

# Utilisation
hier = datetime.now() - timedelta(days=1)
aujourdhui = datetime.now()
stats = analyser_campagne(hier, aujourdhui)
print(f"Statistiques: {stats}")

Version Node.js

javascript
async function analyserCampagne(dateDebut, dateFin) {
    try {
        const messages = await client.messages.list({
            dateSentAfter: dateDebut,
            dateSentBefore: dateFin
        });
        
        const stats = {
            totalEnvoyes: messages.length,
            livres: messages.filter(m => m.status === 'delivered').length,
            echecs: messages.filter(m => m.status === 'failed').length,
            coutTotal: messages.reduce((sum, m) => sum + (parseFloat(m.price) || 0), 0)
        };
        
        return stats;
        
    } catch (error) {
        console.error('Erreur analyse:', error);
        return null;
    }
}

// Utilisation
(async () => {
    const hier = new Date(Date.now() - 24 * 60 * 60 * 1000);
    const aujourdhui = new Date();
    const stats = await analyserCampagne(hier, aujourdhui);
    console.log('Statistiques:', stats);
})();

Alternatives et comparaisons

Twilio vs autres services

• Twilio : Flexible, documentation excellente, prix moyen
• AWS SNS : Intégré AWS, moins cher en volume
• MessageBird : Interface plus simple, support européen
• Nexmo/Vonage : Bonnes performances internationales

Dépannage courant

Problèmes fréquents

• Numéro non vérifié : Vérifier dans la console Twilio
• Message trop long : Limiter à 160 caractères
• Erreur d'authentification : Vérifier SID et token
• Numéro invalide : Respecter le format international (+33...)

Conclusion

L'automatisation SMS avec Twilio est un outil puissant pour automatiser ta communication client. Que tu sois commercial, auto-entrepreneur ou développeur, cette solution s'adapte à tes besoins avec une API simple et des performances fiables.

Remember : utilise ces outils de manière éthique et respecte toujours la vie privée de tes contacts. L'automatisation c'est cool, mais le respect c'est mieux !

Avec quelques lignes de code, tu peux maintenant envoyer des SMS personnalisés à des centaines de contacts. À toi de jouer ! 🚀