Nu bouwen

WhatsApp API met Python: Berichten verzenden, ontvangen en automatiseren

WhatsApp API in PythonPython + WhatsApp API

WhatsApp API met PythonVerstuur, ontvang en automatiseer berichten

Alles wat je nodig hebt om de WhatsApp API in Python: welke bibliotheek je moet kiezen, hoe je een gekoppeld account verbindt met een QR-code, hoe je berichten verzendt en ontvangt met verzoekt en httpx, en hoe je een FastAPI-webhook configureert voor een bot of een AI-agent.
Bouw met Python Bekijk de API-referentie
REST API vandaag, geen Meta Business verificatie nodig
send_whatsapp.py
import requests BASE_URL = "https://{YOUR_DSN}/api/v1" HEADERS = {"X-API-KEY": "YOUR_ACCESS_TOKEN"} def send_whatsapp(chat_id: str, text: str) -> dict: response = requests.post( f"{BASE_URL}/chats/{chat_id}/messages", headers=HEADERS, data={"text": text}, ) response.raise_for_status() return response.json() send_whatsapp("9f9uio56sopa456s", "Hallo vanuit Python!")
200 OK, bericht verzonden
Definitie

Wat is de WhatsApp API in Python?

De WhatsApp API in Python betekent het aanroepen van WhatsApp Business-berichtgeving vanuit Python-code in plaats van te klikken via WhatsApp Web. Een Python-script of achtergrondservice verzendt een HTTP-verzoek, meestal met verzoekt of httpx, naar een REST-API die chats, berichten en webhooks ontsluit, hetzij direct via Meta's Cloud API of een verenigdeprovider zoals Unipile die WhatsApp naast LinkedIn, Instagram en Telegram verbindt achter één interface. Meta publiceert geen officiële all-in-one WhatsApp Python-SDK, wat de reden is waarom bijna elke Python-integratie in deze handleiding, en het meeste van wat je op de rest van het web zult vinden, rechtstreeks met de REST-endpoints communiceert.
Eén REST API voor WhatsApp, LinkedIn, Instagram en Telegram
Gekoppeld via een QR-code of koppelingscode, geen Meta Business-verificatie
verzoekt voor eenvoudige scripts, httpx voor asynchroon op schaal
Voor de oriëntatielaag, toegang, kosten en limieten, begin met de Gids voor WhatsApp API-toegang, kosten en limieten. Bouwen in PHP in plaats van Python?
Lees dezelfde integratie in PHP
Voordat je bouwt

Wat heb je nodig voordat je begint?

Je hebt geen Meta Business-account of goedkeuring van het WhatsApp Business Platform nodig om te beginnen met het verzenden en ontvangen van berichten vanuit Python. Je hebt een werkende Python-omgeving, een HTTP-client, een plek om webhooks te ontvangen en een Unipile-account nodig.
Python 3.9+
Komt overeen met de minimale versie die vereist is door de Unipile Python SDK zelf pydantic afhankelijkheid, en door moderne httpx en FastAPI-releases.
requests of httpx
pip installatieverzoeken voor synchrone oproepen, of pip install httpx als u van plan bent berichten gelijktijdig te versturen. Zie de verzoekt en httpx documentatie.
Een lokale tunnel
Een tool zoals ngrok of cloudflared om je FastAPI-webhookroute tijdens de ontwikkeling beschikbaar te maken op een openbare HTTPS-URL.
Toegangstoken en DSN
Beide komen uit het Unipile-dashboard. De DSN is de host die u aanroept, het toegangstoken gaat in de X-API-KEY header van elk verzoek.
Bouw je eerste WhatsApp-integratie
Vergelijking van bibliotheken

Welke Python-bibliotheek moet je gebruiken voor WhatsApp?

