Skip to main content
Every change a developer can notice, dated by the day it went live on tawked.com. Filter by product with the tags, or follow the RSS feed. A change that can break a working integration carries the Breaking tag.
NotificationsWebhooksBreaking
Campaigns v2

Campaigns v2: saved segments, store offers, results, follow-ups, and campaign webhooks

  • Audiences: saved segments (campaigns.segments.*, counted with campaigns.segments.count before they are saved), ready-made presets, rules on orders and engagement, and exclusions. See Campaigns.
  • The message: a goal, A/B variants, a comparison group, a coupon (one shared code, or a personal code per customer issued by the store, campaigns.coupons.show), a limited-time offer, and a follow-up to who read or tapped (campaigns.campaigns.follow_up).
  • Results: campaigns.campaigns.results, the funnel with taps and the orders and revenue the campaign brought, and campaigns.campaigns.retarget for the next campaign from one of its groups.
  • Approvals: scheduling binds every v2 field and the saved segments its audience reads; deleting a saved segment, adding a follow-up, and a Shopify or WooCommerce store’s consent or disconnection ask the person first. A new human action, store_coupon_scope, when the store has not granted Tawked the coupons permission.
  • The MCP server: two named tools, get_campaign_results and count_campaign_audience.
  • Webhooks: campaign.started, campaign.paused and campaign.completed, in a new group, campaigns, ticked by default on a new endpoint of an application that sends WhatsApp; an endpoint made before keeps the events it chose. See Webhook events.
What changes for an integration that already works. Existing webhook endpoints stop receiving the message statuses (message.sent, message.delivered, message.read, message.failed) of campaign messages, unless the application turns them on: Campaign settings in the console, or campaigns.settings.update with campaign_message_webhooks: true. The statuses of every other message are unchanged.
EmailWebhooks
Receiving email

Receive email: addresses, the API, forwarding and the email.received webhook

  • Receiving addresses: <anything>@<name>.inbound.tawked.com at once, or <anything>@inbound.<your domain> with one MX record on a subdomain of a domain you already send from. See Receiving email.
  • The API: GET /v1/email/received and GET /v1/email/received/{id} (bodies, headers, attachments, verdicts and reply_headers to thread a reply), GET /v1/email/received/{id}/raw, GET /v1/email/received/{id}/attachments/{attachment}, DELETE /v1/email/received/{id}, POST /v1/email/received/{id}/forward and GET /v1/email/inbound-addresses.
  • A new key scope, email:inbound, off on every key, full access included: switch it on for the keys that read received mail. A forward needs email:send too.
  • email.received, a new webhook event with the email’s metadata, sent to the endpoints that choose it.
  • New codes: 409 received_not_ready, 410 received_content_gone, 413 forward_too_large, 422 forward_risky_attachment.
What changes for an integration that already works. Nothing: no existing key gains email:inbound, and no existing endpoint receives email.received until you tick it.
EmailWebhooksBreaking
Tawked Email: the developer surface

The developer surface: manage Email by API, test mode, templates, tracking, previews and Standard Webhooks

  • Manage by API with a live key that holds the new, explicit email:manage: domains (/v1/email/domains), the suppression list (/v1/email/suppressions, imports included), metrics (GET /v1/email/metrics), templates and a message’s kept copy (GET /v1/email/messages/{id}/content). webhooks:manage manages the application’s webhook endpoints (/v1/webhooks). A full-access key holds neither: choose them on the key. A sending key can be limited to one domain.
  • Test mode: a tk_test_ key sends to the simulator addresses (delivered@sim.tawked.com and its siblings), with the whole flow of statuses and webhooks, nothing sent and nothing charged.
  • Templates: {{ KEY }} placeholders with fallbacks, a draft and numbered versions, sent by id or alias over the API (template) and SMTP (X-Tawked-Template).
  • Open and click tracking per domain, on your own subdomain over HTTPS; off by default.
  • Previews: an application can keep a copy of each message for its 30 days; off by default.
  • Webhooks: new events email.sent, email.delivery_delayed, email.suppressed, email.scheduled, email.canceled, email.opened, email.clicked, domain.* and suppression.*; Standard Webhooks signing beside the Tawked signature; replays; Email endpoints retried over about 27.6 hours and switched off after five days of failures.
