LinkedIn
Instagram
Telegram
Google Agenda
Word lid van de Slack-gemeenschap Inhoudsopgave
Grondbeginselen
Verbinden & Verzenden
Productie
Schaal, Kosten & Veelgestelde Vragen
WhatsApp API PHP Gids
WhatsApp API met PHPDe Volledige Integratiegids
Guzzle- en cURL-aanroepen om een WhatsApp-account te koppelen, berichten te verzenden en te ontvangen, groepen te beheren en dit geheel uit te voeren in een Laravel applicatie, zonder een Meta Business-app te registreren. Dit is de WhatsApp API in PHP end-to-end: verbinding, webhooks, multi-tenant SaaS en de echte kosten per bericht.
Geen Meta Business-verificatie
Guzzle & cURL, geen verouderde SDK
connect-whatsapp.php 
gebruik GuzzleHttp\Client;
$client = nieuw Cliënt([
'base_uri' => 'https://api1.unipile.com:13111',
'headers' => ['X-API-KEY' => $apiKey],
]);
// Provider WHATSAPP: geen Meta-app, geen WABA
$res = $client->post('/api/v1/accounts', [
'json' => ['provider' => 'WHATSAPP'],
]);201 Gemaakt, account_id geretourneerd
Hetzelfde patroon voor 
Definitie
Wat is de WhatsApp API in PHP?
De WhatsApp API in PHP is de praktijk van het aanroepen van een WhatsApp REST API vanuit een PHP-runtime, PHP-FPM, een CLI-script of een queue worker, met behulp van een HTTP-client zoals Guzzle of cURL. Er is geen WhatsApp API die specifiek voor PHP is gebouwd: Meta en API-providers stellen plain JSON beschikbaar via HTTPS, en PHP is simpelweg de taal die het verzoek doet, op dezelfde manier waarop het elke andere web-API zou aanroepen.
In de praktijk is een WhatsApp API PHP-integratie een normale HTTP-aanroep: een methode, een URL, een JSON- of multipart-body en een
X-API-KEY header. Niets hiervan is afhankelijk van een functie of endpoint dat alleen voor PHP is. Wat er verandert tussen de Cloud API, een Business Solution Provider (BSP) en een gekoppeld account is niet de taal, maar wie de eigenaar is van het WhatsApp-nummer en of de Meta Business-verificatie zich bevindt tussen jou en je eerste bericht. Voor de volledige uiteenzetting van dat ecosysteem, zie de WhatsApp API-integratiegids.Plain JSON over HTTPS
Elke aanroep is een request/response-cyclus die Guzzle of cURL al kan maken.
Authenticatie is een statische header
Een
X-API-KEY waarde, geen OAuth-dans, geen token-verversingslus om te schrijven.Runtime-agnostisch
Werkt hetzelfde in PHP-FPM, een Symfony console-commando of een Laravel queue-job.
Beslissing
Welke WhatsApp API moet je gebruiken vanuit PHP?
Er zijn drie manieren om WhatsApp aan te roepen vanuit een PHP-backend: Meta's Cloud-API rechtstreeks, een Business Solution Provider (BSP) het doorverkopen van toegang daartoe, of een gekoppeld account via een verenigde API zoals Unipile. Alle drie retourneren ze JSON die je PHP-code op dezelfde manier verwerkt; wat wel verander je, is de insteltijd, of Meta Business-verificatie voor je eerste bericht staat, en of je een bestaande gespreksgeschiedenis krijgt of vanaf nul begint.
Criteria
Cloud-API (direct)
BSP
Gekoppeld account
Meta Bedrijfsverificatie
Vereist
Vereist
Niet vereist
Tijd tot het eerste bericht
Dagen tot enkele weken
Snellere onboarding, dezelfde onderliggende vereisten
Notulen
Telefoonnummer
Nieuw nummer geregistreerd bij een WABA
Nieuw nummer verstrekt door de BSP
Het eigen bestaande WhatsApp-nummer van de gebruiker
Toegang tot bestaande gesprekken
Nee, begint leeg
Nee, begint leeg
Ja, volledige geschiedenis
Beste pasvorm
Eén bedrijfsnummer uitzenden naar vele klanten
Hetzelfde, met een beheerde onboardinglaag
Een product waarbij elke gebruiker het WhatsApp-account koppelt dat hij of zij al heeft
Als je PHP-applicatie een SaaS-product is waarbij elke klant zijn eigen WhatsApp koppelt, verwijdert een gekoppeld account de Meta-verificatiestap volledig. Als je uitzendt vanaf een enkel bedrijfsnummer, is de Cloud API of een BSP in plaats daarvan het juiste uitgangspunt.
Bouwen met een gekoppeld account Setup
Wat heb je nodig voordat je PHP-code schrijft?
Je moet PHP 8.1 of hoger, Componist, de Gulzig schrokken HTTP-client en een Unipile API-sleutel. Er is momenteel geen actief onderhouden PHP SDK voor Unipile, dus elk voorbeeld in deze handleiding communiceert met de
/api/v1 Rechtstreeks via de REST API.PHP 8.1 of hoger
Getypeerde eigenschappen en benoemde argumenten houden de clientcode kort.
Componist
Standaard afhankelijkheidsbeheerder, vereist om Guzzle te kunnen installeren.
Guzzle 7
HTTP-client voor JSON- en multipart-verzoeken, met een cURL-fallback.
Unipile API-sleutel
Verzonden als
X-API-KEY bij elk verzoek dat vanuit uw dashboard wordt gegenereerd.composer require guzzlehttp/guzzle:^7.0Is er een PHP-SDK? Niet eentje die je moet installeren.
Een gemeenschapspakket,
unipile/unipile-php-sdk, staat op Packagist, maar wordt vermeld als verlaten: geen commit sinds 17 oktober 2023, 5 sterren op GitHub, en het richt zich op een oude API-basis-URL. Niet uitvoeren composer require unipile/unipile-php-sdk. De Node.js SDK (unipile-node-sdk) wordt officieel onderhouden en is up-to-date, maar voor PHP is Guzzle, rechtstreeks gekoppeld aan de REST API, de betrouwbare keuze, en dat is ook wat in alle onderstaande voorbeelden wordt gebruikt. Zie De documentatie van Guzzle voor de hier gebruikte cliëntopties.Implementatie
Hoe verbind je een WhatsApp-account vanuit PHP?
Het koppelen van een WhatsApp-account vanuit PHP kost één
POST verzoek met de provider ingesteld op WHATSAPP, dan één gebruikersactie: de eindgebruiker scant de geretourneerde QR-code vanuit WhatsApp > Gekoppelde apparaten, of voert een koppelcode in op zijn telefoon als je er in plaats daarvan om hebt gevraagd. Geen Meta-ontwikkelaarsapp, geen WABA, geen verificatiestap.1
Vraag een controlepunt aan, standaard een QR-code
Roep het accounts-eindpunt aan met alleen
provider set. Unipile retourneert een account_id plus een controlepunt-payload gebouwd voor de QR-stroom.$response = $client->post('/api/v1/accounts', [
'json' => ['provider' => 'WHATSAPP'],
]);
$payload = json_decode($response->getBody()->Inhoud ophalen(), true);
$accountId = $payload['account_id'];
// $payload bevat ook het controlepunt dat moet worden weergegeven in de
de QR-code om te scannen vanuit WhatsApp > Gekoppelde apparaten
// apparaten. voer var_dump($payload) nogmaals uit met je eigen sleutel
// om de exacte vorm te zien voordat de frontend wordt aangesloten.2
Of vraag in plaats daarvan een koppelingscode aan
Pass
telefoonnummer_koppelen in E.164-cijfers, zonder plus-teken, wanneer het scannen van een QR-code niet praktisch is, bijvoorbeeld wanneer een supportmedewerker een klant telefonisch onboardt.$response = $client->post('/api/v1/accounts', [
'json' => [
'provider' => 'WHATSAPP',
'pairing_phone_number' => '33612345678',
],
]);
$payload = json_decode($response->getBody()->Inhoud ophalen(), true);
$accountId = $payload['account_id'];
// Het controletelpunt hier is de code die uw UI aan de gebruiker toont
// te typen in WhatsApp > Gekoppelde apparaten > Koppel met
// gebruik in plaats daarvan een telefoonnummer.3
Peilen totdat het account volledig is gekoppeld
Het account blijft in een
VERBINDEN wacht tot de QR-code is gescand of de koppelingscode is ingevoerd. Controleer sources[0].status op de rekening.$response = $client->krijgen(""/api/v1/accounts/{$accountId}"");
$account = json_decode($response->getBody()->Inhoud ophalen(), true);
$status = $account['bronnen'][0]['status'] ?? nul;
als ($status === "OK) {
// veilig om chats te verzenden, te ontvangen en weer te geven op $accountId
}Polling in een lus werkt, maar verspilt verzoeken. Als je PHP-toepassing al een webhook-eindpunt heeft, registreer er dan een bij
accountstatus" in plaats daarvan en reageer op het moment dat de status overgaat naar OK. De webhook-instelling zelf wordt verder naar beneden behandeld voor inkomende berichten, en dezelfde endpoint accepteert gebeurtenissen met betrekking tot de accountstatus.Kernproces
Hoe verstuur je een WhatsApp-bericht met PHP en Guzzle?
Een bericht verzenden vanuit PHP is een
POST naar het chatberichten-eindpunt met een text veld in een multipart-lichaam. De aanroep retourneert een bericht-id zodra WhatsApp het accepteert.$response = $client->post(""/api/v1/chats/{$chatId}/messages"", [
'multipart' => [
['naam' => "tekst, 'Inhoud' => 'Hoi! Je bestelling is verzonden.'],
],
]);
$result = json_decode($response->getBody()->Inhoud ophalen(), true);
$messageId = $result['message_id'];Hetzelfde
meerdelig array draagt ook bijlagen, een spraakbericht bestand, of een offerte_id Om op een specifiek bericht te reageren, voegt Guzzle deze toe als extra multipart-velden naast text. Voor het volledige overzicht van elke berichttypen die de WhatsApp API ondersteunt, inclusief sjablonen en het 24-uurs servicovenster, vind je in onze speciale handleiding.Kernproces
Hoe start je een nieuw gesprek vanuit PHP?
Het starten van een gesprek dat nog niet bestaat, betekent dat je het chats-eindpunt aanroept met een
account_id en een attendees_ids array in plaats van een bestaande chat_id. Unipile maakt de chat aan en, als je een text veld, verzorgt het eerste bericht in dezelfde aanroep.$response = $client->post('/api/v1/chats', [
'multipart' => [
['naam' => 'account_id', 'Inhoud' => [$accountId],
['naam' => 'attendees_ids[]', 'Inhoud' => '33612345678@s.whatsapp.net'],
['naam' => "tekst, 'Inhoud' => 'Hoi, dit is Acme support.'],
],
]);
$result = json_decode($response->getBody()->Inhoud ophalen(), true);
$chatId = $result['chat_id'];De ontvanger wordt geïdentificeerd door
{phone_number}@s.whatsapp.net, internationale cijfers, geen leidend plus-teken, geen spaties. Sla de geretourneerde chat_id Naast die gebruikersrecord: elk bericht na het eerste gaat via het berichten-eindpunt uit de vorige sectie, niet via deze.Kernproces
Hoe haal je chats en berichten op in PHP?
De meeste WhatsApp API-tutorials stoppen bij het verzenden. Een PHP-backend moet meestal ook de bestaande gesprekken van een gebruiker kunnen weergeven, door hun geschiedenis bladeren en zien wie er in een chat zit. Drie eindpunten dekken dit:
GET /api/v1/chats, GET /api/v1/chats/{chat_id}/messagesen GET /api/v1/chats/{chat_id}/attendees, allemaal gepagineerd met een cursor.Geef een lijst van elke WhatsApp-chat op een account
$response = $client->krijgen('/api/v1/chats', [
'query' => [
''account_id' => $accountId,
'account_type' => 'WHATSAPP',
'limiet' => 50,
],
]);
$data = json_decode($response->getBody()->Inhoud ophalen(), true);
$chats = $data['artikelen'];
$nextCursor = $data['cursor'];Blader door de geschiedenis van één chat
$cursor = nul;
$all = [];
doen {
$res = $client->krijgen(""/api/v1/chats/{$chatId}/messages"", [
'query' => array_filter(['cursor' => $cursor, 'limiet' => 100]),
]);
$pagina = json_decode($res->getBody()->Inhoud ophalen(), true);
$all = array_merge($all, $page['artikelen']);
$cursor = $page['cursor'];
} terwijl ($cursor !== nul);Elk lijst-eindpunt volgt hetzelfde cursorschema: geef de vorige respons door
cursor achteruit inparkeren, stop zodra het terugkomt nul. Om te zien wie er daadwerkelijk in een gesprek zit, bel GET /api/v1/chats/{chat_id}/attendees: het retourneert van elke deelnemer id, provider_id en weergavenaam, wat je nodig hebt voordat je kunt bellen deelnemerToevoegen of deelnemerVerwijderen verderop in deze gids over een groep.Productie
Hoe ontvang je WhatsApp-berichten met een PHP webhook?
Een WhatsApp-webhook in PHP is een openbaar HTTPS-eindpunt dat Unipile aanroept met een JSON-payload bij gebeurtenissen zoals
bericht_ontvangen. Jouw script leest de ruwe body, bevestigt dat de oproep echt is, reageert snel en draagt het daadwerkelijke werk over aan een wachtrij. Polling GET /api/v1/chats voor nieuwe berichten werkt voor een demo, niet voor een product met meer dan een handvol gebruikers.1. Registreer de webhook, met een gedeeld geheim in een aangepaste header
$client->post('/api/v1/webhooks', [
'json' => [
'bron' => 'Berichtenuitwisseling',
'request_url' => 'https://example.com/webhooks/whatsapp',
'events' => ['bericht_ontvangen'],
'headers' => [
['sleutel' => 'X-Webhook-Secret', 'waarde' => [$webhookSecret],
],
],
]);2. Controleer, reageer en verwerk vervolgens
$rawBody = file_get_contents('php://input');
$provided = $_SERVER['HTTP_X_WEBHOOK_SECRET'] ?? '';
als (!hash_equals($expectedSecret, $provided)) {
http_response_code(401);
uitgang;
}
http_response_code(200);
als (function_exists('fastcgi_finish_request')) {
fastcgi_finish_request();
}
$payload = json_decode($rawBody, true);
als (($payload['evenement'] ?? nul) === 'bericht_ontvangen') {
// $-payload naar een wachtrijtabel of Redis-lijst plaatsen,
verwerk nooit een webhook inline
whatsapp_bericht_in_wachtrij_plaatsen($payload);
}Unipile ondertekent de webhook-body niet met een HMAC-geheim dat u opnieuw berekent, het create-webhook-eindpunt stelt een
kopteksten in plaats daarvan een array. Voeg je eigen geheime sleutel toe als een aangepaste header wanneer je de webhook registreert, en controleer deze vervolgens met hash_equals(), een timing-veilige stringvergelijking, voordat de payload wordt vertrouwd. Elk veld in $payload, account_id, accounttype, evenement, chat_id, bericht-id, message en afzender.deelnemer_provider_id, komt overeen met de JSON Unipile-documenten voor de messaging-webhook.Productie
Hoe integreer je de WhatsApp API in een Laravel-applicatie?
Laravel vervangt drie dingen uit de voorbeelden in platte PHP hierboven: het
http facade in plaats van een handgemaakte Guzzle-client, een gekoppelde taak in plaats van inline verwerking, en een route plus controller in plaats van parsen php://input met de hand. De WhatsApp-oproepen hieronder zijn identiek aan elk voorbeeld dat al in deze handleiding staat.1. ConfiguratieEén vermelding in services.php, waarden uit .env
return [
// ...bestaande services
'unipile' => [
'base_uri' => milieu('UNIPILE_BASE_URI', 'https://api1.unipile.com:13111'),
'api_key' => milieu('UNIPILE_CONTROLSLEUTEL'),
'webhook_secret' => milieu('UNIPILE_WEBHOOK_SECRET'),
],
];Een dunne servicelaag over de Http-facade
naamruimte App\Services;
gebruik Illuminate\Support\Facades\Http;
klasse WhatsappService
{
beschermd functie klant()
{
return Http::basisUrl(configuratie('services.unipile.base_uri'))
->metKopteksten(['X-API-KEY' => configuratie('services.unipile.api_key')]);
}
openbaar functie sendMessage(snaar $chatId, snaar $text): reeks
{
return $dit->klant()
->alsMultipart()
->post(""/api/v1/chats/{$chatId}/messages"", [
['naam' => "tekst, 'Inhoud' => $text],
])
->json();
}
}3. Route- en webhookcontroller
Route::post('/webhooks/whatsapp', [WhatsappWebhookController::klasse, 'handvat']);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. Een in de wachtrij geplaatste taak, zodat de webhook-route snel blijft
klasse WhatsAppBerichtVerwerken implementeert MoetInDeWachtrij
{
gebruik Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
openbaar functie __construct(openbaar reeks $payload) {}
openbaar functie hendel(): nietig
{
// zoek de huurder op aan de hand van $this->payload['account_id'],
// sla het bericht op, verwittig de juiste gebruiker
}
}De route raakt Guzzle nooit direct, het gaat via
Bouw het in Laravel WhatsappService, waardoor de WhatsApp-gesprekken in tests kunnen worden gemockt op dezelfde manier als elke andere Laravel HTTP-integratie. Zie Documentatie over de HTTP-client van Laravel voor het femelen van deze verzoeken in je testsuite.Productie
Hoe beheer je WhatsApp-groepen vanuit PHP?
Het beheren van een WhatsApp-groep vanuit PHP is een enkel
PATCH oproep naar het chat-eindpunt met een actie veld deelnemerToevoegen, deelnemerVerwijderenof uitnodigingslinkOphalen. De eigen Cloud API-groepsfunctie van Meta limiteert een groep tot 8 deelnemers en onthult geen eindpunt om direct iemand toe te voegen, alleen een uitnodigingslink om te delen.Voeg een deelnemer toe
$client->patch(""/api/v1/chats/{$groupChatId}"", [
'json' => [
'actie' => 'deelnemerToevoegen',
'waarde' => '33612345678@s.whatsapp.net',
],
]);Vraag de uitnodigingslink op
$res = $client->patch(""/api/v1/chats/{$groupChatId}"", [
'json' => ['action' => 'getInviteLink'],
]);
$link = json_decode($res->getBody()->Inhoud ophalen(), true)['uitnodigingslink'];deelnemerVerwijderen neemt dezelfde vorm aan als deelnemerToevoegen, met het WhatsApp-id van de deelnemer in waarde. Dit is de enige actie die Meta's eigen Groups API helemaal niet blootstelt; het toevoegen van iemand gebeurt alleen via de uitnodigingslink aan hun kant. Voor elke limiet, het plafond van 10.000 groepen per nummer en wat nog steeds niet wordt ondersteund, zie de WhatsApp Groeps-API referentie.Schaal
Hoe beheer je vele gebruikersaccounts vanuit één PHP-applicatie?
Een PHP SaaS-product heeft niet één WhatsApp-account, maar één per klant. Er is één Unipile
X-API-KEY voor uw hele toepassing, maar een duidelijke account_id voor elke eindgebruiker die zijn WhatsApp koppelt. Het patroon is om dat op te slaan account_id naast je eigen tenant-rij, en geef deze expliciet mee bij elke aanroep die anders over accounts heen zou kunnen gaan.// Binnen de webhook-handler: zoek op van welke tenant dit
// bericht hoort bij voordat er iets mee wordt gedaan.
$stmt = $pdo->voorbereiden('SELECT id FROM tenants WHERE unipile_account_id = ?');
$stmt->uitvoeren([$payload['account_id']]);
$tenantId = $stmt->kolomOphalen();
als ($tenantId === vals) {
// onbekend account_id, weiger in plaats van de tenant te raden
http_response_code(404);
uitgang;
}
// Uitgaand: geef account_id door zodat een verouderde of hergebruikte chat_id
// stuur nooit het WhatsApp-nummer van de verkeerde huurder mee.
$client->post(""/api/v1/chats/{$chatId}/messages"", [
'multipart' => [
['naam' => "tekst, 'Inhoud' => $text],
['naam' => 'account_id', 'Inhoud' => [$expectedAccountId],
],
]);Het optionele
account_id veld op het berichten-eindpunt bestaat specifiek om te voorkomen dat er wordt verzonden naar een chat buiten dat account, beschouw het als verplicht in een multi-tenant codabasis, ook al vereist de API dit niet. Versleutel de opgeslagen account_id waarden in rust zoals elke andere klantinloggegevens: ze zijn op zichzelf niet geheim, maar ze zijn de koppelingssleutel tussen je gebuikerstabel en iemands echte WhatsApp-gesprekken.Valkuilen
Wat zijn de meest voorkomende PHP-specifieke fouten?
De meeste WhatsApp API-bugs in een PHP-codebase komen door PHP zelf, niet door de API. Deze vijf duiken voortdurend op in productie-integraties.
Een bericht afkorten met substr() in plaats van mb_substr()
PHP's
substr() telt bytes, niet tekens. Een emoji is een UTF-8-reeks van meerdere bytes, knip hem door de midden en je stuurt een kapot teken of ongeldige JSON. Gebruik altijd de functies voor meerdere bytes bij door gebruikers gegenereerde WhatsApp-tekst.$safe = mb_substr($text, 0, 4096, 'UTF-8');cURL-fout 60 op Windows en XAMPP
"SSL-certificaatprobleem: kan geen lokaal uitgeverscertificaat verkrijgen. Windows PHP-builds en XAMPP worden vaak geleverd zonder een actieve CA-bundel gekoppeld in php.ini, waardoor HTTPS-aanroepen van Guzzle mislukken, zelfs als de code correct is.
curl.cainfo = "C:\php\extras\cacert.pem"
openssl.cafile = "C:\php\extras\cacert.pem"max_execution_time beëindigt de webhook voordat deze antwoordt
Een standaardinstelling van 30 seconden is meer dan genoeg totdat de handler een trage uitgaande oproep doet voordat deze reageert. Als Unipile geen snel antwoord krijgt, probeert het opnieuw en begint een trage handler dezelfde bericht twee keer te verwerken. Reageer eerst, werk daarna, zoals weergegeven in de webhook-sectie hierboven.
Geen backoff bij 429- of 5xx-responsen
Een strakke
terwijl Een lus die bij een mislukking onmiddellijk opnieuw probeert, verandert één rate limit in een door jezelf veroorzaakte storing. Wacht, en verhoog de wachttijd bij elke opeenvolgende mislukking.voor ($poging = 1; $poging <= 5; $attempt++) {
proberen {
return $client->post($uri, $options);
} vangst (ConnectException | ServerException $e) {
usleep((2 ** $attempt) * 100_000); // 0,2s, 0,4s, 0,8s...
}
}Het ruwe antwoord loggen en dat debugging noemen
Als je handmatig een JSON-body opbouwt in plaats van Guzzle's
json optie afhandelen, toevoegen JSON_UNESCAPED_UNICODE naar json_encode(). Zonder dit verschijnen emoji's en namen met accenten als escaped. \u sequenties in je logboeken, wat technisch gezien geldige JSON is, maar onleesbaar is wanneer je een echt gesprek probeert te debuggen.Kosten
Wat kost het om WhatsApp-berichten te verzenden vanuit PHP?
Niets in de PHP-code wijzigt de prijs. Meta factureert per bericht sinds 1 juli 2025, niet per conversatie. Het enige dat je code aanstuurt is timing: een antwoord dat binnen het servicevenster van 24 uur na het bericht van een gebruiker wordt verzonden is nog steeds gratis, dezelfde oproep die een uur later wordt verzonden is factureerbaar.
Hulpprogramma- en authenticatiesjablonen blijf gratis binnen een open serviceterven, gefactureerd daarbuiten.
Marketingtemplates worden gefactureerd ongeacht het venster.
Tarieven per bericht variëren per land van de ontvanger en berichtcategorie, niet per client-bibliotheek waarmee je ze verzendt.
Voor huidige WhatsApp-prijs per bericht bekijk het volledige prijsoverzicht per land en categorie.
WhatsApp API met PHP - FAQ
Duidelijke antwoorden over verbinden, verzenden, Laravel en de verouderde PHP SDK.
Maak een Guzzle-client aan die naar de Unipile REST API wijst, roep
POST /api/v1/accounts met provider WHATSAPP om een QR-code of koppelingscode te verkrijgen, laat de gebruiker dit op zijn telefoon voltooien en gebruik vervolgens dezelfde cliënt voor GET, POST en PATCH oproepen om berichten te verzenden, chats te vermelden en groepen te beheren. Er is geen PHP-specifiek eindpunt, elke aanroep is een normaal HTTP-verzoek met een X-API-KEY koptekst. De een WhatsApp-account koppelen Sectie hierboven behandelt de exacte code.Ja. Een enkele
POST naar /api/v1/chats/{chat_id}/berichten with a text veld in een multipart-lichaam verz 브랜드et het bericht en retourneert een bericht-id, zie de verzend sectie hierboven voor de exacte Guzzle-aanroep.Alleen als je rechtstreeks via Meta's Cloud API gaat of via een Business Solution Provider die daarop is gebouwd. Het koppelen van een WhatsApp-account via Unipile verbindt het bestaande WhatsApp-nummer van de gebruiker via een QR-code of koppelingscode en vereist helemaal geen Meta Business-verificatie.
Geen actief onderhouden. Een communitypakket,
unipile/unipile-php-sdk, staat op Packagist maar is gemarkeerd verlaten, met geen enkele commit sinds 17 oktober 2023 en 5 sterren op GitHub. Elk voorbeeld in deze gids roept in plaats daarvan rechtstreeks de REST API aan via Guzzle, wat ook is wat de verlaten SDK intern deed.Je kunt geen webhooks ontvangen zonder een publiekelijk bereikbare HTTPS-URL, zo werken HTTP-callbacks namelijk. Tijdens lokale ontwikkeling kun je een lokale poort tunnelen met een dienst zoals ngrok en deze koppelen aan de webhook-
verzoek_url op het HTTPS-adres van de tunnel. Berichten-eindpunt opvragen is het alternatief wanneer een openbaar eindpunt echt onmogelijk is, ten koste van latentie en extra verzoeken.Ja, er is niets aan dat specifiek is voor een framework. De Laravel-sectie hierboven verpakt dezelfde Guzzle-equivalente aanroepen in de
http facade, een in de wachtrij geplaatste taak (queued job), en een webhook-route en -controller, wat de idiomatiche manier is om dit te structureren in een Laravel-codebase.Ja, dat is de normale SaaS-vorm. Eén Unipile API-sleutel dekt de hele toepassing, terwijl elke eindgebruiker zijn of haar eigen sleutel krijgt
account_id na het verbinden van hun WhatsApp. Sla dat ID op bij uw tenant-record en geef dit door bij uitgaande oproepen om cross-tenant verzendingen te voorkomen, zie de multitenantgedeelte boven.PATCH /api/v1/chats/{chat_id} met {"action": "addParticipant", "value": "@s.whatsapp.net"}. Meta's eigen Cloud API-groppenfunctie heeft geen equivalent eindpunt, alleen een uitnodigingslink, wat een van de duidelijkere verschillen is tussen rechtstreeks bouwen op Meta en via Unipile gaan. Details in de groepen sectie boven.Bijna altijd omdat een string werd afgekapt met
substr() in plaats van mb_substr(). De standaard stringfuncties van PHP tellen bytes, en een emoji is een UTF-8-reeks van meerdere bytes. Als deze doormidden wordt geknipt, verandert deze in een ongeldig teken of wordt de JSON-payload volledig onbruikbaar.Guzzle is voldoende, het is een HTTP-client gebouwd bovenop PHP's cURL-extensie, geen vervanging ervoor. Elk verzoek in deze handleiding gebruikt Guzzle; een rauwe
curl_init() call werkt identiek als een project de afhankelijkheid niet kan toevoegen, de JSON- en multipart-bodies zijn in beide gevallen hetzelfde.Hetzelfden als het op elke andere manier verzenden. Meta factureert per bericht sinds 1 juli 2025 op basis van categorie en het land van de ontvanger, niet op basis van de clientbibliotheek die wordt gebruikt om de API aan te roepen. Zie de kostenoverzicht boven en de volledige prijzenlijst voor de actuele tarieven.
Ja, het verdwijnt niet, het bepaalt alleen wat gratis is in plaats van wat technisch is toegestaan. Een antwoord binnen het venster van 24 uur na het laatste bericht van een gebruiker wordt verzonden zonder dat het als sjabloonbericht wordt gefactureerd; PHP-code die het venster negeert, betaalt simpelweg voor berichten die dat niet hadden gehoeven.
Heb je nog vragen over het bouwen hiervan in PHP? Ons team staat klaar om te helpen.
WhatsApp API PHP Gids
Klaar om de WhatsApp API in je PHP-applicatie te bouwen?
Elk eindpunt in deze gids, connect, send, receive, groups, werkt op hetzelfde Unipile-account dat je nu kunt aanmaken. Geen Meta Business-verificatie, geen verouderde SDK, gewoon
Gulzig schrokken en een REST-API die je PHP-applicatie al weet aan te roepen.Automatiseren in plaats van integreren in een bestaande app? Lees dezelfde integratie in Python.
NL 
EN 
FR 
ES 
DE 
IT 
BR 
PL 
TR