WhatsApp API für Entwickler — Bauen, Ausliefern, Skalieren

Eine entwicklerorientierte WhatsApp API mit sauberen REST-Endpunkten, Webhooks, Codebeispielen in sechs Sprachen und einer Infrastruktur, die mit Ihrem Projekt skaliert.

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

Warum Entwickler diese API wählen

Die meisten WhatsApp-API-Lösungen werden zuerst für nicht-technische Nutzer entworfen und erst in zweiter Linie für Entwickler. Die Dokumentation ist dünn, die Fehlermeldungen wenig hilfreich, und Sie verbringen mehr Zeit damit, gegen die API zu kämpfen, als mit ihr zu bauen. Wir haben diese API umgekehrt konzipiert — Entwickler zuerst, alles andere danach.

Jeder Endpunkt gibt strukturiertes JSON mit klaren Fehlercodes zurück. Jede Anfrage hat ein vorhersagbares Antwortformat. Die Dokumentation enthält funktionierende Codebeispiele, die Sie sofort kopieren und ausführen können. Und das Webhook-System liefert eingehende Nachrichten in Echtzeit mit signierten Payloads an Ihren Server, sodass Sie die Echtheit verifizieren können.

Ob Sie einen Kundensupport-Chatbot, ein Bestellbenachrichtigungssystem, ein Marketing-Automatisierungstool oder eine kundenspezifische Integration bauen — die API stellt sich nicht in den Weg und lässt Sie sich auf Ihren Code konzentrieren.

Architekturübersicht

Die API sitzt zwischen Ihrer Anwendung und den WhatsApp-Servern. Das passiert, wenn Sie eine Nachricht senden:

1. Ihre Anwendung sendet eine HTTP-POST-Anfrage an den API-Endpunkt
2. Die API authentifiziert Ihre Anfrage über den API-Schlüssel im Authorization-Header
3. Die Nachricht wird an die richtige WhatsApp-Instanz weitergeleitet (falls Sie mehrere haben)
4. Die Nachricht wird über eine dauerhafte WebSocket-Verbindung an WhatsApp übermittelt
5. Sie erhalten eine Antwort mit der Nachrichten-ID und dem Zustellstatus
6. Weitere Statusaktualisierungen (zugestellt, gelesen) werden an Ihren Webhook übermittelt

Der gesamte Round-Trip dauert typischerweise weniger als 50 Millisekunden. Kein Browser, keine Screenshot-Verarbeitung, keine DOM-Manipulation. Die WebSocket-Verbindung ist dauerhaft und übernimmt Wiederverbindung, Authentifizierungs-Aktualisierung und Fehlerbehebung automatisch.

REST-API-Referenz

Alle Endpunkte folgen REST-Konventionen. Anfragen verwenden JSON-Bodies, Antworten JSON. Die Authentifizierung erfolgt über Bearer-Tokens im Authorization-Header.

Nachrichten senden

Instanzen verwalten

Webhooks

Webhook-Integration

Über Webhooks empfangen Sie eingehende Nachrichten. Sendet jemand eine Nachricht an Ihre verbundene WhatsApp-Nummer, richtet die API eine POST-Anfrage mit den Nachrichtendaten an Ihre Webhook-URL.

Ein Webhook-Payload sieht so aus:

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

Ihr Webhook-Handler verarbeitet diese Daten und kann jede automatisierte Antwort auslösen. Das Webhook-System unterstützt Retry-Logik — ist Ihr Server vorübergehend nicht erreichbar, wiederholt die API die Zustellung mehrfach, bevor sie aufgibt.

Zur Sicherheit enthält jeder Webhook-Payload einen X-Signature-Header, den Sie verifizieren können, um sicherzustellen, dass die Anfrage tatsächlich von unserer API und nicht von Dritten stammt.

Codebeispiele in sechs Sprachen

Wir bieten funktionierende Codebeispiele für jeden gängigen Vorgang. Jedes Beispiel ist ein vollständiges, lauffähiges Skript — kein Schnipsel, bei dem Sie über Imports, Fehlerbehandlung oder Konfiguration rätseln.

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);

Fehlerbehandlung

Die API nutzt Standard-HTTP-Statuscodes und gibt strukturierte Fehlerantworten zurück:

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

Häufige Fehlercodes sind:

• 401 Unauthorized — Ungültiger oder fehlender API-Schlüssel
• 400 Bad Request — Fehlende Pflichtfelder oder ungültige Daten
• 404 Not Found — Instanz oder Ressource existiert nicht
• 429 Too Many Requests — Rate-Limit überschritten
• 500 Internal Server Error — Auf unserer Seite ist etwas schiefgegangen (selten)

Webhook-Sicherheit