Er is geen enkel, voor de hand liggend antwoord, en de meeste blogposts over dit onderwerp promoten het pakket dat de auteur zelf onderhoudt. Hier is een feitelijke vergelijking van de vijf manieren waarop Python-ontwikkelaars tegenwoordig daadwerkelijk WhatsApp aanroepen, van browserautomatisering tot een verenigde provider, zodat je kunt kiezen op basis van wat elke optie daadwerkelijk doet, en niet op basis van marketing.
Bibliotheek / aanpak
Wat het daadwerkelijk oproept
Meta Bedrijfsverificatie
Onderhouden
Het beste voor
pywhatkit
Bestuurt WhatsApp Web in een browsertabblad (toetsenbordautomatisering), geen server-side API
N.T., geen API
Gemeenschap, sporadisch
Eenmalige scripts en demo's op een machine met een scherm, geen productie-verzending
whatsapp-cloud-api
Dunne Python-wrapper rond Meta's eigen WhatsApp Cloud API-eindpunten
Vereist
Community-wrapper
Teams die al zijn goedgekeurd op de Cloud API en een Pythonic client willen
whatsapp-api-client-python
Roept de green-api SaaS aan, die op zijn beurt de WhatsApp-sessie vasthoudt
Niet vereist
Door leverancier onderhouden
Teams die zich comfortabel voelen bij het vertrouwen op een tweede, enkelvoudige SaaS-leverancier
verzoeken, rechtstreeks naar Meta
Meta's Cloud API-endpoints, helemaal geen wrapper
Vereist
Je maakt het zelf (DIY)
Teams die al zijn goedgekeurd voor Meta Business-verificatie en volledige controle willen
Unipile, requests of httpx
De verenigde berichten-API van Unipile, WhatsApp samen met LinkedIn, Instagram en Telegram
Niet vereist
Actief onderhouden, Python SDK in bèta
SaaS-producten die namens elke gebruiker meerdere WhatsApp-accounts van eindgebruikers verbinden
pywhatkit
OproepenBestuurt WhatsApp Web in een browsertabblad, geen server-side API
Meta-verificatieN.T., geen API
OnderhoudenGemeenschap, sporadisch
Het beste voorEenmalige scripts en demo's, niet voor productieomgevingen
whatsapp-cloud-api
OproepenDunne wrapper rond Meta's eigen Cloud API-eindpunten
Meta-verificatieVereist
OnderhoudenCommunity-wrapper
Het beste voorTeams zijn al goedgekeurd op de Cloud API
whatsapp-api-client-python
OproepenDe green-api SaaS, die de WhatsApp-sessie vasthoudt
Meta-verificatieNiet vereist
OnderhoudenDoor leverancier onderhouden
Het beste voorTeams die comfortabel zijn met een tweede SaaS-leverancier
verzoeken, rechtstreeks naar Meta
OproepenMeta's Cloud API-eindpunten, geen wrapper
Meta-verificatieVereist
OnderhoudenJe maakt het zelf (DIY)
Het beste voorTeams al goedgekeurd voor Meta Business-verificatie
Unipile, requests of httpx
OproepenVerenigde berichten-API, WhatsApp met LinkedIn, Instagram, Telegram
Meta-verificatieNiet vereist
OnderhoudenActief onderhouden, Python SDK in bèta
Het beste voorSaaS-producten die vele eindgebruikersaccounts verbinden
Elke optie die houdt Meta Bedrijfsverificatie vereist uiteindelijk communiceert met Meta's eigen WhatsApp Cloud API (zie Documentatie van Meta's WhatsApp Business-platform), wat de juiste keuze is als je al een geverifieerd bedrijfsnummer gebruikt. Als je in plaats daarvan WhatsApp-accounts verbindt namens vele verschillende eindgebruikers, verwijdert een QR-code- of koppelingscodeflow die verificatiestap volledig, wat het model is dat de rest van deze gids gebruikt.
Account verbinding

Hoe koppel je een WhatsApp-account in Python?