What changes for an integration that already sends. Nothing an existing call answers changes. On the webhooks of Email: to and recipient.address carry the full address, the bodies gain type and timestamp, retries last longer, and an endpoint failing for five days is switched off with a notice. No new event or header reaches an existing endpoint until its owner adds it, and email.failed with recipient_suppressed keeps coming.
EmailWebhooksBreaking
Tawked Email

Send like Resend: recipients, batches, scheduling, headers and tags, for less

  • Up to 50 recipients a message: to takes one address or an array, and cc and bcc are honoured, each with a display name (Sara Ali <sara@example.com>), duplicates sent once, a suppressed address skipped rather than refusing the message. reply_to takes up to 10 addresses, and from a string. See Recipients.
  • headers and tags are honoured: your own headers, one-click unsubscribe among them (422 header_not_allowed for the ones Tawked sets), and up to 20 tags returned on the message and its webhooks. See Custom headers and Tags.
  • POST /v1/email/messages/batch: up to 100 messages in one call, all or nothing by default (422 batch_invalid), or Tawked-Batch-Validation: permissive.
  • Scheduling: scheduled_at up to 30 days ahead, PATCH /v1/email/messages/{id} to move it and POST /v1/email/messages/{id}/cancel to cancel it, refunded (409 message_not_scheduled once it is on its way).
  • GET /v1/email/messages lists the application’s messages, filtered by status, recipient, reference, tag and date, a page at a time.
  • The price: 3,000 emails free every month, then 100 halalas per 1,000, every recipient one e-mail. The free e-mails start after the account’s first paid top-up (a signup bonus or a team credit is not one). price_halalas is the whole halalas a message took from the balance: 0, or 1 about every tenth e-mail.
  • Limits: 5,000 e-mails a day per account by default, counted per recipient on the day it is sent, and 10 requests a second (429 rate_limited with Retry-After: 1); a send answers RateLimit-Limit, RateLimit-Remaining, RateLimit-Reset and Tawked-Daily-Remaining. The per-key limit on the e-mail endpoints is 1,200 a minute, and 429 too_many_requests now carries Retry-After on every endpoint. 503 email_platform_busy answers, rarely, when Tawked’s whole sending day is used.
  • Webhooks: one email.* event per recipient, data adding recipient and tags for a message of several; every webhook delivery, of every product, carries a tawked-webhook-id header to dedupe on. See Duplicates and order.
  • Retention: messages are kept for 30 days, then deleted; daily figures and the suppression list stay. A message’s body is kept encrypted only until it is sent.
  • Deliverability: a send that links to a host on Tawked’s list of blocked hosts answers 422 content_blocked with host (SMTP 554 5.7.1), and a rare hold on all of Tawked Email answers 503 service_unavailable (SMTP 451 4.3.0); nothing is recorded or charged. A pause after the 202 no longer fails the message at once: it stays queued and charged, is sent if the pause lifts within 12 hours of its time, and otherwise fails with queue_expired, refunded once. A domain can send from its own return path (send.<your domain>, SPF aligned), and its page reads its DMARC record. See Sender domains and Suppressed addresses.
  • SMTP: an e-mail is one message with all its recipients (To and Cc kept, Bcc hidden), your headers passed on, X-Tawked-Tags, X-Tawked-Reference and three idempotency headers read, and a clear 535 at sign-in for an account not yet granted Email. See Sending over SMTP.
What changes for an integration that already sends. A request in the original shape (one to string, no cc, bcc, tags or scheduled_at) answers exactly as before. cc, bcc, headers and tags were ignored and are now honoured, so a request that already sent a valid cc, bcc or tags now answers the extended shape (to an array, with recipients and cost) and its webhooks carry recipient; an invalid value sent with a key made before 2026-10-21 is dropped, not refused, until 2026-11-25. A message is now queued: a failure at the sending service arrives as its failed status and an email.failed webhook (new error.code values: email_paused, email_early_access, sender_not_verified, recipient_suppressed, queue_expired) instead of a 502 send_failed or a 503 for a pause at the sending service; 503 email_paused still answers at once when the application’s own sending is paused. GET right after the 202 reads accepted. An SMTP e-mail to several recipients is now one message id, with one webhook per recipient, where each recipient was its own message before.
NotificationsIntegrations
Placeholder names

