Buduj teraz

API WhatsApp z Pythonem: Wysyłaj, odbieraj i automatyzuj wiadomości

WhatsApp API w PythoniePython + API WhatsApp

API WhatsApp z PythonWysyłaj, odbieraj i automatyzuj wiadomości

Wszystko, czego potrzebujesz, aby używać WhatsApp API w Pythonie: jaką bibliotekę wybrać, jak połączyć powiązane konto za pomocą kodu QR, jak wysyłać i odbierać wiadomości za pomocą żądania oraz httpx, oraz jak podłączyć webhook FastAPI dla bota lub agenta AI.
Twórz w Pythonie Zobacz dokumentację API
REST API już dziś, bez potrzeby weryfikacji Meta Business
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", "Hello from Python!")
200 OK, wiadomość wysłana
Definicja

Czym jest WhatsApp API w Pythonie?

The WhatsApp API w Pythonie oznacza wywoływanie wiadomości WhatsApp Business z kodu w Pythonie zamiast klikania w WhatsApp Web. Skrypt w Pythonie lub usługa backendowa wysyła żądanie HTTP, zazwyczaj za pomocą żądania lub httpx, do interfejsu REST API obsługującego czaty, wiadomości i webhooki – albo bezpośrednio do Cloud API od Meta, albo do zunifikowanego dostawcy, takiego jak Unipile, który łączy WhatsAppa obok LinkedIna, Instagrama i Telegrama w ramach jednego interfejsu. Meta nie publikuje oficjalnego, kompleksowego zestawu SDK WhatsApp dla języka Python, dlatego prawie każda integracja w tym przewodniku oraz większość tego, co znajdziesz w pozostałej części sieci, komunikuje się bezpośrednio z punktami końcowymi REST.
Jedno REST API dla WhatsApp, LinkedIn, Instagrama i Telegrama
Połączone za pomocą kodu QR lub kodu parowania, bez weryfikacji Meta Business
żądania dla prostych skryptów, httpx dla przetwarzania asynchronicznego na skalę masową
W przypadku warstwy orientacji, dostępu, kosztów i limitów zacznij od Przewodnik po dostępie, kosztach i limitach API WhatsApp. Budowanie w PHP zamiast w Pythonie?
Przeczytać tę samą integrację w PHP
Zanim zaczniesz budować

Czego potrzebujesz przed rozpoczęciem?

Nie potrzebujesz konta Meta Business ani zatwierdzenia WhatsApp Business Platform, aby zacząć wysyłać i odbierać wiadomości z poziomu Pythona. Potrzebujesz działającego środowiska Python, klienta HTTP, miejsca do odbierania webhooków oraz konta Unipile.
Python 3.9+
Odpowiada minimalnej wersji wymaganej przez sam pakiet Unipile Python SDK pydantic zależność, a przez współczesne httpx i wydania FastAPI.
requests czy httpx
pip install requests dla wywołań synchronicznych, lub pip install httpx jeśli planujesz wysyłać wiadomości jednocześnie. Zobacz żądania oraz httpx dokumentacja.
Lokalny tunel
Narzędzie takie jak ngrok lub cloudflared aby udostępnić swoją ścieżkę webhooka FastAPI pod publicznym adresem URL HTTPS na czas rozwoju.
Token dostępu i DSN
Oba pochodzą z panelu Unipile. DSN to host, który wywołujesz, a Token Dostępu trafia do X-API-KEY nagłówek każdego żądania.
Zbuduj swoją pierwszą integrację z WhatsApp
Porównanie bibliotek

Której biblioteki Pythona powinieneś użyć do WhatsAppa?