Elke aanroep in deze handleiding wordt uitgevoerd namens een geauthenticeerde gebruiker die hun eigen WhatsApp-account hebben gekoppeld. Er is geen Meta Business-verificatiestap: vanuit Python stuur je een enkele POST /api/v1/accounts aanvraag met provider instellen op WHATSAPP, en de gebruiker bevestigt de koppeling door het scannen van een QR-code of het invoeren van een koppelingscode op zijn telefoon.
Optie A: QR-code (standaard)
Vertrekken telefoonnummer_koppelen uit de aanvraagbody en Unipile retourneert een controlepunt met de QR-code-payload. Render deze met een bibliotheek zoals QR-code en geef deze weer zodat de gebruiker deze kan scannen vanuit WhatsApp > Gekoppelde apparaten.
connect_qr.py
import requests BASE_URL = "https://{YOUR_DSN}/api/v1" HEADERS = {"X-API-KEY": "YOUR_ACCESS_TOKEN", "accept": "application/json"} def connect_whatsapp_qr() -> dict: response = requests.post( f"{BASE_URL}/accounts", headers=HEADERS, json={"provider": "WHATSAPP"}, ) response.raise_for_status() return response.json() account = connect_whatsapp_qr() print(account) # account bevat een nieuwe account_id en een checkpoint-object. # Geef het checkpoint weer als een QR-code en laat de gebruiker deze scannen # via WhatsApp > Gekoppelde apparaten.
Optie B: koppelingscode
Pass telefoonnummer_koppelen in E.164-cijfers alleen, landcode eerst, geen plus teken, geen spaties. Unipile retourneert een controlepunt met een verificatiecode die de gebruiker in WhatsApp typt in plaats van iets te scannen, wat beter past bij een headless server zonder scherm om een QR-code op weer te geven.
connect_pairing_code.py
def connect_whatsapp_pairing_code(phone_e164_digits: str) -> dict: response = requests.post( f"{BASE_URL}/accounts", headers=HEADERS, json={ "provider": "WHATSAPP", "pairing_phone_number": phone_e164_digits, }, ) response.raise_for_status() return response.json() # Landcode + nummer, alleen cijfers, bijv. Frankrijk account = connect_whatsapp_pairing_code("33612345678") # Het checkpoint van het account bevat de koppelingscode die in je gebruikersinterface moet worden weergegeven. # De gebruiker voert deze in via WhatsApp > Gekoppelde apparaten > Koppelen met telefoonnummer.
Bevestig dat het account is verbonden
Zodra de gebruiker de QR-code scant of de koppelcode typet, moet u weten wanneer het account daadwerkelijk klaar is om te verzenden en te ontvangen. Unipile biedt u twee opties.
Vraag de accountstatus op
Roepen GET /api/v1/accounts/{account_id} elke paar seconden totdat het account geen controlepunt meer nodig heeft. Eenvoudig, maar het verspilt aanvragen terwijl je wacht.
Accountstatuswebhoc
Registreer een webhook bij bron instellen op account_status (hetzelfde POST /api/v1/webhooks eindpunt dat wordt gebruikt voor berichten) en Unipile pusht {"AccountStatus": {"account_id": "...", "message": "OK"}} het moment dat de account klaar is. Dit is wat de meeste productie-integraties gebruiken.
poll_status.py
import time def wait_for_connection(account_id: str, timeout_seconds: int = 120) -> dict: deadline = time.time() + timeout_seconds while time.time() < deadline: response = requests.get(f"{BASE_URL}/accounts/{account_id}", headers=HEADERS) response.raise_for_status() account = response.json() print(account) # bekijk de live payload voor je eigen statuscontrole time.sleep(2) raise TimeoutError("WhatsApp-account heeft de verbinding niet op tijd bevestigd")
Bouw de verbindingsstroom
Stuur

Hoe verstuur je een WhatsApp-bericht met Python?

Het verzenden van een WhatsApp-bericht vanuit Python is één enkele HTTP-aanroep: POST /api/v1/chats/{chat_id}/messages, met de chat_id heb je al van het ophalen van chats of van een inkomende webhook, en een text veld. Het eindpunt accepteert zowel formulier-gecodeerde als JSON-gecodeerde lichamen, dus een eenvoudig requests.post met gegevens= werkt zonder extra installatie.
Als er geen bestaande chat_id, bijvoorbeeld het eerste bericht naar een nieuw contact, bellen POST /api/v1/chats in plaats van met een account_id en die van de ontvanger attendees_ids; Unipile maakt de 1-op-1-chat aan en verzendt het bericht in hetzelfde verzoek.
send.py
import requests BASE_URL = "https://{YOUR_DSN}/api/v1" HEADERS = {"X-API-KEY": "YOUR_ACCESS_TOKEN"} def send_message(chat_id: str, text: str) -> dict: response = requests.post( f"{BASE_URL}/chats/{chat_id}/messages", headers=HEADERS, data={"text": text}, ) response.raise_for_status() return response.json() def start_chat(account_id: str, attendee_provider_id: str, text: str) -> dict: response = requests.post( f"{BASE_URL}/chats", headers=HEADERS, data={ "account_id": account_id, "attendees_ids": attendee_provider_id, "text": text, }, ) response.raise_for_status() return response.json()
Berichttypen (tekst, media, spraakberichten, sjablonen) and het 24-uurs klantenservicevenster zijn een onderwerp op zich, dat uitvoerig wordt behandeld in de gids voor berichtenstypen die de WhatsApp API ondersteunt. Dit gedeelte behandelt alleen het Python-leide/loodgieterswerk.
Meta brengt WhatsApp API-berichten per verzonden bericht in rekening, niet per conversatie, sinds juli 2025. Zie Hoe de prijzen van de WhatsApp API per bericht werken voor de huidige tarieven per land.
Gelijktijdigheid

