API WhatsApp pour développeurs — Construisez, livrez, évoluez

Une API WhatsApp pensée pour les développeurs avec des points de terminaison REST épurés, des webhooks, des exemples de code en six langages et une infrastructure qui évolue avec votre projet.

const response = await fetch('https://api2whats.com/send-text', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    to: '971501234567',
    message: 'Hello from my app!'
  })
});
const data = await response.json();
console.log(data.id); // message ID

Pourquoi les développeurs choisissent cette API

La plupart des solutions d'API WhatsApp sont conçues d'abord pour les utilisateurs non techniques et ensuite pour les développeurs. La documentation est maigre, les messages d'erreur inutiles, et vous passez plus de temps à combattre l'API qu'à développer avec. Nous avons construit cette API dans l'autre sens — les développeurs d'abord, tout le reste ensuite.

Chaque point de terminaison renvoie du JSON structuré avec des codes d'erreur clairs. Chaque requête a un format de réponse prévisible. La documentation inclut des exemples de code fonctionnels que vous pouvez copier et exécuter immédiatement. Et le système de webhook délivre les messages entrants à votre serveur en temps réel avec des charges utiles signées pour que vous puissiez vérifier leur authenticité.

Que vous développiez un chatbot de support client, un système de notification de commandes, un outil d'automatisation marketing ou une intégration personnalisée pour un client, l'API s'efface et vous laisse vous concentrer sur votre code.

Vue d'ensemble de l'architecture

L'API se situe entre votre application et les serveurs WhatsApp. Voici ce qui se passe lorsque vous envoyez un message :

1. Votre application envoie une requête HTTP POST au point de terminaison API
2. L'API authentifie votre requête à l'aide de la clé API dans l'en-tête Authorization
3. Le message est acheminé vers la bonne instance WhatsApp (si vous en avez plusieurs)
4. Le message est délivré via une connexion WebSocket persistante vers WhatsApp
5. Vous recevez une réponse avec l'identifiant du message et le statut de livraison
6. Les mises à jour de statut ultérieures (livré, lu) sont poussées vers votre webhook

L'aller-retour complet prend généralement moins de 50 millisecondes. Aucun navigateur impliqué, aucun traitement de capture d'écran, aucune manipulation DOM. La connexion WebSocket est persistante et gère automatiquement la reconnexion, le renouvellement de l'authentification et la récupération d'erreurs.

Référence de l'API REST

Tous les points de terminaison suivent les conventions REST. Les requêtes utilisent des corps JSON. Les réponses sont en JSON. L'authentification se fait via des jetons Bearer dans l'en-tête Authorization.

Envoi de messages

Gestion des instances

Webhooks

Intégration des webhooks

Les webhooks sont le moyen de recevoir les messages entrants. Lorsque quelqu'un envoie un message à votre numéro WhatsApp connecté, l'API envoie une requête POST à votre URL de webhook avec les données du message.

Une charge utile de webhook ressemble à ceci :

{
  "event": "message",
  "instance": "instance_abc123",
  "data": {
    "id": "3EB0A1B2C3D4E5F6",
    "from": "971501234567",
    "message": "Hi, I need help with my order",
    "timestamp": 1691234567,
    "type": "text"
  }
}

Votre gestionnaire de webhook traite ces données et peut déclencher toute réponse automatisée. Le système de webhook prend en charge la logique de nouvelle tentative — si votre serveur est temporairement indisponible, l'API réessaie la livraison plusieurs fois avant d'abandonner.

Pour la sécurité, toutes les charges utiles de webhook incluent un en-tête X-Signature que vous pouvez vérifier pour vous assurer que la requête provient bien de notre API et non d'un tiers.

Exemples de code en six langages

Nous fournissons des exemples de code fonctionnels pour chaque opération courante. Chaque exemple est un script complet et exécutable — pas un extrait qui vous laisse deviner les imports, la gestion d'erreurs ou la configuration.

PHP

<?php
$ch = curl_init('https://api2whats.com/send-text');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ***',
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode([
        'to' => '971501234567',
        'message' => 'Hello from PHP!',
    ]),
    CURLOPT_RETURNTRANSFER => true,
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

Python

import requests

response = requests.post(
    'https://api2whats.com/send-text',
    headers={
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json',
    },
    json={
        'to': '971501234567',
        'message': 'Hello from Python!',
    }
)
print(response.json())

JavaScript (Node.js)

const response = await fetch('https://api2whats.com/send-text', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json',
    },
    body: JSON.stringify({
        to: '971501234567',
        message: 'Hello from Node.js!',
    }),
});
const data = await response.json();
console.log(data);

Gestion des erreurs

L'API utilise les codes de statut HTTP standards et renvoie des réponses d'erreur structurées :

{
    "success": false,
    "error": {
        "code": "INSTANCE_DISCONNECTED",
        "message": "The WhatsApp instance is not connected"
    }
}

Les codes d'erreur courants incluent :

• 401 Unauthorized — Clé API invalide ou manquante
• 400 Bad Request — Champs requis manquants ou données invalides
• 404 Not Found — L'instance ou la ressource n'existe pas
• 429 Too Many Requests — Limite de débit dépassée
• 500 Internal Server Error — Un problème est survenu de notre côté (rare)