Nie ma jednej, oczywistej odpowiedzi, a większość wpisów na blogach na ten temat promować będzie tę paczkę, którą utrzymuje autor. Oto faktyczne porównanie pięciu sposobów, w jakie programiści Pythona rzeczywiście wywołują dziś WhatsAppa – od automatyzacji przeglądarki po zunifikowanego dostawcę – dzięki czemu możesz dokonać wyboru w oparciu o to, co każda opcja faktycznie robi, a nie o marketing.
Biblioteka / podejście
Jak to właściwie się nazywa
Weryfikacja firm w Meta
Utrzymany
Najlepszy dla
pywhatkit
Obsługuje WhatsApp Web w karcie przeglądarki (automatyzacja klawiatury), a nie jako API po stronie serwera
Nie dotyczy, brak API
Społeczność, sporadyczny
Jednorazowe skrypty i demonstracje na maszynie z ekranem, a nie wysyłka produkcyjna
whatsapp-cloud-api
Cienka otoczona w Pythonie wokół oficjalnych punktów końcowych WhatsApp Cloud API od Meta
Wymagany
Wrapper społecznościowy
Zespoły z zatwierdzonym już dostępem do Cloud API, które chcą korzystać z klienta w języku Python
klient-api-whatsapp-python
Wywołuje SaaS Green-API, który z kolei utrzymuje sesję WhatsApp
Niewymagane
Utrzymywany przez dostawcę
Zespoły czujące się swobodnie w poleganiu na drugim, jednofunkcyjnym dostawcy SaaS
żądania, bezpośrednio do Meta
Punkty końcowe Cloud API firmy Meta, bez żadnego wrappera
Wymagany
Zrób to sam (DIY)
Zespoły mające już zweryfikowane konto w Meta Business, które chcą pełnej kontroli
Unipile, requests czy httpx
Jednolite API wiadomości Unipile, WhatsApp obok LinkedIn, Instagrama i Telegrama
Niewymagane
Aktywnie utrzymywany, zestaw SDK języka Python w wersji beta
Produkty SaaS łączące wiele kont WhatsApp użytkowników końcowych w imieniu każdego użytkownika
pywhatkit
PołączeniaObsługuje WhatsApp Web w karcie przeglądarki, a nie jako interfejs API po stronie serwera
Weryfikacja MetaNie dotyczy, brak API
UtrzymanySpołeczność, sporadyczny
Najlepszy dlaJednorazowe skrypty i demonstracje, bez wysyłki produkcyjnej
whatsapp-cloud-api
PołączeniaCienka otoczka wokół własnych punktów końcowych API w chmurze firmy Meta
Weryfikacja MetaWymagany
UtrzymanyWrapper społecznościowy
Najlepszy dlaZespoły już zatwierdzone w Cloud API
klient-api-whatsapp-python
PołączeniaSaaS green-api, który utrzymuje sesję WhatsApp
Weryfikacja MetaNiewymagane
UtrzymanyUtrzymywany przez dostawcę
Najlepszy dlaZespoły czujące się swobodnie z drugim dostawcą SaaS
żądania, bezpośrednio do Meta
PołączeniaKońcówki API chmurowego Meta, bez wrappera
Weryfikacja MetaWymagany
UtrzymanyZrób to sam (DIY)
Najlepszy dlaZespoły już zweryfikowane w ramach weryfikacji Meta Business
Unipile, requests czy httpx
PołączeniaZunifikowane API wiadomości, WhatsApp z LinkedIn, Instagramem, Telegramem
Weryfikacja MetaNiewymagane
UtrzymanyAktywnie utrzymywany, zestaw SDK języka Python w wersji beta
Najlepszy dlaProdukty SaaS łączące wiele kont użytkowników końcowych
Każda opcja, która utrzymuje Wymagana weryfikacja Meta Business ostatecznie komunikuje się z własnym interfejsem WhatsApp Cloud API firmy Meta (zob. Dokumentacja platformy WhatsApp Business firmy Meta), co jest właściwym rozwiązaniem, jeśli korzystasz już ze zweryfikowanego numeru firmowego. Jeśli natomiast łączysz konta WhatsApp w imieniu wielu różnych użytkowników końcowych, proces z użyciem kodu QR lub kodu parowania całkowicie pomija ten krok weryfikacji i jest to model, który opisuje dalsza część tego przewodnika.
Połączenie z kontem

Jak połączyć konto WhatsApp w Pythonie?