Hoe verstuur je asynchrone WhatsApp-berichten in Python?

Wanneer je naar te veel ontvangers tegelijk verzendt, een broadcast, een wachtrijleegloop, een bulk-opvolgtaak, een lus die wacht op één requests.post op een moment is de bottleneck, niet de API. httpx.AsyncClient gecombineerd met asyncio.gather vuur tegelijkertijd vele verzoeken af vanuit één enkele gebeurtenisloop, zonder dat er threads nodig zijn. Een semafoor zorgt ervoor dat je je netjes gedraagt: WhatsApp-accounts zijn nog steeds gebonden aan de eigen snelheidslimieten van het platform, dus onbeperkte gelijktijdigheid verruilt een traag proces alleen maar voor een muur van 429-reacties.
send_bulk_async.py
import asyncio import httpx BASE_URL = "https://{YOUR_DSN}/api/v1" HEADERS = {"X-API-KEY": "YOUR_ACCESS_TOKEN"} CONCURRENCY_LIMIT = 5 async def send_message_async( client: httpx.AsyncClient, semaphore: asyncio.Semaphore, chat_id: str, text: str, ) -> dict: async with semaphore: response = await client.post( f"{BASE_URL}/chats/{chat_id}/messages", headers=HEADERS, data={"text": text}, ) response.raise_for_status() return response.json() async def send_bulk(messages: list[tuple[str, str]]) -> list: semaphore = asyncio.Semaphore(CONCURRENCY_LIMIT) async with httpx.AsyncClient(timeout=30) as client: tasks = [ send_message_async(client, semaphore, chat_id, text) for chat_id, text in messages ] return await asyncio.gather(*tasks, return_exceptions=True) messages = [ ("9f9uio56sopa456s", "Your order shipped!"), ("a1b2c3d4e5f6g7h8", "Your order shipped!"), ] results = asyncio.run(send_bulk(messages)) for chat_id_text, result in zip(messages, results): if isinstance(result, Exception): print("mislukt:", chat_id_text[0], result)
Behouden GELIJKTIJDIGHEIDSLIMIET conservatief en verhoog het pas nadat je de daadwerkelijke foutpercentages hebt bekeken. return_exceptions=True betekent dat één mislukte verzending de rest van de batch niet annuleert, wat belangrijk is zodra je honderden berichten in één keer verstuurt. De sectie over rate limits en hertry's hieronder voortbouwt op ditzelfde patroon.
Bouw uw verzendpipeline
Webhooks

Hoe ontvang je WhatsApp-berichten met een FastAPI-webhook?

