How to create a channel in Python with the Wapito WhatsApp API

Before you start

• pip install requests
• os.environ["WAPITO_TOKEN"]
• A channel with a WhatsApp number linked to it, and its API token. Create one in the dashboard — the authentication guide shows where the token goes.

The whole script

Every step above in one runnable file. Save it as create-channel.py, put your token in the environment, and run it.

"""Create Channel with the Wapito WhatsApp API.

List what exists, create the channel with an honest description, store its id, and delete only when you have archived the history.

Run it with:
    export WAPITO_TOKEN="wpt_..."
    python create-channel.py
"""
import os

import requests

BASE_URL = "https://api.wapito.com/v1"
TOKEN = os.environ["WAPITO_TOKEN"]

# --- List the channels this number owns ---
url = BASE_URL + "/newsletters"

querystring = {"role":"owner","count":"50","offset":"0"}

headers = {"Authorization": "Bearer " + TOKEN}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

# --- Create the channel ---
url = BASE_URL + "/newsletters"

payload = {
    "name": "Acme Release Notes",
    "description": "Every shipped change, once a week.",
    "picture": "https://acme.example/brand/channel-cover.png"
}
headers = {
    "Authorization": "Bearer " + TOKEN,
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

# --- Read it back and store the id ---
url = BASE_URL + "/newsletters/120363099887766554@newsletter"

headers = {"Authorization": "Bearer " + TOKEN}

response = requests.get(url, headers=headers)

print(response.json())

# --- Delete a channel you no longer run ---
url = BASE_URL + "/newsletters/120363099887766554@newsletter"

headers = {"Authorization": "Bearer " + TOKEN}

response = requests.delete(url, headers=headers)

print(response.status_code)

Receive the webhook

FastAPI receiver for channel — it verifies the signature, answers immediately and does the work after. Install it with pip install fastapi uvicorn and save it as webhook.py.

import hashlib
import hmac
import os
import time

from fastapi import FastAPI, Header, HTTPException, Request

app = FastAPI()
SECRET = os.environ["WAPITO_WEBHOOK_SECRET"].encode()
EVENTS = ["channel"]


def verify(raw: bytes, header: str | None) -> bool:
    """Checks the X-Wapito-Signature header: t=<ms>,v1=<hex hmac-sha256>."""
    if not header:
        return False
    parts = dict(p.split("=", 1) for p in header.split(",") if "=" in p)
    ts, sig = parts.get("t"), parts.get("v1")
    if not ts or not sig:
        return False
    if abs(time.time() * 1000 - int(ts)) > 300_000:  # 5 minute clock skew
        return False
    expected = hmac.new(SECRET, ts.encode() + b"." + raw, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, sig)


@app.post("/wapito")
async def wapito(request: Request, signature: str | None = Header(default=None, alias="X-Wapito-Signature")):
    raw = await request.body()
    if not verify(raw, signature):
        raise HTTPException(status_code=401, detail="bad signature")
    payload = await request.json()
    if payload["event"] in EVENTS:
        print(payload["event"], payload["data"])
    return {"ok": True}  # answer 2xx fast; do the real work in a queue

Errors you may hit

• engine_unsupported_feature (501)
• forbidden (403)
• engine_error (502)

Gotchas

• requests does not raise on a 4xx by itself. Call response.raise_for_status() or check response.ok, otherwise a 429 send_rate_limited silently looks like a successful send and your loop keeps hammering the queue.
• json= and data= are not interchangeable. Pass json={...} so requests sets Content-Type: application/json and encodes UTF-8 for you; data= with a dict sends form encoding and the API answers 400 invalid_request.
• The default requests timeout is None, which means a stalled connection hangs your worker forever. Always pass timeout=(5, 30) and treat a read timeout as "maybe delivered" - re-check with the message id before you send again.
• A group id such as 120363000000000000@g.us is a string, not a number. Building it with an f-string from an int drops the precision and you get 404 not_found.
• Emoji and accented text need no extra work in Python 3, but reading a CSV of numbers with the default encoding on Windows will mangle them - open files with encoding="utf-8".

Where to run it

• Google Cloud Run (container, scale to zero, one revision per deploy)
• Render background worker for the sender, Render web service for the webhook receiver
• A 1 GB VPS with systemd for the worker and Caddy in front of the FastAPI receiver
• AWS Lambda + API Gateway for the webhook receiver only (the sender needs a long-lived process for queue spacing)

Pitfalls in Python

• The word channel in the Wapito docs means your linked number, while the object these calls manage is a newsletter; a variable named channel_id that holds a newsletter id will confuse the next reader and, eventually, you. Call it newsletter_id and let the linter enforce the name.
• A script that makes a new channel on every run because it compares names case-sensitively against a list where the name was capitalised differently ends up with duplicates that cannot be merged; normalise with str.casefold before comparing, and strip trailing whitespace too.
• invite_link in the create response is nullable, and an engine that fills it only on the read-back hands you None on the first call; treat a missing link as a reason to call the read step again rather than to publish an empty string, and make the column nullable so the first insert does not fail on it.

Frequently asked questions

Related