LinkedIn
Instagram
Telegramma
Calendario di Google
Partecipare alla comunità Slack Indice dei contenuti
Fondamentali
Connetti e invia
Produzione
Guida API WhatsApp PHP
API di WhatsApp con PHPLa Guida di Integrazione Completa
Chiamate Guzzle e cURL per connettere un account WhatsApp, inviare e ricevere messaggi, gestire gruppi e eseguire il tutto all'interno di un Laravel applicazione, senza registrare un'applicazione Meta Business. Questa è la API di WhatsApp in PHP end-to-end: connessione, webhook, SaaS multi-tenant e il costo reale per messaggio.
Nessuna verifica Meta Business
Guzzle & cURL, nessun SDK abbandonato
connect-whatsapp.php 
usare GuzzleHttp\Client;
$client = new Cliente([
'base_uri' => 'https://api1.unipile.com:13111',
'headers' => ['X-API-KEY' => $apiKey],
]);
// Provider WHATSAPP: nessuna app Meta, nessuna WABA
$res = $client->posta('/api/v1/accounts', [
'json' => ['provider' => 'WHATSAPP'],
]);201 Creato, account_id restituito
Stesso schema per 
Definizione
Cos'è l'API di WhatsApp in PHP?
Il API di WhatsApp in PHP è la pratica di chiamare un'API REST di WhatsApp da un runtime PHP, PHP-FPM, uno script CLI o un queue worker, utilizzando un client HTTP come Guzzle o cURL. Non esiste un'API di WhatsApp creata specificamente per PHP: Meta e i fornitori di API espongono JSON semplice tramite HTTPS, e PHP è semplicemente il linguaggio che effettua la richiesta, nello stesso modo in cui chiamerebbe qualsiasi altra API web.
In pratica, un'integrazione PHP delle API di WhatsApp è una normale chiamata HTTP: un metodo, un URL, un corpo JSON o multipart e un
CHIAVE X-API header. Niente qui dipende da una funzionalità o da un endpoint esclusivi di PHP. Ciò che cambia tra Cloud API, un Business Solution Provider (BSP) e un account collegato non è il linguaggio, ma chi possiede il numero di WhatsApp e se la verifica di Meta Business si trova tra voi e il vostro primo messaggio. Per l'analisi completa di quell'ecosistema, consultate il Guida all'integrazione delle API di WhatsApp.JSON semplice su HTTPS
Ogni chiamata è un ciclo di richiesta/risposta che Guzzle o cURL sanno già come effettuare.
L'autenticazione è un'intestazione statica
Un
CHIAVE X-API valore, niente balletto OAuth, nessun ciclo di aggiornamento dei token da scrivere.Indipendente dal runtime
Funziona allo stesso modo in PHP-FPM, in un comando della console di Symfony o in un job di coda di Laravel.
Decisione
Quale API di WhatsApp dovresti usare da PHP?
Ci sono tre modi per chiamare WhatsApp da un backend PHP: API Cloud di Meta direttamente, un Fornitore di Soluzioni Aziendali rivendendone l'accesso, o un account collegato tramite un'API unificata come Unipile. Tutte e tre restituiscono JSON che il vostro codice PHP elabora nello stesso modo, ciò che cambia è il tempo di configurazione, se la verifica Meta Business si frappone al vostro primo messaggio e se ottenete una cronologia delle conversazioni esistente o partite da zero.
Criteri
API Cloud (diretta)
BSP
Account collegato
Verifica aziendale di Meta
Richiesto
Richiesto
Non richiesto
Tempo al primo messaggio
Da giorni a poche settimane
Onboarding più rapido, stessi requisiti di base
Verbale
Numero di telefono
Nuovo numero registrato a un WABA
Nuovo numero fornito dal BSP
Il numero WhatsApp esistente dell'utente
Accesso alle conversazioni esistenti
No, inizia vuoto
No, inizia vuoto
Sì, cronologia completa
Migliore aderenza
Un numero aziendale che trasmette a molti clienti
Lo stesso, con un livello di onboarding gestito
Un prodotto in cui ogni utente collega il proprio account WhatsApp esistente
Se la tua applicazione PHP è un prodotto SaaS in cui ogni cliente collega il proprio WhatsApp, un account collegato elimina completamente il passaggio di verifica di Meta. Se stai inviando messaggi broadcast da un singolo numero aziendale, la Cloud API o un BSP sono invece il punto di partenza corretto.
Crea con un account collegato Impostazione
Di cosa hai bisogno prima di scrivere qualsiasi codice PHP?
È necessario PHP 8.1 o superiore, Compositore, il Guzzle Client HTTP e una chiave API di Unipile. Al momento non esiste un SDK PHP attivamente mantenuto per Unipile, quindi ogni esempio in questa guida si interfaccia con
/api/v1 API REST direttamente.PHP 8.1+
Le proprietà tipizzate e gli argomenti nominati mantengono il codice client corto.
Compositore
Gestore delle dipendenze standard, necessario per includere Guzzle.
Guzzle 7
Client HTTP per richieste JSON e multipart, con un fallback a cURL.
Chiave API Unipile
Inviato come
CHIAVE X-API su ogni richiesta, generata dalla tua dashboard.composer require guzzlehttp/guzzle:^7.0Esiste un SDK PHP? Non uno che si debba installare.
Un pacchetto della community,
unipile/unipile-php-sdk, esiste su Packagist, ma è elencato come abbandonato: nessun commit dal 17 ottobre 2023, 5 stelle su GitHub e punta a una vecchia URL di base delle API. Non eseguire composer require unipile/unipile-php-sdk. L'SDK di Node.js (unipile-node-sdk) è ufficialmente mantenuto e aggiornato, ma per PHP, Guzzle direttamente contro le API REST è la strada affidabile ed è ciò che ogni esempio sottostante utilizza. Vedi La documentazione di Guzzle per le opzioni del client utilizzate qui.Implementazione
Come si collega un account WhatsApp da PHP?
La connessione di un account WhatsApp da PHP richiede un
POSTA richiesta con il provider impostato su WHATSAPP, quindi un'azione dell'utente: l'utente finale scansiona il codice QR restituito da WhatsApp > Dispositivi collegati, o digita un codice di abbinamento sul proprio telefono se ne avete richiesto uno in alternativa. Nessuna app per sviluppatori Meta, nessun WABA, nessuna fase di verifica.1
Richiedi un checkpoint, codice QR di default
Chiama l'endpoint dei conti con solo
provider set. Unipile restituisce un account_id inoltre un payload di controllo creato per il flusso QR.$response = $client->posta('/api/v1/accounts', [
'json' => ['provider' => 'WHATSAPP'],
]);
$payload = json_decode($response->ottieniCorpo()->ottieniContenuti(), true);
$accountId = $payload['ID account'];
// Il payload $ contiene anche il checkpoint da visualizzare nel
il codice QR da scansionare da WhatsApp > Collegati
// dispositivi. var_dump($payload) ancora una volta con la tua chiave
// per vedere la forma esatta prima di collegare il frontend.2
O richiedi invece un codice di abbinamento
Passare
abbinamento_numero_di_telefono in cifre E.164, senza segno più, quando la scansione di un codice QR non è pratica, ad esempio un agente dell'assistenza che registra un cliente per telefono.$response = $client->posta('/api/v1/accounts', [
'json' => [
'provider' => 'WHATSAPP',
'pairing_phone_number' => '33612345678',
],
]);
$payload = json_decode($response->ottieniCorpo()->ottieniContenuti(), true);
$accountId = $payload['ID account'];
// Il punto di controllo qui è il codice che la tua interfaccia utente mostra all'utente
// da digitare in WhatsApp > Dispositivi collegati > Collega con
// al suo posto un numero di telefono.3
Esegui il polling finché l'account non è completamente collegato
Il conto rimane in
COLLEGAMENTO resta in attesa finché il codice QR non viene scansionato o il codice di abbinamento non viene inserito. Controlla sources[0].status sul conto.$response = $client->ottenere(""/api/v1/accounts/{$accountId}"");
$account = json_decode($response->ottieniCorpo()->ottieniContenuti(), true);
$status = $account['fonti'][0]['stato'] ?? nullo;
se ($status === 'OK') {
// è sicuro inviare, ricevere ed elencare le chat su $accountId
}Il polling in un ciclo funziona ma spreca richieste. Se la tua applicazione PHP ha già un endpoint webhook, registratene uno con
stato_account" invece e agisci nel momento in cui lo stato passa a OK. La configurazione del webhook in sé è trattata più avanti per i messaggi in arrivo; lo stesso endpoint accetta gli eventi sullo stato dell'account.Flusso principale
Come si invia un messaggio WhatsApp con PHP e Guzzle?
L'invio di un messaggio da PHP è uno
POSTA all'endpoint dei messaggi della chat con un text campo in un corpo multipart. La chiamata restituisce un id_messaggio nel momento in cui WhatsApp lo accetta.$response = $client->posta(""/api/v1/chats/{$chatId}/messages"", [
'multipart' => [
['nome' => 'testo', 'contenuti' => 'Ciao! Il tuo ordine è stato spedito.'],
],
]);
$result = json_decode($response->ottieniCorpo()->ottieniContenuti(), true);
$messageId = $result['id_messaggio'];Lo stesso
multipartito anche l'array trasporta allegati, a messaggio_vocale file, o un ID citazione per rispondere a un messaggio specifico, Guzzle li allega come campi multipart aggiuntivi accanto a text. Per l'analisi completa di ogni tipi di messaggi supportati dall'API di WhatsApp, inclusi i modelli e la finestra di servizio di 24 ore, consultate la nostra guida dedicata.Flusso principale
Come si avvia una nuova conversazione da PHP?
Avviare una conversazione che non esiste ancora significa chiamare l'endpoint delle chat con un
account_id e un attendees_ids array invece di uno esistente chat_id. Unipile crea la chat e, se includi un text campo, invia il primo messaggio nella stessa chiamata.$response = $client->posta('/api/v1/chats', [
'multipart' => [
['nome' => 'ID account', 'contenuti' => [$accountId],
['nome' => 'attendees_ids[]', 'contenuti' => '33612345678@s.whatsapp.net'],
['nome' => 'testo', 'contenuti' => 'Salve, qui è il supporto di Acme.'],
],
]);
$result = json_decode($response->ottieniCorpo()->ottieniContenuti(), true);
$chatId = $result['chat_id'];Il destinatario è identificato da
{phone_number}@s.whatsapp.net, cifre internazionali, nessun segno più iniziale, nessun spazio. Memorizzare il restituito chat_id accanto a quel record utente: ogni messaggio successivo al primo passa attraverso l'endpoint dei messaggi della sezione precedente, non attraverso questo.Flusso principale
Come si recuperano chat e messaggi in PHP?
La maggior parte dei tutorial sulle API di WhatsApp si ferma all'invio. Un backend PHP di solito deve anche elencare le conversazioni esistenti di un utente, scorrere la cronologia ed E vedere chi c'è in una chat. Tre endpoint coprono tutto ciò:
GET /api/v1/chats, GET /api/v1/chats/{chat_id}/messages, e GET /api/v1/chats/{chat_id}/attendees, tutte paginate con un cursore.Elenca tutte le chat di WhatsApp su un account
$response = $client->ottenere('/api/v1/chats', [
'query' => [
''account_id' => $accountId,
'account_type' => 'WHATSAPP',
'limit' => 50,
],
]);
$data = json_decode($response->ottieniCorpo()->ottieniContenuti(), true);
$chats = $data['oggetti'];
$nextCursor = $data['cursore'];Scorri la cronologia di una chat
$cursor = nullo;
$all = [];
fare {
$res = $client->ottenere(""/api/v1/chats/{$chatId}/messages"", [
'query' => array_filter(['cursore' => $cursor, 'limite' => 100]),
]);
$page = json_decode($res->ottieniCorpo()->ottieniContenuti(), true);
$all = array_merge($all, $page['oggetti']);
$cursor = $page['cursore'];
} mentre ($cursor !== nullo);Ogni endpoint di elenco segue lo stesso contratto di cursore: passa la risposta precedente
cursore entra, fermati quando torna nullo. Per vedere chi sta effettivamente partecipando a una conversazione, chiama GET /api/v1/chats/{chat_id}/attendees: restituisce quello di ciascun partecipante id, provider_id e nome visualizzato, che è ciò di cui hai bisogno prima di poter chiamare aggiungiPartecipante o rimuoviPartecipante su un gruppo più avanti in questa guida.Produzione
Come si ricevono i messaggi di WhatsApp con un webhook in PHP?
Un webhook di WhatsApp in PHP è un endpoint HTTPS pubblico che Unipile chiama con un payload JSON in occasione di eventi come
messaggio_ricevuto. Il tuo script legge il corpo grezzo, conferma che la chiamata è autentica, risponde rapidamente e affida il lavoro effettivo a una coda. Polling GET /api/v1/chats per i nuovi messaggi funziona per una demo, non per un prodotto con più di una manciata di utenti.Registra il webhook, con un segreto condiviso in un'intestazione personalizzata
$client->posta('/api/v1/webhooks', [
'json' => [
'source' => 'messaggistica',
'request_url' => 'https://example.com/webhooks/whatsapp',
'events' => ['messaggio ricevuto'],
'headers' => [
['chiave' => 'X-Webhook-Secret', 'valore' => [$webhookSecret],
],
],
]);2. Verifica, rispondi, quindi elabora
$rawBody = file_get_contents('php://input');
$provided = $_SERVER['HTTP_X_WEBHOOK_SECRET'] ?? '';
se (!hash_equals($expectedSecret, $provided)) {
codice_risposta_http(401);
esci;
}
codice_risposta_http(200);
se (function_exists('fastcgi_finish_request')) {
fastcgi_finish_request();
}
$payload = json_decode($rawBody, true);
se (($payload['evento'] ?? nullo) === 'messaggio ricevuto') {
// inserire il payload $ in una tabella di coda o in una lista Redis,
// non elaborare mai un webhook in linea
accoda_messaggio_whatsapp($payload);
}Unipile non firma il corpo del webhook con un segreto HMAC che ricalcoli, l'endpoint create-webhook espone un
intestazioni array invece. Allega il tuo segreto come intestazione personalizzata quando registri il webhook, quindi controllalo con hash_equals(), un confronto di stringhe sicuro rispetto ai tempi di esecuzione, prima di considerare affidabile il payload. Ogni campo in $payload, account_id, tipo_di_account, evento, chat_id, id_messaggio, message e sender.attendee_provider_id, corrisponde ai documenti JSON di Unipile per il webhook di messaggistica.Produzione
Come si integra l'API di WhatsApp in un'applicazione Laravel?
Laravel sostituisce tre cose dagli esempi in PHP semplice di cui sopra: il
Http una facade anziché un client Guzzle autoprodotto, un job in coda anziché un'elaborazione in linea e una rotta più un controller anziché il parsing php://input a mano. Le chiamate WhatsApp qui sotto sono identiche a ogni esempio già presente in questa guida.1. ConfigurazioneUna voce in services.php, valori da .env
return [
// ...servizi esistenti
'unipile' => [
'base_uri' => ambiente('UNIPILE_BASE_URI', 'https://api1.unipile.com:13111'),
'api_key' => ambiente('UNIPILE_API_KEY'),
'webhook_secret' => ambiente('UNIPILE_WEBHOOK_SECRET'),
],
];2. Una sottile classe di servizio sopra la facciata Http
spazio dei nomi App\Services;
usare Illuminate\Support\Facades\Http;
classe ServizioWhatsapp
{
protetto funzione client()
{
return Http::baseUrl(configurazione('services.unipile.base_uri'))
->conIntestazioni(['X-API-KEY' => configurazione('services.unipile.api_key')]);
}
pubblico funzione sendMessage(stringa $chatId, stringa $text): matrice
{
return $questo->client()
->comeMultipartuppet()
->posta(""/api/v1/chats/{$chatId}/messages"", [
['nome' => 'testo', 'contenuti' => [$text],
])
->json();
}
}3. Controller per rotte e webhook
Percorso::posta('/webhooks/whatsapp', [WhatsappWebhookController::classe, 'gestire']);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. Un job in coda, in modo che la rotta del webhook rimanga veloce
classe ElaboraMessaggioWhatsapp implementa ShouldQueue
{
usare Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
pubblico funzione __construct(pubblico matrice $payload) {}
pubblico funzione maniglia(): vuoto
{
// cerca l'inquilino in base a $this->payload['account_id'],
memorizza il messaggio, avvisa l'utente giusto
}
}La rotta non tocca mai direttamente Guzzle, passa attraverso
Costruiscilo in Laravel ServizioWhatsapp, il che rende le chiamate WhatsApp simulabili nei test allo stesso modo di qualsiasi altra integrazione HTTP di Laravel. Vedi Documentazione del client HTTP di Laravel per falsificare queste richieste nella tua suite di test.Produzione
Come gestisci i gruppi di WhatsApp da PHP?
Gestire un gruppo WhatsApp da PHP è un singolo
PATCH chiamata all'endpoint di chat con un azione campo aggiungiPartecipante, rimuoviPartecipante, o ottieniLinkInvito. La funzione gruppi della Cloud API di Meta limita un gruppo a 8 partecipanti e non espone alcun endpoint per aggiungere qualcuno direttamente, ma solo un link di invito da condividere.Aggiungi un partecipante
$client->patch(""/api/v1/chats/{$groupChatId}"", [
'json' => [
'action' => 'aggiungiPartecipante',
'value' => '33612345678@s.whatsapp.net',
],
]);Ottieni il link d'invito
$res = $client->patch(""/api/v1/chats/{$groupChatId}"", [
'json' => ['action' => 'ottieniLinkInvito'],
]);
$link = json_decode($res->ottieniCorpo()->ottieniContenuti(), true)['link di invito'];rimuoviPartecipante prende la stessa forma di aggiungiPartecipante, con l'ID WhatsApp del partecipante in valore. Questa è l'unica azione che l'API Groups di Meta non espone affatto, l'aggiunta di qualcuno avviene solo tramite il link di invito da parte sua. Per ogni limite, il tetto di 10.000 gruppi per numero e ciò che non è ancora supportato, vedere il API per gruppi WhatsApp riferimento.Scala
Come gestisci molti account utente da una singola applicazione PHP?
Un prodotto SaaS in PHP non ha un account WhatsApp, ne ha uno per cliente. C'è un singolo Unipile
CHIAVE X-API per l'intera applicazione, ma un distinto account_id per ogni utente finale che collega il suo WhatsApp. Il modello prevede di memorizzare tale account_id accanto alla riga del tuo tenant, e passalo esplicitamente a ogni chiamata che altrimenti potrebbe attraversare gli account.// All'interno del gestore del webhook: trova a quale tenant appartiene
// il messaggio appartiene a prima di fare qualsiasi cosa con esso.
$stmt = $pdo->prepara('SELECT id FROM tenants WHERE unipile_account_id = ?');
$stmt->eseguire([$payload['ID account']]);
$tenantId = $stmt->recuperaColonna();
se ($tenantId === falso) {
// account_id sconosciuto, rifiuta anziché indovinare il tenant
codice_risposta_http(404);
esci;
}
// In uscita: passa account_id in modo che un chat_id obsoleto o riutilizzato possa
// non inviare mai tramite il numero WhatsApp del tenant sbagliato.
$client->posta(""/api/v1/chats/{$chatId}/messages"", [
'multipart' => [
['nome' => 'testo', 'contenuti' => [$text],
['nome' => 'ID account', 'contenuti' => [$expectedAccountId],
],
]);L'opzionale
account_id il campo sull'endpoint dei messaggi esiste specificamente per impedire l'invio in una chat al di fuori di quell'account, trattalo come obbligatorio in una codebase multi-tenant anche se l'API non lo richiede. Cifra il memorizzato account_id valori a riposo come qualsiasi altra credenziale cliente: non sono segreti di per sé, ma sono la chiave di join tra la tabella dei vostri utenti e le vere conversazioni WhatsApp di qualcuno.Insidie
Quali sono gli errori più comuni specifici di PHP?
La maggior parte dei bug delle API di WhatsApp in una codebase PHP proviene da PHP stesso, non dalle API. Questi cinque si ripresentano continuamente nelle integrazioni in produzione.
Troncare un messaggio con substr() anziché mb_substr()
di PHP
sotto_stringa() conta i byte, non i caratteri. Un'emoji è una sequenza UTF-8 multi-byte, tagliala a metà e invierai un carattere corrotto o un JSON non valido. Usa sempre le funzioni multi-byte sul testo WhatsApp generato dall'utente.$safe = mb_substr($text, 0, 4096, 'UTF-8');Errore cURL 60 su Windows e XAMPP
"Problema del certificato SSL: impossibile ottenere il certificato dell'emissario locale. Le build di Windows PHP e XAMPP spesso vengono distribuite senza un bundle CA corrente configurato in php.ini, quindi le chiamate HTTPS di Guzzle falliscono anche se il codice è corretto.
curl.cainfo = "C:\php\extras\cacert.pem"
openssl.cafile = "C:\php\extras\cacert.pem"max_execution_time sta interrompendo il webhook prima che risponda
Un valore predefinito di 30 secondi è più che sufficiente finché l'handler non effettua una chiamata in uscita lenta prima di rispondere. Se Unipile non riceve una risposta rapida, effettua un nuovo tentativo e un handler lento inizia a elaborare lo stesso messaggio due volte. Rispondi prima, elabora dopo, come mostrato nella sezione webhook sopra.
Nessun backoff in caso di risposte 429 o 5xx
Stretto
mentre un ciclo che riprova immediatamente in caso di fallimento trasforma un limite di frequenza in un'interruzione auto-inflitta. Aspetta, e aumenta l'attesa a ogni fallimento consecutivo.per ($attempt = 1; $attempt <= 5; $attempt++) {
tentare {
return $client->posta($uri, $options);
} cattura (ConnectException | ServerException $e) {
usleep((2 ** $attempt) * 100_000); // 0,2s, 0,4s, 0,8s...
}
}Registrare la risposta grezza e chiamarla debug
Se costruisci un corpo JSON a mano invece di lasciare che quello di Guzzle
json opzione gestiscilo, aggiungi JSON_UNESCAPED_UNICODE a json_encode(). Senza di esso, le emoji e i nomi accentati vengono visualizzati come codificati \u sequenze nei tuoi log, che è JSON tecnicamente valido ma illeggibile quando stai cercando di debugnare una conversazione reale.Costo
Quanto costa inviare messaggi WhatsApp da PHP?
Niente nel codice PHP modifica il prezzo. Meta fattura a messaggio dal 1° luglio 2025, non per conversazione. L'unica cosa che il tuo codice controlla è la tempistica: una risposta inviata entro la finestra di servizio di 24 ore dal messaggio di un utente è ancora gratuita, la stessa identica chiamata inviata un'ora dopo è a pagamento.
Modelli di utilità e autenticazione rimani gratuito all'interno di una finestra di servizio aperta, fatturato al di fuori di essa.
Modelli di marketing vengono fatturati indipendentemente dalla finestra.
Le tariffe per messaggio variano in base al paese del destinatario e alla categoria del messaggio, non in base alla libreria client con cui vengono inviati.
Aggiungi un timestamp a ogni messaggio in entrata ricevuto dal tuo webhook PHP e mantieni un valore "finestra aperta fino a" per ciascuna conversazione; questo è l'unico input di cui la tua logica di fatturazione ha effettivamente bisogno. Per quanto riguarda prezzaggio WhatsApp per messaggio per paese e categoria, vedi il dettaglio completo dei prezzi.
API di WhatsApp con PHP - Domande Frequenti
Risposte chiare su connessione, invio, Laravel e il PHP SDK abbandonato.
Crea un client Guzzle puntato all'API REST di Unipile, chiama
POST /api/v1/accounts con il fornitore WHATSAPP per ottenere un codice QR o un codice di associazione, fai completare l'operazione all'utente sul proprio telefono, quindi usa lo stesso client per GET, POSTA e PATCH chiamate per inviare messaggi, elencare chat e gestire gruppi. Non esiste un endpoint specifico per PHP, ogni chiamata è una normale richiesta HTTP con un CHIAVE X-API intestazione. Il collega un account WhatsApp la sezione precedente analizza il codice esatto.Sì. Uno solo
POSTA a /api/v1/chat/{chat_id}/messaggi with a text campo in un corpo multipart invia il messaggio e restituisce un id_messaggio, vedi la invia sezione sopra per la chiamata Guzzle esatta.Solo se passi direttamente attraverso la Cloud API di Meta o un Business Solution Provider basato su di essa. Il collegamento di un account WhatsApp tramite Unipile collega il numero WhatsApp esistente dell'utente tramite codice QR o codice di associazione e non richiede alcuna verifica aziendale da parte di Meta.
Nessuno attivamente mantenuto. Un pacchetto della community,
unipile/unipile-php-sdk, è su Packagist ma contrassegnato abbandonato, senza alcun commit dal 17 ottobre 2023 e con 5 stelle su GitHub. Ogni esempio di questa guida richiama invece direttamente l'API REST tramite Guzzle, che è anche ciò che l'SDK abbandonato faceva internamente.Non puoi ricevere webhook senza un URL HTTPS pubblicamente raggiungibile, è così che funzionano i callback HTTP. Durante lo sviluppo locale, crea un tunnel su una porta locale con un servizio come ngrok e punta il webhook
url_richiesta all'indirizzo HTTPS del tunnel. Interrogazione dell'endpoint dei messaggi è il ripiego quando un endpoint pubblico non è realmente possibile, al costo di latenza e richieste extra.Sì, nulla di tutto ciò è specifico per un framework. Il Sezione Laravel qui sopra racchiude le stesse chiamate equivalenti a Guzzle nel
Http facade, un job in coda e una rotta con relativo controller per webhook, qual è il modo idiomatico di strutturarli in una codebase Laravel.Sì, questa è la tipica struttura SaaS. Una singola chiave API di Unipile copre l'intera applicazione, mentre ogni utente finale ottiene la propria
account_id dopo aver connesso il loro WhatsApp. Memorizza quell'id accanto al record del tuo tenant e trasmettilo nelle chiamate in uscita per prevenire invii tra tenant diversi, vedi il sezione multi-tenant sopra.PATCH /api/v1/chats/{chat_id} con {"action": "addParticipant", "value": "@s.whatsapp.net"}. La funzionalità dei gruppi dell'API Cloud di Meta non ha un endpoint equivalente, solo un link di invito, che è una delle differenze più evidenti tra lo sviluppo diretto su Meta e l'utilizzo di Unipile. Dettagli nel sezione gruppi sopra.Quasi sempre perché una stringa è stata troncata con
sotto_stringa() invece di mb_substr(). Le normali funzioni per le stringhe di PHP contano i byte, e un'emoji è una sequenza UTF-8 multi-byte; se tagliata a metà, si trasforma in un carattere non valido o compromette interamente il payload JSON.Guzzle è sufficiente, è un client HTTP basato sull'estensione cURL di PHP, non un sostituto di essa. Ogni richiesta in questa guida utilizza Guzzle; un grezzo
curl_init() la chiamata funziona in modo identico se un progetto non può aggiungere la dipendenza, i corpi JSON e multipart sono gli stessi in entrambi i casi.Lo stesso che inviarlo in qualsiasi altro modo. Meta fattura per messaggio dal 1° luglio 2025 in base alla categoria e al paese del destinatario, non in base alla libreria client utilizzata per chiamare l'API. Vedi il sezione costi sopra e il guida completa ai prezzi per le tariffe correnti.
Sì, non sta scomparendo, determina solo cosa è gratuito anziché ciò che è tecnicamente consentito. Una risposta entro la finestra di 24 ore dall'ultimo messaggio dell'utente viene inviata senza essere fatturata come messaggio modello, il codice PHP che ignora la finestra paga semplicemente per messaggi di cui non aveva bisogno.
Hai ancora domande su come realizzarlo in PHP? Il nostro team è qui per aiutarti.
Guida API WhatsApp PHP
Pronto per integrare l'API di WhatsApp nella tua applicazione PHP?
Ogni endpoint di questa guida, connect, send, receive, groups, funziona sullo stesso account Unipile che puoi creare subito. Nessuna verifica Meta Business, nessun SDK abbandonato, solo
Guzzle e un'API REST che la tua applicazione PHP sa già come chiamare.Automatizzare anziché integrare in un'app esistente? Leggi la stessa integrazione in Python.
IT 
EN 
FR 
ES 
DE 
BR 
NL 
PL 
TR