Een webhook is hoe je Python-service direct op de hoogte raakt van een nieuw WhatsApp-bericht zodra dit arriveert, in plaats hiernaar te pollen. Je registreert één eindpunt bij Unipile, en elk bijbehorend event wordt als JSON naar je server verzonden. FastAPI past natuurlijk bij de ontvangende kant: een pydantic model valideert de payload voor je, en Achtergrondtaken Laat je route onmiddellijk een response terugkeren terwijl het echte werk, het aanroepen van een model en het schrijven naar een database, daarna gebeurt.
1. Registreer de webhook
Punt verzoek_url op je FastAPI-route. Tijdens lokale ontwikkeling betekent dat de HTTPS-URL die je tunnel (uit de bovenstaande voorwaardensectie) beschikbaar stelt, en niet localhost.
register_webhook.py
import requests BASE_URL = "https://{YOUR_DSN}/api/v1" HEADERS = {"X-API-KEY": "YOUR_ACCESS_TOKEN"} response = requests.post( f"{BASE_URL}/webhooks", headers=HEADERS, json={ "source": "messaging", "request_url": "https://your-tunnel.example.com/webhooks/whatsapp", "name": "whatsapp-fastapi", "format": "json", "events": ["message_received"], }, ) response.raise_for_status() print(response.json())
2. Ontvangen in FastAPI
De payload die Unipile verz বার্তা, de afzender en de berichttest als platte velden, plus een lijst met bijlagen wanneer die er zijn. Modeleer alleen wat je nodig hebt; Pydantic negeert extra velden standaard.
main.py
from typing import List, Optional from fastapi import BackgroundTasks, FastAPI from pydantic import BaseModel app = FastAPI() class Sender(BaseModel): attendee_id: str attendee_name: Optional[str] = None attendee_provider_id: str class Attachment(BaseModel): id: str type: str mimetype: Optional[str] = None unavailable: bool = False class WhatsAppMessageEvent(BaseModel): account_id: str account_type: str event: str chat_id: str message_id: str message: Optional[str] = None timestamp: str webhook_name: Optional[str] = None afzender: Sender bijlagen: Lijst[Attachment] = [] def handle_message(event: WhatsAppMessageEvent) -> None: if event.account_type != "WHATSAPP" or event.event != "message_received": return # Unipile bevat berichten die het gekoppelde account zelf heeft verzonden, vanaf # een ander apparaat of via uw eigen API-aanroepen. Vergelijk de afzender # met de accounteigenaar die u bij het tot stand brengen van de verbinding hebt opgeslagen, als u # alleen wilt reageren op berichten die van de andere kant komen. print(f"Nieuw WhatsApp-bericht in chat {event.chat_id}: {event.message}") # stuur het vanaf hier door naar je wachtrij, je database of een AI-agent @app.post("/webhooks/whatsapp") async def whatsapp_webhook( event: WhatsAppMessageEvent, background_tasks: BackgroundTasks, ): background_tasks.add_task(handle_message, event) return {"status": "received"}
Voer het uit met uvicorn main:app --reload, richt je tunnel op poort 8000 en registreer die publieke URL als verzoek_url in stap 1. Terugkerend {"status": "ontvangen"} voordat het bericht volledig is verwerkt, is belangrijk: Unipile verwacht een snelle reactie, en Achtergrondtaken is wat houdt bericht_afhandelen om te voorkomen dat het wordt geblokkeerd.
Nog iets dat de moeite waard is om vanaf het begin in te bouwen: sla elke verwerkte bericht-id voordat je actie onderneemt, en sla alles over wat je al hebt gezien. Als het gekoppelde WhatsApp-account zelf de verbinding verbreekt en weer herstelt, levert Unipile de berichten af die tijdens die periode zijn binnengekomen zodra het is bijgewerkt, en een herimplementatie of een gecrashte achtergrondtaak kan er los van voor zorgen dat je eigen handler dezelfde gebeurtenis twee keer ziet, dus het behandelen bericht-id omdat een idempotency-sleutel voorkomt dat een WhatsApp-bot dubbele antwoorden geeft.
Bouw je FastAPI webhook
Lees

Hoe haal je chats en berichtengeschiedenis op in Python?