A placeholder’s name is at most 20 characters

Meta approves a template whose named placeholder is longer than 20 characters, such as {{subscription_start_date}}, then refuses every message sent from it with its error 100. Tawked now stops it earlier. See Placeholder names.
  • POST /v1/whatsapp/templates and PATCH /v1/whatsapp/templates/{template_id} refuse such a name with 400 invalid_request and the reason placeholderName, as the console and the MCP server do.
  • POST /v1/whatsapp/messages from a template that already has one answers 422 unsupported_template with message long_placeholder_name. Nothing is sent or charged, where Meta’s refusal came back as a failed message before.
VerifyNotificationsIntegrations
Account API

Meta’s charges on the Account API, and Verify’s business document

  • whatsapp.charges.show (GET /v1/applications/{application}/whatsapp/charges, permission whatsapp:read): what Meta charged on the application’s WhatsApp number this month and last, by Meta’s category, with an estimate where Meta keeps the amount from Tawked (the number’s WhatsApp account is the business’s own), the number’s free replies this month, and Tawked’s own fee per template message. The console’s charges card and free replies meter, read by an agent.
  • account.document.update (PUT /v1/account/document, the owner’s alone): saves the account’s business document, a commercial registration or a freelance certificate with its number.
  • Verify now needs that document as well as the confirmed business e-mail: applications.products.add and applications.applications.create answer 409 business_document_missing for verify on an account without one, and the answer’s next names account.document.update. An account that signed up through Verify’s own door already has it.
Integrations
Account API

The Account API, and one MCP server for your agent

Everything a person does in the console is now an operation an agent or a script can call, at the same base URL with a new credential: an account token (tk_acct_), made under Settings → Account API. A token acts as the person who made it, never beyond their role, narrowed by permissions per area (read, or read and write, or *), optionally to some applications and to some IP addresses, with an optional expiry. Start with GET /v1/me (its next_steps say what is left to set up), find operations with GET /v1/operations?q=…, read one’s input with GET /v1/operations/{id}. Every operation is in the new Account API tab. See Account API, and the quickstart for Claude Code, Claude, ChatGPT, Cursor, Codex and a script.
  • When a person must act, the answer carries human_action: a stable reason, the url the person opens, the sentence to say to them, and the operation to call then. See The person in the loop.
  • Every answer says what to do next: next names the operation to call and how often to read again, following the state of what it answers, and every refusal carries one. An unknown operation or address answers did_you_mean, and GET /v1/operations/{id} says what each path parameter is and which operation lists its values; a body that is not JSON 400 invalid_json; a revoked or expired token 401 token_revoked or 401 token_expired with the link to make a new one.
  • Approvals: a token made with Ask me first (the default) answers a consequential call (it reaches customers, spends money, deletes, or cannot be undone) with HTTP 428 approval_required; a 2xx always means the operation ran. The person approves the exact request in the console, its key facts named (the application, the template, the masked recipient and the sending number, the person added, the campaign and its recipients), and the same request sent again with Tawked-Approval (and the same Idempotency-Key, if any) runs once. A call that could not run anyway (a body with fields to fix, then the operation’s own checks) is refused first, and nobody is asked to approve it.
  • Security: every call on record for 90 days (account.tokens.activity), an e-mail when a token is made, an address allowlist (403 ip_not_allowed), and Tawked-Untrusted-Content: true on answers holding text written outside the account. See Security.
  • The Tawked MCP server at https://tawked.com/mcp has one model: every connection holds an account token, made by the assistant’s sign-in (everything you can do, or read only, on the applications you choose) or typed into its settings, such as Claude Code’s --header "Authorization: Bearer tk_acct_…". Four tools reach every operation: search_tawked_api, describe_tawked_operation, read_tawked_api and call_tawked_api; the named tools for templates, messages and Verify test codes run their operations too, and are listed by the token’s permissions. call_tawked_api is always listed on /mcp, so a permission allowed mid-conversation works at once.
  • Assistants that signed in before keep only reads: their old keys became one account token with the reads of the areas they reached (Verify, WhatsApp). To let one write again, allow more on its token’s page under Settings → Account API, or sign it in again with Everything you can do.
  • Keys typed into an assistant keep working until 15 November 2026: replace them with a sign-in or an account token.
  • Application keys and the sending API are unchanged.
