LinkedIn
Instagram
Telegramm
Google Kalender
Slack-Gemeinschaft beitreten Inhaltsübersicht
Grundlagen
Verbinden & Senden
Produktion
WhatsApp API PHP-Anleitung
WhatsApp-API mit PHPDas vollständige Integrationshandbuch
Guzzle- und cURL-Aufrufe, um ein WhatsApp-Konto zu verbinden, Nachrichten zu senden und zu empfangen, Gruppen zu verwalten und das Ganze in einem Laravel Anwendung, ohne eine Meta Business-App zu registrieren. Dies ist die WhatsApp API in PHP End-to-End: Verbindung, Webhooks, mandantenfähige SaaS und die echten Kosten pro Nachricht.
Keine Meta-Unternehmensverifizierung
Guzzle & cURL, kein aufgegebenes SDK
connect-whatsapp.php 
verwenden GuzzleHttp\Client;
$client = new Kunde([
'base_uri' => 'https://api1.unipile.com:13111',
'headers' => ['X-API-KEY' => $apiKey],
]);
// Anbieter WHATSAPP: keine Meta-App, kein WABA
$res = $client->Beitrag('/api/v1/accounts', [
'json' => ['provider' => 'WhatsApp'],
]);201 Erstellt, account_id zurückgegeben
Gleiches Muster für 
Definition
Was ist die WhatsApp-API in PHP?
Die WhatsApp API in PHP ist die Praxis, eine WhatsApp-REST-API von einer PHP-Laufzeitumgebung, PHP-FPM, einem CLI-Skript oder einem Warteschlangen-Worker aus aufzurufen, unter Verwendung eines HTTP-Clients wie Guzzle oder cURL. Es gibt keine speziell für PHP entwickelte WhatsApp-API: Meta und API-Anbieter stellen einfaches JSON über HTTPS bereit, und PHP ist einfach die Sprache, die die Anfrage stellt, genau wie sie jede andere Web-API aufrufen würde.
In der Praxis ist eine WhatsApp-API-PHP-Integration ein ganz normaler HTTP-Aufruf: eine Methode, eine URL, ein JSON- oder Multipart-Body und ein
X-API-KEY header. Nichts hier hängt von einer reinen PHP-Funktion oder einem reinen PHP-Endpunkt ab. Was sich zwischen der Cloud-API, einem Business Solution Provider (BSP) und einem verknüpften Konto unterscheidet, ist nicht die Sprache, sondern wem die WhatsApp-Nummer gehört und ob die Meta Business-Verifizierung zwischen Ihnen und Ihrer ersten Nachricht liegt. Eine vollständige Aufschlüsselung dieses Ökosystems finden Sie im WhatsApp-API-Integrationshandbuch.Einfaches JSON über HTTPS
Jeder Aufruf ist ein Request/Response-Zyklus, den Guzzle oder cURL bereits auszuführen wissen.
Die Authentifizierung ist ein statischer Header
Eine
X-API-KEY Wert, kein OAuth-Tanz, kein Token-Refresh-Loop zu schreiben.Laufzeitunabhängig
Funktioniert genauso in PHP-FPM, einem Symfony-Konsolenbefehl oder einem Laravel-Queue-Job.
Entscheidung
Welche WhatsApp-API solltest du von PHP aus verwenden?
Es gibt drei Möglichkeiten, WhatsApp von einem PHP-Backend aus aufzurufen: Metas Cloud-API direkt, ein Business Solution Provider (BSP) Weiterverkauf des Zugangs dazu, oder ein verknüpftes Konto über eine einheitliche API wie Unipile. Alle drei geben JSON zurück, das Ihr PHP-Code auf dieselbe Weise verarbeitet; was sich ändert, ist die Einrichtungsszeit, ob die Meta-Geschäftsverifizierung vor Ihrer ersten Nachricht liegt und ob Sie einen bestehenden Gesprächsverlauf erhalten oder bei Null beginnen.
Kriterien
Cloud-API (direkt)
BSP
Verknüpftes Konto
Meta Unternehmensverifizierung
Erforderlich
Erforderlich
Nicht erforderlich
Zeit bis zur ersten Nachricht
Tage bis zu wenigen Wochen
Schnelleres Onboarding, unveränderte Anforderungen im Hintergrund
Protokoll
Telefonnummer
Neue Nummer bei einer WABA registriert
Neue Nummer vom BSP bereitgestellt
Die eigene bestehende WhatsApp Nummer des Nutzers
Zugriff auf bestehende Unterhaltungen
Nein, beginnt leer
Nein, beginnt leer
Ja, vollständige Historie
Passgenau
Eine Geschäftsnummer sendet an viele Kunden
Gleichfalls, mit einer verwalteten Onboarding-Ebene
Ein Produkt, bei dem jeder Nutzer sein bereits vorhandenes WhatsApp-Konto verknüpft
Wenn Ihre PHP-Anwendung ein SaaS-Produkt ist, bei dem jeder Kunde sein eigenes WhatsApp verbindet, entfällt durch ein verknüpftes Konto der Meta-Verifizierungsschritt vollständig. Wenn Sie stattdessen von einer einzigen Firmennummer aus senden, sind die Cloud API oder ein BSP der richtige Ausgangspunkt.
Mit einem verknüpften Konto erstellen Einrichtung
Was benötigen Sie, bevor Sie PHP-Code schreiben?
Sie benötigen PHP 8.1 oder neuer, Komponist, der / die / das Guzzle HTTP-Client und einem Unipile-API-Schlüssel. Da es derzeit kein aktiv gewartetes PHP-SDK für Unipile gibt, spricht jedes Beispiel in diesem Leitfaden direkt den
/api/v1 REST-API direkt.PHP 8.1+
Typed Properties und benannte Argumente halten den Client-Code kurz.
Komponist
Standard-Abhängigkeitsmanager, erforderlich, um Guzzle einzubinden.
Guzzle 7
HTTP-Client für JSON- und Multipart-Anfragen mit einem cURL-Fallback.
Unipile-API-Schlüssel
Gesendet als
X-API-KEY bei jeder Anfrage, die über Ihr Dashboard generiert wird.composer require guzzlehttp/guzzle:^7.0Gibt es ein PHP-SDK? Keines, das man installieren muss.
Ein Community-Paket,
unipile/unipile-php-sdk, ist auf Packagist vorhanden, aber es ist aufgeführt als verlassenKein Commit seit dem 17. Oktober 2023, 5 Sterne auf GitHub und es zielt auf eine alte API-Basis-URL ab. Nicht ausführen composer require unipile/unipile-php-sdk. Das Node.js SDK (unipile-node-sdk) wird offiziell gepflegt und ist aktuell, aber für PHP ist Guzzle direkt gegen die REST-API der zuverlässige Weg, und genau diesen verwenden alle folgenden Beispiele. Siehe Die Dokumentation von Guzzle für die hier verwendeten Client-Optionen.Umsetzung
Wie verbindet man ein WhatsApp-Konto von PHP aus?
Das Verbinden eines WhatsApp-Kontos von PHP aus dauert eine
POST Anfrage mit dem Anbieter eingestellt auf WHATSAPP, dann eine Nutzeraktion: Der Endnutzer scans den zurückgegebenen QR-Code über WhatsApp > Verknüpfte Geräte oder gibt einen Kopplungscode in sein Telefon ein, falls Sie stattdessen einen angefordert haben. Keine Meta-Entwickler-App, kein WABA, kein Verifizierungsschritt.1
Einen Kontrollpunkt anfordern, standardmäßig QR-Code
Rufen Sie den Konten-Endpunkt nur mit auf
provider Set. Unipile gibt eine account_id plus ein Checkpoint-Payload, das für den QR-Flow erstellt wurde.$response = $client->Beitrag('/api/v1/accounts', [
'json' => ['provider' => 'WhatsApp'],
]);
$payload = json_decode($response->Holen Sie sich den Körper()->Inhalte abrufen(), true);
$accountId = $payload['Konto-ID'];
// $payload enthält auch den Checkpoint, der in das
// Endbenutzer: den QR-Code zum Scannen von WhatsApp > Verknüpft
// Geräte. var_dump($payload) – noch einmal mit Ihrem eigenen Schlüssel
// um die genaue Form zu sehen, bevor das Frontend angebunden wird.2
Oder stattdessen einen Kopplungscode anfordern
Pass
Mobiltelefonnummer koppeln im E.164-Ziffernformat, ohne Pluszeichen, wenn das Scannen eines QR-Codes nicht praktikabel ist, zum Beispiel wenn ein Support-Mitarbeiter einen Kunden telefonisch einrichtet.$response = $client->Beitrag('/api/v1/accounts', [
'json' => [
'provider' => 'WhatsApp',
'pairing_phone_number' => '33612345678',
],
]);
$payload = json_decode($response->Holen Sie sich den Körper()->Inhalte abrufen(), true);
$accountId = $payload['Konto-ID'];
// Der Checkpoint hier ist der Code, den deine Benutzeroberfläche dem Benutzer anzeigt
// in WhatsApp eingeben unter > Verknüpfte Geräte > Mit einem Gerät verknüpfen
// stattdessen Telefonnummer.3
Abfragen, bis das Konto vollständig verknüpft ist
Das Konto verbleibt in einem
VERBINDUNG Warten, bis der QR-Code gescannt oder der Kopplungscode eingegeben wurde. Überprüfen sources[0].status auf Rechnung.$response = $client->bekommen.(""/api/v1/accounts/{$accountId}"");
$account = json_decode($response->Holen Sie sich den Körper()->Inhalte abrufen(), true);
$status = $account['Quellen'][0]['Status'] ?? null;
wenn ($status === OK) {
// Chats können auf dem Konto mit der ID „$accountId“ sicher gesendet, empfangen und aufgelistet werden
}Polling in einer Schleife funktioniert, verschwendet aber Anfragen. Wenn Ihre PHP-Anwendung bereits einen Webhook-Endpunkt hat, registrieren Sie einen bei
Kontostatus" stattdessen und reagieren Sie in dem Moment, in dem der Status umschaltet zu OK. Die Einrichtung des Webhooks selbst wird weiter unten für eingehende Nachrichten behandelt, derselbe Endpunkt akzeptiert Kontostatusereignisse.Kernprozess
Wie sendet man eine WhatsApp-Nachricht mit PHP und Guzzle?
Das Senden einer Nachricht von PHP aus ist eine
POST an den Nachrichten-Endpunkt des Chats mit einem text Feld in einem Multipart-Body. Der Aufruf gibt ein Nachrichten-ID sobald WhatsApp es akzeptiert.$response = $client->Beitrag(""/api/v1/chats/{$chatId}/messages"", [
'multipart' => [
['Name' => 'Text', 'Inhalt' => 'Hallo! Ihre Bestellung wurde versandt.'],
],
]);
$result = json_decode($response->Holen Sie sich den Körper()->Inhalte abrufen(), true);
$messageId = $result['message_id'];Dasselbe
mehrteilig Array überträgt ebenfalls Anhänge, ein stimme_nachricht Datei oder eine Angebot-ID Um auf eine bestimmte Nachricht zu antworten, fügt Guzzle diese als zusätzliche Multipart-Felder neben text. Für die vollständige Aufschlüsselung jedes Nachrichtentypen, die die WhatsApp API unterstützt, einschließlich Vorlagen und dem 24-Stunden-Servicefenster, finden Sie in unserem speziellen Leitfaden.Kernprozess
Wie beginnt man ein neues Gespräch von PHP aus?
Das Starten einer Unterversation, die noch nicht existiert, bedeutet, den Chats-Endpunkt aufzurufen mit einem
account_id und ein attendees_ids Array anstelle eines bestehenden chat_id. Unipile erstellt den Chat und, wenn Sie einen einschließen text Feld sendet die erste Nachricht im selben Aufruf.$response = $client->Beitrag('/api/v1/chats', [
'multipart' => [
['Name' => 'Konto-ID', 'Inhalt' => [$accountId],
['Name' => 'attendees_ids[]', 'Inhalt' => '33612345678@s.whatsapp.net'],
['Name' => 'Text', 'Inhalt' => 'Hallo, hier ist der Acme-Support.'],
],
]);
$result = json_decode($response->Holen Sie sich den Körper()->Inhalte abrufen(), true);
$chatId = $result['chat_id'];Der Empfänger wird identifiziert durch
{phone_number}@s.whatsapp.net, internationale Ziffern, kein führendes Pluszeichen, keine Leerzeichen. Speichern Sie das zurückgegebene chat_id Neben diesem Benutzerdatensatz: Jede Nachricht nach der ersten läuft über den Nachrichten-Endpunkt aus dem vorherigen Abschnitt, nicht über diesen.Kernprozess
Wie ruft man Chats und Nachrichten in PHP ab?
Die meisten WhatsApp-API-Tutorials hören beim Senden auf. Ein PHP-Backend muss in der Regel auch die bestehenden Unterhaltungen eines Benutzers auflisten, durch deren Verlauf blättern und sehen, wer sich in einem Chat befindet. Drei Endpunkte decken dies ab:
GET /api/v1/chats, GET /api/v1/chats/{chat_id}/messagesund GET /api/v1/chats/{chat_id}/attendees, alle mit einem Cursor paginiert.Alle WhatsApp-Chats eines Kontos auflisten
$response = $client->bekommen.('/api/v1/chats', [
'query' => [
''account_id' => $accountId,
'account_type' => 'WhatsApp',
'limit' => 50,
],
]);
$data = json_decode($response->Holen Sie sich den Körper()->Inhalte abrufen(), true);
$chats = $data['Artikel'];
$nextCursor = $data['Cursor'];Blättern Sie durch den Verlauf eines Chats
$cursor = null;
$all = [];
tun {
$res = $client->bekommen.(""/api/v1/chats/{$chatId}/messages"", [
'query' => array_filter(['Cursor' => $cursor, 'Grenze' => 100]),
]);
$page = json_decode($res->Holen Sie sich den Körper()->Inhalte abrufen(), true);
$all = array_merge($all, $page['Artikel']);
$cursor = $page['Cursor'];
} während ($cursor !== null);Jeder Listen-Endpunkt folgt demselben Cursor-Vertrag: Übergeben Sie die Antwort des vorherigen
Cursor zurückfahren, anhalten, wenn es zurückkommt null. Um zu sehen, wer tatsächlich an einem Gespräch teilnimmt, rufen Sie auf GET /api/v1/chats/{chat_id}/attendees: er gibt jeden Teilnehmer zurück id, provider_id und einem Anzeigenamen, den Sie benötigen, bevor Sie anrufen können Teilnehmer hinzufügen oder Teilnehmer entfernen in einer Gruppe später in diesem Leitfaden.Produktion
Wie empfängt man WhatsApp-Nachrichten mit einem PHP-Webhook?
Ein WhatsApp-Webhook in PHP ist ein öffentlicher HTTPS-Endpunkt, den Unipile bei Ereignissen wie mit einer JSON-Nutzlast aufruft
nachricht_erhalten. Dein Skript liest den Raw-Body, bestätigt, dass der Aufruf echt ist, antwortet schnell und übergibt die eigentliche Arbeit an eine Warteschlange. Polling GET /api/v1/chats Für neue Nachrichten funktioniert das bei einer Demo, aber nicht bei einem Produkt mit mehr als einer Handvoll Nutzer.1. Registrieren Sie den Webhook mit einem gemeinsamen Geheimnis in einem benutzerdefinierten Header
$client->Beitrag('/api/v1/webhooks', [
'json' => [
'source' => 'Nachrichten',
'request_url' => 'https://example.com/webhooks/whatsapp',
'events' => ['Nachricht empfangen'],
'headers' => [
['Schlüssel' => 'X-Webhook-Secret', 'Wert' => [$webhookSecret],
],
],
]);2. Überprüfen, antworten und dann verarbeiten
$rawBody = file_get_contents('php://input');
$provided = $_SERVER['HTTP_X_WEBHOOK_SECRET'] ?? '';
wenn (!hash_equals($expectedSecret, $provided)) {
http_response_code(401);
Ausgang;
}
http_response_code(200);
wenn (function_exists('fastcgi_finish_request')) {
fastcgi_finish_request();
}
$payload = json_decode($rawBody, true);
wenn (($payload['Ereignis'] ?? null) === 'Nachricht empfangen') {
// $-Nutzdaten in eine Warteschlangentabelle oder eine Redis-Liste einfügen,
// Verarbeite niemals einen Webhook direkt (inline)
whatsapp_nachricht_in_warteschlange_einreihen($payload);
}Unipile signiert den Webhook-Body nicht mit einem HMAC-Geheimnis, das Sie neu berechnen, der Create-Webhook-Endpunkt legt einen
Kopfzeilen Verwenden Sie stattdessen ein Array. Fügen Sie bei der Registrierung des Webhooks Ihr eigenes Geheimnis als benutzerdefinierten Header hinzu und überprüfen Sie es anschließend mit hash_equals(), einen timing-sicheren String-Vergleich, bevor Sie dem Nutzdaten-Inhalt vertrauen. Jedes Feld in $nutzlast, account_id, Kontotyp, Veranstaltung, chat_id, Nachrichten-ID, message und sender.attendee_provider_id, entspricht den JSON-Unipile-Dokumenten für den Messaging-Webhook.Produktion
Wie integriert man die WhatsApp API in eine Laravel-Anwendung?
Laravel ersetzt drei Dinge aus den obigen reinen PHP-Beispielen: die
HTTP Fassade anstelle eines handgeschriebenen Guzzle-Clients, ein eingereiihter Job anstelle der Inline-Verarbeitung und eine Route plus Controller anstelle des Parsens php://input von Hand. Die WhatsApp-Anrufe darunter sind identisch mit jedem Beispiel, das bereits in dieser Anleitung enthalten ist.1. KonfigurationEin Eintrag in services.php, Werte aus .env
return [
// ...bestehende Dienste
'unipile' => [
'base_uri' => Umgebung('UNIPILE_BASE_URI', 'https://api1.unipile.com:13111'),
'api_key' => Umgebung('UNIPILE_API_SCHLÜSSEL'),
'webhook_secret' => Umgebung('UNIPILE_WEBHOOK_SECRET'),
],
];2. Eine dünne Service-Klasse über der HTTP-Fassade
Namensraum App\Services;
verwenden Illuminate\Support\Facades\Http;
Klasse WhatsApp-Dienst
{
geschützt Funktion client()
{
return Http::Basiskennung(Konfiguration('services.unipile.base_uri'))
->mitHeadern(['X-API-KEY' => Konfiguration('services.unipile.api_key')]);
}
öffentlich Funktion sendMessage(Zeichenkette $chatId, Zeichenkette $text): Array
{
return $this->client()
->alsMultipart()
->Beitrag(""/api/v1/chats/{$chatId}/messages"", [
['Name' => 'Text', 'Inhalt' => $text],
])
->json();
}
}3. Routen- und Webhook-Controller
Route::Beitrag('/webhooks/whatsapp', [WhatsappWebhookController::Klasse, 'Griff']);public function handle(Request $request)
{
$provided = $request->header('X-Webhook-Secret', '');
if (!hash_equals(config('services.unipile.webhook_secret'), $provided)) {
abort(401);
}
if ($request->input('event') === 'message_received') {
ProcessWhatsappMessage::dispatch($request->all());
}
return response()->json(['status' => 'received']);
}4. Ein eingereihter Job, damit die Webhook-Route schnell bleibt
Klasse WhatsappNachrichtVerarbeiten implementiert ShouldQueue
{
verwenden Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
öffentlich Funktion __construct(öffentlich Array $payload) {}
öffentlich Funktion Griff(): leer
{
// Den Mieter anhand von $this->payload['account_id'] suchen,
// Nachricht speichern, den richtigen Benutzer benachrichtigen
}
}Die Route berührt Guzzle niemals direkt, sie geht durch
Bauen Sie es in Laravel WhatsApp-Dienst, was WhatsApp-Anrufe in Tests genauso mockbar macht wie jede andere Laravel-HTTP-Integration. Siehe Dokumentation des Laravel-HTTP-Clients zum Fälschen dieser Anfragen in Ihrer Testsuite.Produktion
Wie verwaltet man WhatsApp-Gruppen von PHP aus?
Die Verwaltung einer WhatsApp-Gruppe von PHP aus ist ein einzelner
PATCH Aufruf an den Chat-Endpunkt mit einem Aktion Feld Teilnehmer hinzufügen, Teilnehmer entfernen, oder Einladungslink abrufen. Die Gruppenfunktion der eigenen Cloud-API von Meta limitiert eine Gruppe auf 8 Teilnehmer und bietet keinen Endpunkt, um jemanden direkt hinzuzufügen, sondern nur einen Einladungslink zum Teilen.Teilnehmer hinzufügen
$client->Patch(""/api/v1/chats/{$groupChatId}"", [
'json' => [
'Aktion' => 'TeilnehmerHinzufügen',
'Wert' => '33612345678@s.whatsapp.net',
],
]);Hole den Einladungslink
$res = $client->Patch(""/api/v1/chats/{$groupChatId}"", [
'json' => ['action' => 'EinladungslinkErhalten'],
]);
$link = json_decode($res->Holen Sie sich den Körper()->Inhalte abrufen(), true)['Einladungslink'];Teilnehmer entfernen nimmt dieselbe Form an wie Teilnehmer hinzufügen, mit der WhatsApp-ID des Teilnehmers in Wert. Dies ist die einzige Aktion, die Metas eigene Groups-API überhaupt nicht bereitstellt; das Hinzufügen von Personen erfolgt ausschließlich über den Einladungslink auf deren Seite. Alle Details zu den Beschränkungen, der Obergrenze von 10.000 Gruppen pro Nummer und den Funktionen, die nach wie vor nicht unterstützt werden, finden Sie im WhatsApp-Gruppen-API Referenz.Skala
Wie verwaltet man viele Benutzerkonten von einer PHP-Anwendung aus?
Ein PHP-SaaS-Produkt hat nicht ein WhatsApp-Konto, sondern eines pro Kunde. Es gibt ein einziges Unipile
X-API-KEY für Ihre gesamte Anwendung, aber ein eigener account_id für jeden Endbenutzer, der sein WhatsApp verknüpft. Das Muster ist, das zu speichern account_id neben Ihrer eigenen Mandantenzeile, und übergeben Sie ihn explizit bei jedem Aufruf, der sonst kontenübergreifend erfolgen könnte.// Innerhalb des Webhook-Handlers: Finde heraus, zu welchem Tenant dieser
// Die Nachricht gehört dazu, bevor etwas damit gemacht wird.
$stmt = $pdo->vorbereiten('SELECT id FROM tenants WHERE unipile_account_id = ?');
$stmt->ausführen([$payload['Konto-ID']]);
$tenantId = $stmt->Spalte abrufen();
wenn ($tenantId === falsch) {
// Unbekannte account_id, ablehnen anstatt den Mandanten zu raten
http_response_code(404);
Ausgang;
}
// Outbound: übergebe account_id, damit eine veraltete oder wiederverwendete chat_id
// Senden Sie niemals über die WhatsApp-Nummer des falschen Mandanten.
$client->Beitrag(""/api/v1/chats/{$chatId}/messages"", [
'multipart' => [
['Name' => 'Text', 'Inhalt' => $text],
['Name' => 'Konto-ID', 'Inhalt' => [$expectedAccountId],
],
]);Das Optionale
account_id Das Feld auf dem Nachrichten-Endpunkt existiert speziell, um das Senden in einem Chat außerhalb dieses Kontos zu verhindern, und sollte in einer Mandanten-Fähigen Codebasis als obligatorisch behandelt werden, obwohl die API dies nicht erfordert. Verschlüsseln Sie das gespeicherte account_id Werte im Ruhezustand wie jede andere Kundenzugangsdaten: Sie sind für sich genommen kein Geheimnis, aber sie sind der Verbindungsschlüssel zwischen Ihrer Benutzertabelle und den echten WhatsApp-Gesprächen von jemandem.Fallstricke
Was sind die häufigsten PHP-spezifischen Fehler?
Die meisten WhatsApp-API-Fehler in einer PHP-Codebase liegen an PHP selbst und nicht an der API. Diese fünf treten in Produktionsintegrationen immer wieder auf.
Das Kürzen einer Nachricht mit substr() anstelle von mb_substr()
PHP
Teilzeichenkette() zählt Bytes, keine Zeichen. Ein Emoji ist eine Multi-Byte-UTF-8-Sequenz; schneidet man es in der Mitte durch, sendet man ein beschädigtes Zeichen oder ungültiges JSON. Verwenden Sie bei benutzergenerierten WhatsApp-Texten immer die Multi-Byte-Funktionen.$safe = mb_substr($text, 0, 4096, 'UTF-8');cURL-Fehler 60 unter Windows und XAMPP
"SSL-Zertifikatsproblem: Lokales Ausstellerzertifikat konnte nicht abgerufen werden. Windows-PHP-Builds und XAMPP werden oft ohne ein aktuelles, in der php.ini eingebundenes CA-Bundle ausgeliefert, sodass die HTTPS-Aufrufe von Guzzle fehlschlagen, obwohl der Code korrekt ist.
curl.cainfo = "C:\php\extras\cacert.pem"
openssl.cafile = "C:\php\extras\cacert.pem"max_execution_time bricht den Webhook ab, bevor er antwortet
Ein Standardwert von 30 Sekunden ist völlig ausreichend, bis der Handler vor der Antwort einen langsamen ausgehenden Anruf tätigt. Wenn Unipile keine schnelle Antwort erhält, versucht es den Vorgang erneut, und ein langsamer Handler beginnt, dieselbe Nachricht doppelt zu verarbeiten. Erst antworten, dann arbeiten, wie im obigen Webhook-Abschnitt gezeigt.
Kein Backoff bei 429- oder 5xx-Antworten
Ein enges
während Eine Schleife, die bei einem Fehler sofort Wiederholungsversuche unternimmt, verwandelt ein Rate Limit in einen selbstverschuldeten Ausfall. Warten Sie, und erhöhen Sie die Wartezeit bei jedem aufeinanderfolgenden Fehler.für ($attempt = 1; $attempt <= 5; $attempt++) {
versuchen {
return $client->Beitrag($uri, $options);
} fangen (ConnectException | ServerException $e) {
usleep((2 ** $attempt) * 100_000); // 0,2s, 0,4s, 0,8s...
}
}Das Protokollieren der rohen Antwort und es als Debugging zu bezeichnen
Wenn Sie einen JSON-Body von Hand erstellen, anstatt Guzzles
json Option „Behandeln“, hinzufügen JSON_UNESCAPED_UNICODE zu json_encode(). Ohne sie werden Emojis und Namen mit Akzenten als maskiert angezeigt. \u Sequenzen in Ihren Protokollen, die zwar technisch gültiges JSON sind, aber unlesbar, wenn Sie versuchen, eine echte Konversation zu debuggen.Kosten
Wie viel kostet das Versenden von WhatsApp-Nachrichten über PHP?
Nichts im PHP-Code ändert den Preis. Meta berechnet pro Nachricht seit dem 1. Juli 2025, nicht pro Konversation. Das Einzige, was Ihr Code steuert, ist das Timing: Eine Antwort, die innerhalb des 24-Stunden-Servicefensters nach der Nachricht eines Nutzers gesendet wird, ist weiterhin kostenlos, derselbe Aufruf eine Stunde später ist kostenpflichtig.
Dienstprogramm- und Authentifizierungsvorlagen Bleiben Sie innerhalb eines offenen Servicefensters kostenlos, die Abrechnung erfolgt außerhalb davon.
Marketing-Vorlagen werden unabhängig von dem Zeitfenster berechnet.
Die Gebühren pro Nachricht variieren je nach Empfängerland und Nachrichtenkategorie, nicht nach der Client-Bibliothek, mit der Sie sie senden.
Versehen Sie jede eingehende Nachricht, die Ihr PHP-Webhook empfängt, mit einem Zeitstempel und führen Sie für jede Unterhaltung einen Wert "Fenster geöffnet bis", das ist die einzige Eingabe, die Ihre Abrechnungslogik tatsächlich benötigt. Für aktuelle Preiskalkulation pro Nachricht bei WhatsApp nach Land und Kategorie finden Sie die vollständige Preisübersicht.
WhatsApp API mit PHP - Häufig gestellte Fragen
Klare Antworten zu den Themen Verbindung, Senden, Laravel und dem aufgegebenen PHP-SDK.
Erstellen Sie einen Guzzle-Client, der auf die Unipile REST API verweist, und rufen Sie
POST /api/v1/accounts mit Anbieter WHATSAPP Um einen QR-Code oder Kopplungscode zu erhalten, lassen Sie den Benutzer dies auf seinem Telefon abschließen und verwenden Sie dann denselben Client für GET, POST und PATCH Aufrufe zum Senden von Nachrichten, Auflisten von Chats und Verwalten von Gruppen. Es gibt keinen PHP-spezifischen Endpunkt, jeder Aufruf ist eine normale HTTP-Anfrage mit einer X-API-KEY Kopfzeile. Das ein WhatsApp-Konto verknüpfen Der obige Abschnitt führt durch den genauen Code.Ja. Ein einzelnes
POST zu /api/v1/chats/{chat_id}/nachrichten with a text Feld in einem Multipart-Body sendet die Nachricht und gibt ein zurück Nachrichten-ID, siehe die Abschnitt senden oben für den genauen Guzzle-Aufruf.Nur wenn Sie direkt über die Cloud-API von Meta oder einen darauf aufgebauten Business Solution Provider gehen. Das Verbinden eines WhatsApp-Kontos über Unipile verknüpft die bestehende WhatsApp-Nummer des Benutzers per QR-Code oder Kopplungscode und erfordert überhaupt keine Meta-Unternehmensverifizierung.
Kein aktiv gewartetes. Ein Community-Paket,
unipile/unipile-php-sdk, ist auf Packagist, aber markiert verlassen, ohne Commits seit dem 17. Oktober 2023 und mit 5 Sternen auf GitHub. Jedes Beispiel in diesem Leitfaden ruft stattdessen die REST-API direkt über Guzzle auf, was auch das ist, was das aufgegebene SDK intern tat.Sie können keine Webhooks ohne eine öffentlich erreichbare HTTPS-URL empfangen, so funktionieren HTTP-Callbacks. Leiten Sie während der lokalen Entwicklung einen lokalen Port mit einem Dienst wie ngrok weiter und verweisen Sie auf den Webhook
anfrage_url unter der HTTPS-Adresse des Tunnels. Abfragen des Nachrichten-Endpunkts ist der Rückgriff, wenn ein öffentlicher Endpunkt tatsächlich nicht möglich ist, auf Kosten von Latenz und zusätzlichen Anfragen.Ja, daran ist nichts Framework-spezifisch. Das Laravel-Bereich oben fasst dieselben Guzzle-äquivalenten Aufrufe in dem
HTTP Fassade, ein geplanter Job sowie eine Webhook-Route und ein Controller, was der idiomatische Weg ist, dies in einer Laravel-Codebasis zu strukturieren.Ja, das ist das normale SaaS-Modell. Ein Unipile-API-Schlüssel deckt die gesamte Anwendung ab, während jeder Endbenutzer seinen eigenen erhält.
account_id nachdem sie ihr WhatsApp verbunden haben. Speichern Sie diese ID neben Ihrem Mandantendatensatz und geben Sie sie bei ausgehenden Anrufen weiter, um mandantenübergreifende Sendungen zu verhindern, siehe das Mandantenfähiger Abschnitt oben.PATCH /api/v1/chats/{chat_id} mit {"action": "addParticipant", "value": "@s.whatsapp.net"}. Die Funktion für Gruppen der eigenen Cloud-API von Meta hat keinen äquivalenten Endpunkt, sondern nur einen Einladungslink, was einer der klareren Unterschiede zwischen dem direkten Aufbau auf Meta und der Nutzung von Unipile ist. Details im Gruppenbereich oben.Fast immer, weil eine Zeichenkette abgeschnitten wurde mit
Teilzeichenkette() anstatt mb_substr(). Die nativen String-Funktionen von PHP zählen Bytes, und ein Emoji ist eine Multibyte-UTF-8-Sequenz. Wenn es in der Mitte abgeschnitten wird, wird es zu einem ungültigen Zeichen oder zerstört die JSON-Nutzdaten vollständig.Guzzle reicht aus, es ist ein auf der cURL-Erweiterung von PHP aufbauender HTTP-Client und kein Ersatz dafür. Jede Anfrage in diesem Leitfaden verwendet Guzzle; ein roher
curl_init() Call funktioniert identisch, wenn ein Projekt die Abhängigkeit nicht hinzufügen kann; die JSON- und Multipart-Bodys sind in beiden Fällen gleich.Genauso wie beim Versand auf jedem anderen Weg. Meta berechnet seit dem 1. Juli 2025 pro Nachricht basierend auf Kategorie und Empfängerland, nicht nach der zum Aufrufen der API verwendeten Client-Bibliothek. Siehe das Kostenbereich oben und die Vollständiger Preisleitfaden für aktuelle Tarife.
Ja, es verschwindet nicht, es bestimmt nur, was kostenlos ist, anstatt was technisch erlaubt ist. Eine Antwort innerhalb des 24-Stunden-Fensters nach der letzten Nachricht eines Nutzers wird versendet, ohne als Templatenachricht abgerechnet zu werden; PHP-Code, der das Fenster ignoriert, bezahlt einfach für Nachrichten, die er nicht gebraucht hätte.
Haben Sie noch Fragen zur Umsetzung in PHP? Unser Team hilft Ihnen gerne weiter.
WhatsApp API PHP-Anleitung
Bereit, die WhatsApp-API in Ihre PHP-Anwendung zu integrieren?
Jeder Endpunkt in diesem Leitfaden – connect, send, receive, groups – läuft über dasselbe Unipile-Konto, das Sie jetzt sofort erstellen können. Keine Meta-Business-Verifizierung, kein veraltetes SDK, sondern einfach nur
Guzzle und eine REST-API, die Ihre PHP-Anwendung bereits aufrufen kann.Automatisieren statt in eine bestehende App zu integrieren? Lesen dieselbe Integration in Python.
DE 
EN 
FR 
ES 
IT 
BR 
NL 
PL 
TR