Elk lijst-eindpunt in de Unipile API, chats, berichten, deelnemers, wordt op dezelfde manier gepagineerd: het antwoord bevat een artikelen array en een cursor. Geef dat door cursor terug op het volgende gesprek, en stop zodra het terugkomt nul. Van Python terwijl True lus sluit direct aan op dat patroon.
Vermeld elke WhatsApp-chat voor een account
list_chats.py
import requests BASE_URL = "https://{YOUR_DSN}/api/v1" HEADERS = {"X-API-KEY": "YOUR_ACCESS_TOKEN"} def list_all_whatsapp_chats(account_id: str) -> list: chats = [] cursor = None while True: params = {"account_id": account_id, "limit": 100} if cursor: params["cursor"] = cursor response = requests.get(f"{BASE_URL}/chats", headers=HEADERS, params=params) response.raise_for_status() page = response.json() chats.extend(page["items"]) cursor = page["cursor"] if not cursor: break return chats for chat in list_all_whatsapp_chats("Yk08cDzzdsqs9_8ds"): print(chat["id"], chat["name"], chat["unread_count"])
Lees de berichtgeschiedenis en de deelnemers van één chat
Meest recente berichten komen eerst terug. Gebruik dezelfde begrenzen en cursor patroon om door de oudere geschiedenis terug te bladeren en de deelnemers-eindpunt aan te roepen wanneer u moet achterhalen wie er daadwerkelijk in een chat zit, individueel of in een groep.
chat_history.py
def get_chat_history(chat_id: str, limit: int = 100) -> list: response = requests.get( f"{BASE_URL}/chats/{chat_id}/messages", headers=HEADERS, params={"limit": limit}, ) response.raise_for_status() return response.json()["items"] def get_chat_attendees(chat_id: str) -> list: response = requests.get( f"{BASE_URL}/chats/{chat_id}/attendees", headers=HEADERS, ) response.raise_for_status() return response.json()["items"] messages = get_chat_history("9f9uio56sopa456s") attendees = get_chat_attendees("9f9uio56sopa456s")
Dit is ook het codepad dat een CRM-synchronisatie of een supportinbox daadwerkelijk uitvoert in Python: op een nieuwe verbinding, loop door elke chat één keer met alle_whatsapp_chats_weergeven om uw database te vullen en vervolgens te vertrouwen op de webhook uit de vorige sectie om deze actueel te houden in plaats de database opnieuw te pollen. De GET /chats endpoint accepteert ook een ongelezen filter, zodat een lichteretaak die volgens een schema alleen ongelezen chats controleert, niet elke keer dat deze wordt uitgevoerd door een volledige accounthistorie hoeft te bladeren.
WhatsApp-groepen zijn ook chats, dus hetzelfde GET /chats en GET /chats/{chat_id}/attendees oproepen, geef een lijst hiervan en hun leden weer vanuit Python zonder extra code. Om een deelnemer toe te voegen of te verwijderen, of om de uitnodigingslink op te halen, gebruikt u PATCH /chats/{chat_id} met een deelnemerToevoegen, deelnemerVerwijderenof uitnodigingslinkOphalen actie. De volledige uitleg, samen met Meta's eigen limieten voor deelnemers op de eigen Groups API, is te vinden in de gids voor WhatsApp-groepsdeelnemers toevoegen of verwijderen.
Automatisering

Hoe bouw je een WhatsApp-bot of AI-agent in Python?

Elke WhatsApp-bot of AI-agent volgt dezelfde drie stappen: ontvang een bericht via de webhook, beslis wat ermee te doen, stuur een antwoord op dezelfde chat_id. Niets over stappen één en drie verandert wanneer je een LLM in het midden plaatst, en daarom de FastAPI-handler en de bericht_verzenden Functies uit de eerdere secties vormen al het grootste deel van de code die je nodig hebt.
agent.py
from openai import OpenAI # of een andere LLM-client die je gebruikt llm = OpenAI() _recent_bot_replies: dict = {} def generate_reply(incoming_text: str) -> str: completion = llm.chat.completions.create( model="gpt-4o-mini", messages=[ {"role": "system", "content": "Je bent een behulpzame WhatsApp-supportmedewerker."}, {"role": "user", "content": incoming_text}, ], ) return completion.choices[0].message.content def handle_message(event: WhatsAppMessageEvent) -> None: if event.account_type != "WHATSAPP" or event.event != "message_received": return if not event.message: return if _recent_bot_replies.get(event.chat_id) == event.message: return # echo van ons eigen laatste antwoord, negeer dit reply_text = generate_reply(event.message) _recent_bot_replies[event.chat_id] = reply_text send_message(event.chat_id, reply_text)
De _recente_bot_antwoorden beveiliging is belangrijk dan het lijkt: die van Unipile bericht_ontvangen gebeurtenissen worden ook geactiveerd voor berichten die het gekoppelde account verzendt, vanaf een ander apparaat of via je eigen API-aanroepen, dus zonder een beveiliging kan een agent uiteindelijk reageren op zijn eigen antwoord. Een dictionary is prima voor een demo; een productieagent moet die status in Redis of een database bijhouden samen met de conversatiegeschiedenis en een idempotentiesleutel.
De webhook-payload en de bericht_verzenden oproepen hebben dezelfde vorm op WhatsApp, LinkedIn, Instagram en Telegram, alleen accounttype wijzigingen, zodat dezelfde FastAPI-handler de antwoorden van één agent kan routeren over elk kanaal waarmee een gebruiker is verbonden. Het correct handhaven van kanaalspecifieke toon, opmaak en limieten daarbij wordt behandeld in de gids over de multichannel-API voor AI-agenten.
Bouw je WhatsApp AI-agent
Betrouwbaarheid