ChatIntegrations
Auto-attendant by API

A connected app sets up its customer’s auto-attendant

A connected app can now build the auto-attendant of its connection’s application, the menu of tappable choices that answers a new conversation on its WhatsApp number in Tawked Chat, publish it and switch it on, so the customer does nothing. See Set up the auto-attendant for your client.
  • Five calls in the Chat group of the API reference: GET /v1/chat/attendant, PUT /v1/chat/attendant/draft, POST /v1/chat/attendant/publish, PUT /v1/chat/attendant/state and PATCH /v1/chat/attendant/settings. The console and the API share one draft, and the last save wins.
  • A new scope, chat:attendant, a connected app’s alone: the customer approves it on the consent page with the app’s other permissions, and Tawked’s team extends it to the existing connections of an app the customer already approved. A business’s own key, full access included, answers these calls 403 insufficient_scope.
  • New error codes: attendant_no_draft (409), attendant_unpublished (409), sending_blocked (409, with reason payment or blocked) and attendant_not_ready (422, with the draft’s problems).
  • When a connection ends, the auto-attendant stays as it is: it is the customer’s.
ChatIntegrations
Conversation menus by API

A connected app adds conversation menus to its customer’s Tawked Chat

A connected app can now add a conversation menu, a tab beside the conversations of its connection’s application, so the customer does nothing. See Add a conversation menu for your client.
  • Five calls in a new Chat group of the API reference: GET /v1/chat/menus, POST /v1/chat/menus, GET /v1/chat/menus/{id}, PATCH /v1/chat/menus/{id} and DELETE /v1/chat/menus/{id}. An app reads and changes only the menus its connection made.
  • A new scope, chat:menus, a connected app’s alone: the customer approves it on the consent page with the app’s other permissions, and Tawked’s team extends it to the existing connections of an app the customer already approved. A business’s own key, full access included, answers these calls 403 insufficient_scope.
  • New error codes: chat_not_ready (409, with reason chat or number), menu_limit_reached (422) and chat_unavailable (503).
  • When a connection ends, the menus it made are removed from Tawked Chat. The customer sees the app’s menus in the console’s list, with the app’s name, and may edit or delete them.
NotificationsIntegrations
Document headers

Templates that open with a PDF attachment

A WhatsApp template can now open with a document, a PDF such as an invoice, a contract or an attendance sheet, and each message carries its own file. See Send a PDF attachment.
  • POST /v1/whatsapp/messages takes header.document: { "link": "https://...", "filename": "Contract-1042.pdf" }. link is required for such a template, an https link to the PDF that Meta downloads when it sends; filename is the name the customer sees. A missing or refused link answers 422 invalid_params, a header of another shape 400 invalid_request. unsupported_template no longer covers document headers; video and location headers still answer it.
  • For a connected app’s key, POST /v1/whatsapp/templates and PATCH /v1/whatsapp/templates/{template_id} take header_format (TEXT, IMAGE or DOCUMENT) and header_sample_url, the sample Meta reviews the template with. A refused sample answers 400 invalid_request with headerSampleMissing, headerSampleUnreachable, headerSampleInvalid or headerSampleTooLarge.
  • A template that opens with an image or a document is now edited over the API like a text one, with header_format in the body. Without it, the edit still answers 409 template_not_editable with status MEDIA_HEADER, as does any edit of a template that opens with a video or a location.
  • Templates made on Notifications → Templates can open with a document too.
EmailWebhooks
Tawked Email