Każde wywołanie w tym przewodniku działa w imieniu uwierzytelnionego użytkownika który połączył własne konto WhatsApp. Nie ma etapu weryfikacji Meta Business: z poziomu Pythona wysyłasz pojedynczą POST /api/v1/accounts prośba z provider ustaw na WHATSAPP, a użytk potwierdza połączenie, skanując kod QR lub wpisując kod parowania w swoim telefonie.
Opcja A: Kod QR (domyślnie)
Wyjdź parowanie_numeru_telefonu z treści żądania, a Unipile zwraca punkt kontrolny zawierający ładunek kodu QR. Wyrenderuj go za pomocą biblioteki takiej jak kod QR i wyświetl go użytkowi do zeskanowania z poziomu WhatsApp > Połączone urządzenia.
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) # Zmienna account zawiera nowy identyfikator account_id oraz obiekt checkpoint. # Wygeneruj kod QR na podstawie obiektu checkpoint i poproś użytkownika o jego zeskanowanie # w aplikacji WhatsApp > Powiązane urządzenia.
Opcja B: kod parowania
Podanie parowanie_numeru_telefonu w cyfrach w formacie E.164, najpierw kod kraju, bez znaku plus, bez spacji. Unipile zwraca punkt kontrolny zawierający krótki kod, który użytkownik wpisuje w WhatsAppie zamiast cokolwiek skanować, co lepiej pasuje do serwera bez interfejsu graficznego i ekranu, na którym można wyświetlić kod QR.
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() # Kod kraju + numer, tylko cyfry, np. Francja account = connect_whatsapp_pairing_code("33612345678") # Punkt kontrolny konta zawiera kod parowania, który należy wyświetlić w interfejsie użytkownika. # Użytkownik wprowadza go w aplikacji WhatsApp > Powiązane urządzenia > Połącz z numerem telefonu.
Potwierdź, że konto jest połączone
Gdy użytkownik zeskanuje kod QR lub wpisze kod parowania, musisz wiedzieć, kiedy konto jest faktycznie gotowe do wysyłania i odbierania wiadomości. Unipile daje Ci dwie opcje.
Sprawdź status konta
Zadzwoń GET /api/v1/accounts/{account_id} co kilka sekund, dopóki konto nie przestanie wymagać punktu kontrolnego. Proste, ale marnuje żądania podczas oczekiwania.
Webhook statusu konta
Zarejestruj webhook za pomocą źródło ustaw na status_konta (to samo POST /api/v1/webhooks punkt końcowy używany do przesyłania wiadomości) oraz powiadomienia wysyłane przez Unipile {"AccountStatus": {"account_id": "...", "message": "OK"}} w tej samej sekundzie, gdy konto jest gotowe. Z tego korzysta większość integracji produkcyjnych.
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) # sprawdź dane na żywo, aby samodzielnie zweryfikować status time.sleep(2) raise TimeoutError("Konto WhatsApp nie potwierdziło połączenia w wyznaczonym czasie")
Zbuduj proces połączenia
Wyślij

Jak wysłać wiadomość na WhatsApp za pomocą Pythona?

Wysłanie wiadomości przez WhatsApp z poziomu Pythona to jedno wywołanie HTTP: POST /api/v1/chats/{chat_id}/messages, z chat_id masz już z listy czatów lub z przychodzącego webhooka, oraz text pola. Endpoint obsługuje zarówno treści zakodowane w formacie formularza, jak i JSON, więc zwykły requests.post z dane= działa bez dodatkowej konfiguracji.
Jeśli nie ma istniejącego chat_id, na przykład pierwsza wiadomość do nowego kontaktu, połączenie POST /api/v1/chats zamiast z account_id i odbiorcy attendees_ids; Unipile tworzy czat 1:1 i wysyła wiadomość w tym samym żądaniu.
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()
Typy wiadomości (tekst, media, wiadomości głosowe, szablony) oraz 24-godzinne okno obsługi klienta to osobny temat, omówiony w całości w przewodniku po typy wiadomości obsługiwane przez interfejs API WhatsApp. Ta sekcja dotyczy wyłącznie infrastruktury Pythona.
Meta nalicza opłaty za wiadomości przez API WhatsApp za każdą wysłaną wiadomość, a nie za konwersację, od lipca 2025 roku. Zobacz Jak działa cennik API WhatsApp za wiadomość dla aktualnych stawek w poszczególnych krajach.
Współbieżność

Jak wysyłać wiadomości WhatsApp asynchronicznie w Pythonie?