Hoe ga je om met limieten (rate limits) en het opnieuw proberen (retries) van verzoeken in Python?

Unipile retourneert een JSON-body met een type veld, zoals fouten/ongeldige_inloggegevens of fouten/losgekoppeld_account, wanneer een verzoek mislukkt. Sommige daarvan zijn het proberen waard, zoals een verbroken verbinding of een tijdelijke storing bij de provider; andere, zoals ongeldige inloggegevens, lossen zichzelf niet op, hoe vaak u het ook opnieuw probeert. Hoe snel en hoeveel u vanaf één WhatsApp-account verzendt, blijft een beslissing van de klant, gevormd door de limieten die WhatsApp zelf aan dat account oplegt, en geen vast getal dat Unipile daarbovenop oplegt.
De doorzettingsvermogen verpak dat in een decorator in plaats van een met de hand geschreven lus. Omwikkel dezelfde bericht_verzenden functie uit de verzendsectie met exponentiële back-off en een begrensd aantal pogingen:
probeer_opnieuw.py
# pip install tenacity import requests from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type @retry( stop=stop_after_attempt(5), wait=wait_exponential(multiplier=1, min=2, max=30), retry=retry_if_exception_type(requests.exceptions.HTTPError), ) def send_message_with_retry(chat_id: str, text: str) -> dict: response = requests.post( f"{BASE_URL}/chats/{chat_id}/messages", headers=HEADERS, data={"text": text}, ) response.raise_for_status() return response.json()
Vijf pogingen met een exponentiële back-off van 2 tot 30 seconden zijn een verstandige standaardinstelling voor een achtergrondtaak; verlaag het aantal pogingen voor alles wat in een door de gebruiker benaderd aanvraagpad loopt, aangezien doorzettingsvermogen zal het verzoek anders openhouden terwijl het opnieuw probeert. Dezelfde decorator omwikkelt de async-versie uit de concurrency-sectie, voeg gewoon toe wacht op waar doorzettingsvermogen ondersteunt het via AsyncRetrying.
SDK

Is er een officiële Unipile Python SDK?

Ja. unipile/unipile-python is echt en wordt actief onderhouden, met een commit die al op 11 augustus 2026 is gepushed. Twee dingen zijn de moeite waard om te weten voordat je ernaar grijpt: het is nog niet gepubliceerd op PyPI, en het richt zich op Unipile's API v2, die zich nog in de bètafase bevindt, terwijl elk eindpunt dat in deze gids wordt gebruikt v1 is.
Actief onderhouden, alleen op GitHub
Python 3.9+, pydantic 2.11+
Niet op PyPI, installeer vanuit GitHub
Richt op API v2 beta, niet v1
install_sdk.sh
pip install git+https://github.com/unipile/unipile-python.git
sdk_usage.py
import unipile configuration = unipile.Configuration() configuration.api_key["apiKey"] = "YOUR_ACCESS_TOKEN" api_client = unipile.ApiClient(configuration) messaging_api = unipile.MessagingApi(api_client)
Voor alles wat deze gids vandaag behandelt, kun je voortbouwen op de v1 REST-eindpunten met verzoekt of httpxze zijn stabiel, gedocumenteerd en dat is waarop elk bovenstaand codevoorbeeld daadwerkelijk draait. Zodra de Python SDK de bètastase verlaat en op PyPI verschijnt, betekent migreren voornamelijk het inruilen van HTTP-aanroepen voor getypeerde clientmethoden; de eindpunten en het daaronder liggende model voor gekoppelde accounts veranderen niet. Ter vergelijking: de Node.js SDK is degene waarnaar momenteel wordt verwezen in de hoofdindex van de documentatie van Unipile, en de oudere PHP SDK is sinds oktober 2023 gearchiveerd.
Hetzelfde soort integratie bouwen voor een ander kanaal? De Instagram API met Python gids volgt het identieke patroon van verbinden, verzenden, ophalen en webhook zoals weergegeven in dit artikel.
Bouw vandaag nog met de REST API