Tawked Email: transactional e-mail from your own domain, in early access

A fourth product, in early access: apply from the application’s Email area in the console, and once Tawked’s team approves the account, verify a domain with one TXT record on Email → Setup (Tawked makes the domain’s DKIM key and the record publishes its public half), then send one message per call with POST /v1/email/messages and read it with GET /v1/email/messages/{id}, with a live key and the new email:send and email:read scopes. Until the approval a send answers 403 email_early_access. Bounces and complaints suppress the address for the account, and four new events reach the application’s webhook: email.delivered, email.bounced, email.complained and email.failed. Priced per message from the same balance, nothing monthly. See Tawked Email.A key with full access covers Email already; a custom key needs Email added, on a new key.
NotificationsIntegrations
Integration apps

Make your connected app in the console

A platform no longer writes to Tawked to have its app registered. A partner account makes its app in the console, under Integration apps: its names, its logo, its website and its return addresses, with the client id and the client secret on the app’s own page.
  • Until Tawked approves it, an app is in test mode: it connects to the applications of the account that made it, and to no other account’s.
  • The app is sent for review from its page. Tawked approves it or sends it back with the reason, and once approved any Tawked customer can connect it.
  • A change to an approved app’s name, logo, website, return addresses or Connect page waits for Tawked’s review, and the current ones keep working meanwhile.
See Before you start.
NotificationsIntegrations
Connected apps

Connected apps: a Connect button for platforms

A platform that serves many businesses can now work on its customers’ Tawked applications without a pasted key. The customer presses Connect, signs in to Tawked, chooses one application and allows the app; the platform’s server receives a credential for that one application, and the customer disconnects it from Tawked at any time. See Connected apps.
  • Four template operations on the API: GET /v1/whatsapp/templates/{template_id} reads one template in full, for any live key with notifications:read; POST /v1/whatsapp/templates, and PATCH and DELETE /v1/whatsapp/templates/{template_id}, create, edit and delete a text template, for a connected app’s key alone. A key you create, full access included, answers those three 403 insufficient_scope.
  • GET /v1/whatsapp/templates adds id and managed to each row.
  • New error codes on the template writes: template_not_managed, template_in_use, template_not_editable and template_refused.
Chat
Tawked Chat

Conversation menus in Tawked Chat

A business can show its own web page beside every conversation in Tawked Chat, on the web and in the phone app, from Chat → Conversation menus in the console. The link can carry the open customer through tokens such as {customer_phone}, and a page that loads https://tawked.com/js/tawked-chat-menu.js receives the open conversation with TawkedChat.onConversation. See Conversation menus.
VerifyPartner API
Review

A logo no longer sends a live application back to review

The logo never reaches a message, so Tawked no longer reviews it. Uploading or removing a logo on an active application keeps it active, and its codes keep sending. This holds for the console and for POST and DELETE .../logo on the Partner API, which no longer fire service.review_requested for a live application.A rejected application is the one exception: a new logo, or its removal, returns it to review, since the rejection may have been about the logo. Names and the website are reviewed as before.
BreakingPartner APIVerifyNotificationsWebhooks
Release 1.2.0

Breaking: a partner’s client applications are Verify only

A client application a partner provisions is now Tawked Verify only, and it stays the partner’s. Everything about Verify on the Partner API answers byte for byte as before. Removed:
  • The owner hand-over: GET, POST and DELETE /v1/partner/applications/{external_id}/owner, and the service.owner_invited, service.owner_accepted and service.owner_revoked events.
  • WhatsApp on client applications: GET .../{external_id}/whatsapp, the templates under .../whatsapp/templates (list, read, create, update, delete) and the team under .../whatsapp/team (list, add, remove).
  • GET /v1/partner/messages, and the message.* events on the partner webhook.
  • The owner and whatsapp blocks of an application row, and prices.whatsapp_message_halalas and owner_invite_caps of the profile.
A partner’s own applications are managed in the console, like any other account’s, and send WhatsApp with their own application keys. See Partner API.

Reasons on rejections

service.rejected carries a reason_code when Tawked rejects an application, from a fixed list, with whether the rejection may be appealed. See Partner events.