Kiedy wysyłasz do wielu odbiorców naraz, komunikat masowy, opróżnianie kolejki, masowe zadanie uzupełniające, pętlę, która oczekuje na jeden requests.post w tym przypadku wąskim gardłem jest czas, a nie API. httpx.AsyncClient w połączeniu z asyncio.gather wysyła wiele żądań współbieżnie z pojedynczej pętli zdarzeń, bez użycia wątków. Semafor pozwala zachować rozsądek: konta WhatsApp nadal podlegają własnym limitom platformy, więc nieograniczona współbieżność zamienia jedynie wolną pętle w ścianę błędów 429.
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", "Twoje zamówienie zostało wysłane!"), ("a1b2c3d4e5f6g7h8", "Twoje zamówienie zostało wysłane!"), ] results = asyncio.run(send_bulk(messages)) for chat_id_text, result in zip(messages, results): if isinstance(result, Exception): print("failed:", chat_id_text[0], result)
Zachowaj LIMIT_WSPÓŁBIEŻNOŚCI konserwatywny i zwiększaj go dopiero po zaobserwowaniu rzeczywistych wskaźników błędów. return_exceptions=True co oznacza, że jedno nieudane wysłanie nie przerywa reszty partii, co ma znaczenie, gdy wysyłasz setki wiadomości w jednym ciągu. Sekcja dotycząca limitów częstotliwości i ponownych prób poniżej opiera się na tym samym wzorcu.
Zbuduj swój potok wysyłkowy
Webhooks

Jak odbierać wiadomości z WhatsApp za pomocą webhooka w FastAPI?

Webhook to sposób, w jaki Twój serwis w języku Python dowiaduje się o nowej wiadomości WhatsApp w momencie jej nadejścia, zamiast ją odpytywać. Rejestrujesz jeden punkt końcowy w Unipile, a każde pasujące zdarzenie jest dostarczane do Twojego serwera jako JSON. FastAPI naturalnie pasuje do strony odbiorczej: pydantic model weryfikuje ładunek danych za Ciebie, oraz Zadania w tle Sprawmy, aby Twoja ścieżka zwracała odpowiedź natychmiast, podczas gdy właściwa praca – wywołanie modelu i zapis do bazy danych – odbywa się później.
1. Zarejestruj webhook
Punkt request_url w Twojej ścieżce FastAPI. Podczas lokalnego rozwoju oznacza to adres URL HTTPS, który udostępnia Twój tunel (z sekcji wymagań wstępnych powyżej), a nie 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. Odbierz to w FastAPI
Ładunek wysyłany przez Unipile zawiera czat, nadawcę i tekst wiadomości jako płaskie pola oraz listę załączników, jeśli takie występują. Zamodeluj tylko to, czego potrzebujesz; Pydantic domyślnie ignoruje dodatkowe pola.
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 nadawca: Nadawca załączniki: Lista[Załącznik] = [] def obsłuż_wiadomość(zdarzenie: WhatsAppMessageEvent) -> None: if zdarzenie.typ_konta != "WHATSAPP" lub zdarzenie.zdarzenie != "message_received": return # Unipile uwzględnia wiadomości wysłane przez samo powiązane konto, z # innego urządzenia lub z własnych wywołań API. Porównaj nadawcę # z właścicielem konta zapisanym w momencie nawiązania połączenia, jeśli # chcesz reagować wyłącznie na wiadomości pochodzące z drugiej strony. print(f"Nowa wiadomość WhatsApp na czacie {event.chat_id}: {event.message}") # stąd przekaż ją do swojej kolejki, bazy danych lub agenta AI @app.post("/webhooks/whatsapp") async def whatsapp_webhook( event: WhatsAppMessageEvent, background_tasks: BackgroundTasks, ): background_tasks.add_task(handle_message, event) return {"status": "received"}
Uruchom to za pomocą uvicorn main:app --reload, skieruj swój tunel na port 8000 i zarejestruj ten publiczny adres URL jako request_url w kroku 1. Powrót {"status": "odebrano"} Zanim wiadomość zostanie w pełni przetworzona, ma znaczenie to, że: Unipile oczekuje szybkiej odpowiedzi oraz Zadania w tle to, co utrzymuje obsłuż_wiadomość przed zablokowaniem go.
Jeszcze jedna rzecz, którą warto wdrożyć od samego początku: zapisywać każdy przetworzony id_wiadomosci zanim podejmiesz jakiekolwiek działania i pomiń wszystko, co już widziałeś. Jeśli samo połączone konto WhatsApp rozłączy się i połączy ponownie, Unipile dostarcza wiadomości, które dotarły w tym przerwie, gdy tylko nadrobi zaległości, a ponowne wdrożenie lub awaria zadania w tle mogą niezależnie spowodować, że Twój własny handler zobaczy to samo zdarzenie dwa razy, więc traktowanie id_wiadomosci ponieważ klucz idempotencji chroni bot WhatsApp przed podwójną odpowiedź.
Zbuduj swój webhook FastAPI
Czytaj