Jede Webhook-Anfrage enthält einen X-Signature-Header mit einer HMAC-SHA256-Signatur des Anfrage-Bodys. Ihr Webhook-Handler sollte diese Signatur verifizieren, um sicherzustellen, dass die Anfrage tatsächlich von unserer API und nicht von Dritten stammt.

// 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 });
});

Testen und Debuggen

Die API bietet mehrere Werkzeuge zum Testen und Debuggen Ihrer Integration:

• Dashboard-Logs — Alle API-Anfragen und ihre Antworten in Echtzeit in Ihrem Dashboard einsehen
• Webhook-Test-Endpunkt — Einen Test-Webhook senden, um zu prüfen, ob Ihr Handler korrekt funktioniert
• Nachrichtenstatus-Verfolgung — Den Status jeder Nachricht anhand ihrer ID abfragen
• Fehlerraten-Überwachung — Ihre API-Fehlerraten im Dashboard über die Zeit verfolgen

Wir empfehlen, mit einer Testinstanz zu beginnen, die mit Ihrer persönlichen Nummer verbunden ist. Senden Sie Testnachrichten, verifizieren Sie Webhooks und prüfen Sie die Fehlerbehandlung, bevor Sie Produktionsverkehr live schalten.

Best Practices für Entwickler

• API-Schlüssel sicher speichern — Verwenden Sie Umgebungsvariablen statt fest kodierter Strings. Committen Sie niemals API-Schlüssel in die Versionsverwaltung.
• Fehler elegant behandeln — Implementieren Sie Retry-Logik mit exponentiellem Backoff für vorübergehende Fehler (5xx, Netzwerk-Timeouts).
• Webhook-Signaturen validieren — Vertrauen Sie nie unverifizierten Webhook-Anfragen. Prüfen Sie immer den X-Signature-Header.
• Connection Pooling nutzen — Wiederverwenden Sie HTTP-Verbindungen über mehrere Anfragen, statt für jeden API-Aufruf neue zu erstellen.
• Rate-Limits überwachen — Prüfen Sie den X-RateLimit-Remaining-Header und drosseln Sie proaktiv, wenn Sie sich den Limits nähern.
• Alles protokollieren — Zeichnen Sie Anfrage-/Antwort-Paare für das Debugging auf. Schwärzen Sie sensible Daten (Telefonnummern, Nachrichteninhalte) in Produktions-Logs.

Rate-Limits

Rate-Limits gelten pro API-Schlüssel und variieren je nach Tarif. Beim Erreichen des Limits gibt die API den Statuscode 429 mit einem Retry-After-Header zurück. Die Standardwerte:

• Basic-Tarif — 100 Anfragen pro Minute
• Professional-Tarif — 300 Anfragen pro Minute
• Enterprise-Tarif — 1.000 Anfragen pro Minute

Wenn Sie regelmäßig an die Rate-Limits stoßen, ziehen Sie ein Tarif-Upgrade in Betracht oder bündeln Sie Anfragen, wo möglich.

Webhook-Payload-Formate

Eingehende Nachrichten kommen je nach Nachrichtentyp in unterschiedlichen Formaten an:

Textnachricht

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

Bildnachricht

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

Statusaktualisierung

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

Mögliche Statuswerte: sent (an WhatsApp übergeben), delivered (auf dem Gerät angekommen) und read (vom Empfänger geöffnet).

Erste Schritte

1. Konto erstellen (kostenlos, keine Kreditkarte)
2. Wählen Sie einen Tarif auf der Preisseite
3. Erstellen Sie eine Instanz in Ihrem Dashboard
4. Verbinden Sie Ihre Telefonnummer per QR- oder Kopplungscode
5. Lesen Sie die vollständige API-Dokumentation
6. Senden Sie Ihre erste Nachricht und legen Sie los

Community und Support

Werden Sie Teil unserer Entwickler-Community, um Hilfe zu bekommen, Integrationen zu teilen und über neue Funktionen auf dem Laufenden zu bleiben. Wir haben eine aktive Community von Entwicklern, die WhatsApp-Integrationen in jeder Branche bauen.

• Dokumentation — Umfassende API-Referenz mit funktionierenden Beispielen
• Codebeispiele — Vollständige, lauffähige Skripte in PHP, Python, JavaScript und cURL
• E-Mail-Support — Antwort innerhalb von 24 Stunden in allen Tarifen
• Dashboard-Logs — Echtzeit-Einblick in API-Anfragen und Webhook-Zustellungen
• Statusseite — Live-Systemstatus und Historie von Störungen

Ob Sie Ihre erste WhatsApp-Integration bauen oder eine bestehende skalieren — unsere Ressourcen und unser Support-Team helfen Ihnen gern weiter.