WhatsApp API in Python: FAQ

Duidelijke antwoorden over bibliotheken, verbinding, SDK's en webhooks voor het bouwen van de WhatsApp API in Python.

Er is niet één beste bibliotheek, het hangt ervan af wat je al hebt. Als je al bent goedgekeurd voor Meta's Cloud API, whatsapp-cloud-api geeft je er een Pythonische wrapper omheen. Als je Meta Business-verificatie volledig wilt overslaan en WhatsApp-accounts namens je gebruikers wilt koppelen, kun je de REST API van Unipile aanroepen met verzoekt of httpx dekt WhatsApp naast LinkedIn, Instagram en Telegram vanuit één interface. pywhatkit is het waard om vroegtijdig uit te sluiten: het stuurt WhatsApp Web aan in een browser, geen server-side API, dus het past niet bij een productie-backend.
Verstuur een POST verzoek om /api/v1/chats/{chat_id}/berichten with a text veld en jouw X-API-KEY koptekst, bijvoorbeeld requests.post(url, headers=headers, data={"text": "Hallo"}). Als je geen chat_id toch, POST /api/v1/chats met een account_id en die van de ontvanger attendees_ids maakt de chat aan en verzendt het eerste bericht in dezelfde aanroep.
Ja. Het verbinden van een WhatsApp-account via Unipile vereist alleen dat de accounteigenaar een QR-code scant of een koppelcode invoert, op dezelfde manier als WhatsApp Web werkt. Er is geen Meta Business Platform-applicatie en geen verificatie van het telefoonnummer bij Meta, omdat de integratie verloopt namens de geauthenticeerde gebruiker in plaats van via een geregistreerd WhatsApp Business-nummer.
Ja, unipile/unipile-python is een actief onderhouden officiële SDK, maar staat nog niet op PyPI: installeer het met pip install git+https://github.com/unipile/unipile-python.git. Het richt zich ook op Unipile's API v2, die in bèta is, terwijl elk eindpunt in deze gids de stabiele v1 API gebruikt, dus de meeste Python-integraties worden vandaag de dag nog steeds direct gebouwd op verzoekt of httpx in plaats van de SDK.
verzoekt is eenvoudiger en voldoende voor scripts, cronjobs en verzending in laag volume. httpx is de overstap waard zodra je naar te veel ontvangers tegelijk stuurt of een asynchrone FastAPI-service bouwt, omdat het AsyncClient hiermee kun je meerdere aanvragen gelijktijdig verzenden vanuit dezelfde gebeurtenislus in plaats van te wachten op elke afzonderlijke aanvraag.
Een FastAPI-app lokaal draaien, deze exposeren met een tunnel zoals ngrok of cloudflared om een openbare HTTPS-URL te krijgen en die URL te registreren als verzoek_url wanneer je een webhook aanmaakt met bron instellen op berichtgeving. Unipile stuurt elk nieuw bericht naar die tunnel-URL, die het rechtstreeks doorstuurt naar je lokale FastAPI-route terwijl je ontwikkelt.
Ja. WhatsApp-groepen worden weergegeven als reguliere chats, dus GET /chats en GET /chats/{chat_id}/attendees lijst ze en hun leden zonder hoofdlettergevoeligheid. Om een deelnemer toe te voegen, te verwijderen of de uitnodigingslink voor de groep op te halen, stuur een PATCH /chats/{chat_id} verzoek met een deelnemerToevoegen, deelnemerVerwijderenof uitnodigingslinkOphalen actie, gedetailleerd in de handleiding voor WhatsApp-groepsleden toevoegen en verwijderen.
De onderliggende eindpunten zijn identiek, het verschil zit in de runtime en het bijbehorende ecosysteem: Python geeft de voorkeur aan verzoekt of httpx met asyncio voor concurrency en FastAPI voor webhooks, terwijl PHP-integraties meestal Guzzle gebruiken en binnen een Laravel-applicatie passen met queued jobs. Als je stack PHP is, dezelfde integratie in PHP loopt door elke equivalente stap.

Heb je nog vragen? Ons team staat klaar om te helpen.

Praat met een expert
nl_NLNL
en_USEN fr_FRFR es_ESES de_DEDE it_ITIT pt_BRBR pl_PLPL tr_TRTR nl_NLNL