Jak pobrać czaty i historię wiadomości w Pythonie?

Każdy punkt końcowy listy w API Unipile, czaty, wiadomości, uczestnicy, jest paginowany w ten sam sposób: odpowiedź zawiera Przedmioty tablica i kursor. Podaj to kursor wróć na następnej rozmowie i zatrzymaj się, gdy wróci null. Pythona podczas gdy Prawda pętla odwzorowuje się bezpośrednio na ten wzorzec.
Wymień wszystkie czaty WhatsApp dla konta
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"])
Przeczytać historię wiadomości i uczestników jednego czatu
Najnowsze wiadomości wracają pierwsze. Użyj tego samego limit oraz kursor wzorzec umożliwiający przechodzenie wstecz przez starszą historię i wywoływanie punktu końcowego uczestników za każdym razem, gdy musisz ustalić, kto faktycznie znajduje się w czacie, indywidualnym lub grupowym.
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")
To jest również ścieżka kodu, którą synchronizacja CRM lub skrzynka odbiorcza supportu faktycznie uruchamia w Pythonie: przy nowym połączeniu przejść przez każdy czat raz za pomocą wyświetl_wszystkie_czaty_whatsapp aby zasilić bazę danych, a następnie polegać na webhooku z poprzedniej sekcji, aby utrzymywać ją w aktualnym stanie zamiast ponownego odpytywania. GET /chats punkt końcowy akceptuje również Nieprzeczytane filtr, aby lżejsze zadanie, które sprawdza jedynie nieprzeczytane czaty według harmonogramu, nie musiało przeglądać całej historii konta za każdym razem, gdy się uruchamia.
Grupy na WhatsApp to też czaty, więc to samo GET /chats oraz GET /chats/{chat_id}/attendees połączenia, wyczyść je i ich członków z poziomu Pythona bez dodatkowego kodu. Aby dodać lub usunąć uczestnika albo pobrać link z zaproszeniem, użyj PATCH /chats/{chat_id} z dodajUczestnika, usuńUczestnikalub pobierzLinkZaproszenia akcja. Pełny poradnik wraz z własnymi limitami uczestników Meta w natywnym API grup znajduje się w przewodniku do dodaj lub usuń uczestników grupy WhatsApp.
Automatyzacja

Jak zbudować bota WhatsApp lub agenta AI w Pythonie?

Każdy bot WhatsApp lub agent AI składa się z tych samych trzech kroków: odebranie wiadomości przez webhook, zdecydowanie, co z nią zrobić, i wysłanie odpowiedzi w ten sam sposób chat_id. Nic w krokach pierwszym i trzecim nie zmienia się, gdy umieścisz model LLM w środku, dlatego obsługa w FastAPI oraz wyślij_wiadomość Funkcje z wcześniejszych sekcji stanowią już większą część kodu, którego potrzebujesz.
agent.py
from openai import OpenAI # lub dowolny klient LLM, z którego korzystasz 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": "Jesteś pomocnym konsultantem obsługi klienta WhatsApp."}, {"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 naszej ostatniej odpowiedzi, zignoruj to reply_text = generate_reply(event.message) _recent_bot_replies[event.chat_id] = reply_text send_message(event.chat_id, reply_text)
The _ostatnie_odpowiedzi_bota ochrona znaczy więcej, niż się wydaje: Unipile message_received zdarzenie jest wyzwalane również dla wiadomości wysyłanych przez powiązane konto z innego urządzenia lub za pomocą własnych wywołań API, więc bez zabezpieczenia agent może w końcu odpowiedzieć na własną odpowiedź. Słownik jest w porządku do wersji demo; agent produkcyjny powinien przechowywać ten stan w Redisie lub bazie danych obok historii konwersacji i klucza idempotencji.
Payload webhooka i wyślij_wiadomość połączenia mają taki sam kształt w WhatsApp, LinkedIn, Instagramie i Telegramie, tylko typ_konta zmiany, aby ten sam moduł obsługi FastAPI mógł kierować odpowiedzi jednego agenta przez wszystkie kanały połączone przez użytkownika. Utrzymanie odpowiedniego dla danego kanału tonu, formatowania i limitów częstotliwości w takim przypadku zostało opisane w przewodniku po Wielokanałowe API dla agentów AI.
Zbuduj swojego agenta AI na WhatsAppie
Niezawodność