Key access by product

A key has full access, or custom access per product: verify:check, verify:send, notifications:read, notifications:send. A call outside the key’s access answers 403 insufficient_scope, with a WWW-Authenticate header that names the scope it needs. Existing keys keep exactly what they could do. See Key access.

Image headers on WhatsApp templates

A template that opens with an image now sends: pass the image’s public link in header.image.link. Such a template sent without it answers 422 invalid_params, where it answered 422 unsupported_template before. See Sending messages.

Marketing opt-outs

A MARKETING template to a recipient who asked the application to stop its marketing answers 422 consent_opted_out. Nothing is sent or charged. Utility and authentication templates still reach them.

Webhook test events and sending again

Send a test event on an application’s Webhooks page delivers a signed sample whose envelope carries "test": true. A failed delivery can be sent again from the Delivery log, so handlers should be idempotent on data.id and the event name. See Webhooks.
Notifications
Templates

Three template categories and authentication templates

Templates come in Meta’s three categories: utility, marketing and authentication. An authentication template sends a one-time code from your own WhatsApp number with one value, "params": { "code": "482913" }, of 4 to 15 letters or digits. Tawked stores the code masked. See Templates and Sending messages.Tawked is now three products on one balance: Tawked Verify, Tawked Notifications and Tawked Chat. Nothing changed under /v1.
Partner API
Partner API

The Partner API grows

A partner sandbox key, tk_partner_test_; an Idempotency-Key on every write; bulk provisioning; archiving and restoring; a verification log; and an event feed with webhooks you subscribe to by event. See Partner API.
The message log, the WhatsApp templates and the team over the Partner API, also announced in this release, were removed on 2026-10-04.
Notifications
Notifications

Connect your own WhatsApp number

Connect your WhatsApp Business Account from the console through Meta’s Embedded Signup. The account stays yours, and Meta bills you directly for its messages.
NotificationsWebhooks
Notifications

WhatsApp template messages over the API

POST /v1/whatsapp/messages sends an approved template from your application’s number with the same key, and its statuses reach your webhook as signed message.* events.
VerifyWebhooks
Verify

The verification lifecycle, idempotency, protection and webhooks

  • GET /v1/verify/{id}, POST /v1/verify/{id}/resend and POST /v1/verify/{id}/cancel complete the lifecycle.
  • start accepts an Idempotency-Key header, a reference and autofill-ready messages.
  • Per-application spend caps and per-IP limits guard against SMS pumping.
  • Keys can carry an expiry and an IP allowlist, and a check-only key could be created. Check-only keys became the custom access of 2026-10-04.
  • Each application can receive signed webhooks for verified, failed and expired verifications.
Partner APIWebhooks
Partner API

Partner webhooks

service.approved, service.rejected, service.suspended and balance.low are delivered to the partner’s webhook, signed with its secret. The reference gained GET /v1/partner/services and POST .../resume.
BreakingVerify
Verify

Verification over SMS only

The email verification channel and the old notifications product stopped. POST /v1/messages answers 410 product_retired. Account data and balances were untouched.
Verify
Verify

A per-key rate limit

The /v1/verify endpoints limit each key to 120 requests per minute, and every response carries security headers.
Verify
Verify

The sandbox

tk_test_ keys call the same endpoints with the same shapes before the application is approved. Codes are real, stamped [TEST], and reach the account owner’s phone only. Today you create the test key yourself, under Application settings → API keys. See Testing and the sandbox.
VerifyPartner API
Verify

Verify settings per application, and the partner platform

Code length from 4 to 8 digits, a lifetime from 1 to 15 minutes, 1 to 5 attempts and an hourly cap per number, set in the console only, so a leaked key cannot weaken them.Platforms got one account that creates an application per merchant with POST /v1/partner/services.
Verify
Platform

Several applications on one account

One account holds several applications, each with its own keys and logs, sharing one balance.
Verify
Launch

Tawked Verify

POST /v1/verify/start and POST /v1/verify/check, API keys and a prepaid balance.
Last modified on October 29, 2026