Sécurité des webhooks

Chaque requête de webhook inclut un en-tête X-Signature contenant une signature HMAC-SHA256 du corps de la requête. Votre gestionnaire de webhook devrait vérifier cette signature pour s'assurer que la requête provient bien de notre API et non d'un tiers.

// Node.js webhook signature verification
const crypto = require('crypto');

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

app.post('/webhook', (req, res) => {
    const sig = req.headers['x-signature'];
    const body = JSON.stringify(req.body);

    if (!verifySignature(body, sig, WEBHOOK_SECRET)) {
        return res.status(401).json({ error: 'Invalid signature' });
    }

    // Process the message...
    res.json({ success: true });
});

Tests et débogage

L'API fournit plusieurs outils pour tester et déboguer votre intégration :

• Journaux du tableau de bord — Consultez toutes les requêtes API et leurs réponses en temps réel depuis votre tableau de bord
• Point de terminaison de test de webhook — Envoyez un webhook de test pour vérifier que votre gestionnaire fonctionne correctement
• Suivi du statut des messages — Interrogez le statut de n'importe quel message par son identifiant
• Surveillance du taux d'erreur — Suivez l'évolution de votre taux d'erreur API dans le tableau de bord

Nous recommandons de commencer avec une instance de test connectée à votre numéro personnel. Envoyez des messages de test, vérifiez les webhooks et contrôlez la gestion des erreurs avant de passer au trafic de production.

Bonnes pratiques pour les développeurs

• Stockez les clés API de manière sécurisée — Utilisez des variables d'environnement, pas des chaînes codées en dur. Ne commitez jamais les clés API dans le contrôle de version.
• Gérez les erreurs avec élégance — Implémentez une logique de nouvelle tentative avec backoff exponentiel pour les erreurs transitoires (5xx, dépassements de délai réseau).
• Validez les signatures de webhook — Ne faites jamais confiance aux requêtes de webhook non vérifiées. Vérifiez toujours l'en-tête X-Signature.
• Utilisez le pool de connexions — Réutilisez les connexions HTTP entre les requêtes au lieu d'en créer de nouvelles pour chaque appel API.
• Surveillez les limites de débit — Consultez l'en-tête X-RateLimit-Remaining et mettez en place un throttling proactif à l'approche des limites.
• Journalisez tout — Enregistrez les paires requête/réponse pour le débogage. Masquez les données sensibles (numéros de téléphone, contenu des messages) dans les journaux de production.

Limites de débit

Les limites de débit sont appliquées par clé API et varient selon le forfait. L'API renvoie un code 429 avec un en-tête Retry-After lorsque vous atteignez la limite. Voici les valeurs par défaut :

• Forfait Basic — 100 requêtes par minute
• Forfait Professional — 300 requêtes par minute
• Forfait Enterprise — 1 000 requêtes par minute

Si vous atteignez régulièrement les limites de débit, envisagez de passer à un forfait supérieur ou de regrouper les requêtes lorsque c'est possible.

Formats de charge utile des webhooks

Les messages entrants arrivent dans des formats différents selon le type de message :

Message texte

{
  "event": "message",
  "data": {
    "id": "3EB0A1B2C3D4E5F6",
    "from": "971501234567",
    "message": "Hello!",
    "type": "text",
    "timestamp": 1691234567
  }
}

Message image

{
  "event": "message",
  "data": {
    "id": "3EB0A1B2C3D4E5F7",
    "from": "971501234567",
    "type": "image",
    "caption": "Check this out!",
    "mediaUrl": "https://api2whats.com/media/...",
    "mimeType": "image/jpeg",
    "timestamp": 1691234568
  }
}

Mise à jour de statut

{
  "event": "status",
  "data": {
    "id": "3EB0A1B2C3D4E5F6",
    "status": "delivered",
    "timestamp": 1691234600
  }
}

Les valeurs de statut incluent : sent (remis à WhatsApp), delivered (parvu sur l'appareil) et read (lu par le destinataire).

Premiers pas

1. Créez un compte (gratuit, sans carte bancaire)
2. Choisissez un forfait sur la page des tarifs
3. Créez une instance depuis votre tableau de bord
4. Connectez votre numéro de téléphone via code QR ou code de jumelage
5. Lisez la documentation API complète
6. Envoyez votre premier message et commencez à développer

Communauté et support

Rejoignez notre communauté de développeurs pour obtenir de l'aide, partager des intégrations et rester informé des nouvelles fonctionnalités. Nous avons une communauté active de développeurs qui créent des intégrations WhatsApp dans tous les secteurs.

• Documentation — Référence API complète avec des exemples fonctionnels
• Exemples de code — Scripts complets et exécutables en PHP, Python, JavaScript et cURL
• Support par e-mail — Réponse sous 24 heures pour tous les forfaits
• Journaux du tableau de bord — Visibilité en temps réel sur les requêtes API et les livraisons de webhooks
• Page de statut — État du système en direct et historique des incidents

Que vous réalisiez votre première intégration WhatsApp ou que vous fassiez évoluer une intégration existante, nos ressources et notre équipe support sont là pour vous aider à réussir.