Jak radzisz sobie z ograniczeniami liczby żądań (rate limits) i ponownymi próbami (retries) w Pythonie?

Unipile zwraca treść w formacie JSON z typ pole, jak errors/invalid_credentials lub błędy/odłączone_konto, ilekąd żądanie się nie powiedzie. Niektóre z nich warto ponowić, jak zerwane połączenie lub tymczasowy problem dostawcy; inne, takie jak błędne dane uwierzytelniające, nie naprawią się same, bez względu na to, ile razy ponowisz wywołanie. Jak szybko i jak dużo wysyłasz z jednego konta WhatsApp, pozostaje decyzją klienta, kształtowaną przez limity częstotliwości nakładane przez samego WhatsAppa na to konto, a nie stałą liczbę narzuconą dodatkowo przez Unipile.
The wytrwałość zamień to w dekorator zamiast ręcznie pisanej pętli. Owiń to samo wyślij_wiadomość funkcja z sekcji wysyłania z wykładniczym wygaszaniem i ograniczoną liczbą prób:
retry.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()
Pięć prób z wykładniczym wygaszaniem od 2 do 30 sekund to rozsądne ustawienie domyślne dla zadań w tle; zmniejsz liczbę prób dla wszystkiego, co działa na ścieżce żądania widocznej dla użytkownika, ponieważ wytrwałość będzie w przeciwnym razie utrzymywać żądanie otwarte podczas ponawiania prób. Ten sam dekorator otacza wersję asynchroniczną z sekcji współbieżności, wystarczy dodać czekać gdzie wytrwałość wspiera to poprzez Asynchroniczne ponawianie.
SDK

Czy istnieje oficjalne SDK Unipile dla języka Python?

Tak. unipile/unipile-python jest prawdziwy i aktywnie rozwijany, a commit został wypchnięty zaledwie 11 sierpnia 2026 roku. Warto wiedzieć o dwóch rzeczach, zanim po niego sięgniesz: nie został jeszcze opublikowany na PyPI i jest skierowany na API v2 Unipile, które wciąż jest w fazie beta, podczas gdy każdy punkt końcowy używany w tym przewodniku to v1.
Aktywnie utrzymywane, tylko na GitHubie
Python 3.9+, pydantic 2.11+
Niedostępny na PyPI, zainstaluj z GitHub
Celuje w interfejs API v2 beta, a nie 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)
W oparciu o wszystko, co ten przewodnik obejmuje dzisiaj, rozbuduj punkty końcowe REST w wersji 1 o żądania lub httpxsą stabilne, udokumentowane i to na nich faktycznie opiera się każdy powyższy przykład kodu. Gdy zestaw SDK dla Pythona wyjdzie z fazy beta i trafi do PyPI, migracja będzie oznaczać głównie zastąpienie wywołań HTTP w pełni typowanymi metodami klienta – same endpointy i leżący u ich podstaw model połączonych kont nie ulegną zmianie. Dla porównania, zestaw SDK dla Node.js jest obecnie tym, do którego odwołuje się główny indeks dokumentacji Unipile, natomiast starszy zestaw SDK dla PHP został zarchiwizowany w październiku 2023 roku.
Budujesz tego samego rodzaju integrację dla innego kanału? API Instagrama z Pythoniem Przewodnik ten opiera się na identycznym wzorcu łączenia, wysyłania, pobierania i webhooka, przedstawionym w tym artykule.
Zacznij tworzyć za pomocą interfejsu REST API już dziś

API WhatsApp w Pythonie: FAQ

Konkretne odpowiedzi na temat bibliotek, połączenia, zestawów SDK i webhooków do budowania API WhatsApp w języku Python.

Nie ma jednej najlepszej biblioteki, to zależy od tego, co już masz. Jeśli masz już zatwierdzoną Chmurową API Meta, whatsapp-cloud-api daje Ci wokół niego pythonową otoczkę. Jeśli chcesz całkowicie pominąć weryfikację Meta Business i zamiast tego podłączać konta WhatsApp w imieniu swoich użytkowników, REST API Unipile wywołane za pomocą żądania lub httpx obsługuje WhatsAppa obok LinkedIna, Instagrama i Telegrama z jednego interfejsu. pywhatkit warto to wcześnie wyeliminować: obsługuje WhatsApp Web w przeglądarce, a nie przez serwerowe API, więc nie nadaje się do produkcyjnego backendu.
Wyślij POST wniosek do /api/v1/czaty/{chat_id}/wiadomości with a text pole i twój X-API-KEY nagłówek, na przykład requests.post(url, headers=headers, data={"text": "Cześć"}). Jeśli nie masz chat_id jednakże, POST /api/v1/chats z account_id i odbiorcy attendees_ids tworzy czat i wysyła pierwszą wiadomość w tym samym wywołaniu.
Tak. Połączenie konta WhatsApp za pomocą Unipile wymaga od właściciela konta jedynie zeskanowania kodu QR lub wprowadzenia kodu parowania, dokładnie tak samo, jak działa WhatsApp Web. Nie ma tu aplikacji Meta Business Platform ani weryfikacji numeru telefonu w Meta, ponieważ integracja działa w imieniu uwierzytelnionego użytkownika zamiast za pośrednictwem zarejestrowanego numeru WhatsApp Business.
Tak, unipile/unipile-python jest aktywnie utrzymywanym oficjalnym pakietem SDK, ale nie ma go jeszcze na PyPI: zainstaluj go za pomocą pip install git+https://github.com/unipile/unipile-python.git. Celuje on również w wersję beta API Unipile v2, podczas gdy każdy punkt końcowy w tym przewodniku korzysta ze stabilnego API v1, więc większość dzisiejszych integracji w Pythonie jest nadal budowana bezpośrednio na żądania lub httpx zamiast zestawu SDK.
żądania jest prostszy i wystarczający do skryptów, zadań cron i wysyłania małych ilości wiadomości. httpx warto dokonać zmiany, gdy wysyłasz do wielu odbiorców naraz lub budujesz asynchroniczny serwis FastAPI, ponieważ jego AsyncClient pozwala na wysyłanie wielu żądań jednocześnie z tej samej pętli zdarzeń zamiast blokować każde z nich.
Uruchom aplikację FastAPI lokalnie, udostępnij ją za pomocą tunelu takiego jak ngrok lub cloudflared aby uzyskać publiczny adres URL HTTPS i zarejestrować ten adres URL jako request_url kiedy tworzysz webhook za pomocą źródło ustaw na przekazywanie wiadomości. Unipile wysyła każdą nową wiadomość na ten adres URL tunelu, który przekierowuje ją bezpośrednio do Twojej lokalnej ścieżki FastAPI podczas tworzenia aplikacji.
Tak. Grupy na WhatsAppie pojawiają się jako zwykłe czaty, więc GET /chats oraz GET /chats/{chat_id}/attendees wyświetl je i ich członków bez uwzględniania wielkości liter. Aby dodać uczestnika, usunąć go lub pobrać link z zaproszeniem do grupy, wyślij PATCH /chats/{chat_id} wniosek z dodajUczestnika, usuńUczestnikalub pobierzLinkZaproszenia działanie, szczegółowo opisane w przewodniku po dodawanie i usuwanie członków grupy WhatsApp.
Podstawowe punkty końcowe są identyczne, różnica tkwi w środowisku uruchomieniowym i jego ekosystemie: Python faworyzuje żądania lub httpx z asyncio do współbieżności i FastAPI do obsługi webhooków, podczas gdy integracje w PHP zazwyczaj korzystają z Guzzle i pasują do aplikacji Laravel z kolejkami zadań. Jeśli Twoim stakiem technologicznym jest PHP, ta sama integracja w PHP przechodzi przez każdy równoważny krok.

Masz jeszcze jakieś pytania? Nasz zespół służy pomocą.

Porozmawiaj z ekspertem
pl_PLPL
en_USEN fr_FRFR es_ESES de_DEDE it_ITIT pt_BRBR nl_NLNL tr_TRTR pl_PLPL