README

Tawked for Laravel

Tawked for Laravel 11, 12 and 13. Send your Mailables as transactional email from your own domain through the tawked mail transport, send WhatsApp Business API template messages as Laravel notifications, send and check SMS OTP codes for Saudi mobile numbers with a validation rule for the number, receive Tawked's signed webhooks as Laravel events, and test all of it with Tawked::fake(). Built on tawked/tawked-php.

Tawked (توكيد) is a Saudi messaging platform at tawked.com and a Meta Tech Provider: businesses send WhatsApp Business API notifications from their own number and SMS OTP verification codes, and answer customers in Tawked Chat, a shared WhatsApp inbox for teams. Tawked Email, in early access, sends a business's mail from its own domain.

Documentation · API reference · Changelog · Pricing

Installation

composer require tawked/laravel

The service provider and the Tawked facade register themselves. Put your key in .env:

TAWKED_API_KEY=tk_live_...
TAWKED_WEBHOOK_SECRET=...   # only if you receive webhooks

To change the defaults (timeouts, retries, the webhook route), publish the config file:

php artisan vendor:publish --tag=tawked-config

Before you start

Sign up and create an application in the console.
Create an API key on your application's API keys page: tk_live_…, or tk_test_… before your application is approved (see Testing). Put it in TAWKED_API_KEY. Authentication and keys.
Every product draws on one prepaid balance in Saudi riyals: pricing.
The Account API takes an account token (tk_acct_…) and the Partner API a partner key (tk_partner_…): each is named in its section.

Quick start

Phone sign-in with an SMS code: one route sends the code, a second checks it.

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Tawked\Laravel\Facades\Tawked;
use Tawked\Laravel\Rules\SaudiMobile;

class PhoneSignInController extends Controller
{
    // 1. Send a code by SMS. Any Saudi mobile format works: 0512345678, +966512345678, ٠٥١٢٣٤٥٦٧٨.
    public function send(Request $request)
    {
        $request->validate(['phone' => ['required', new SaudiMobile()]]);

        $started = Tawked::sendCode($request->input('phone'));
        session(['verification_id' => $started->id]);

        return back();
    }

    // 2. Check the code the person typed.
    public function check(Request $request)
    {
        $result = Tawked::checkCode(session('verification_id'), $request->input('code'));

        if (! $result->verified) {
            // invalid_code, too_many_attempts, expired, canceled or failed
            return back()->withErrors(['code' => $result->status]);
        }

        return redirect('/home');
    }
}

Tawked makes the code, sends it and checks it: you never see the code. A wrong or late code is an answer, not an exception: read verified. Keep the key on your server: see Security.

What you can do

Task	Call	Docs
Send your Mailables through Tawked Email	`MAIL_MAILER=tawked`	Email messages
Send a WhatsApp template message as a notification	`via()` returns `['tawked']`, `TawkedWhatsAppMessage`	WhatsApp messages
Send an SMS OTP code to a Saudi mobile number	`Tawked::sendCode()`	Quickstart
Check the code the user typed	`Tawked::checkCode()`	Sign-in flow
Validate a Saudi mobile number	`new SaudiMobile()`, `'saudi_mobile'`	Number formats
Receive webhooks as Laravel events	`EmailEventReceived`, `MessageEventReceived`, `VerificationEventReceived`, `PartnerEventReceived`	Webhooks
Fake Tawked in your tests	`Tawked::fake()`, `assertCodeSent()`, `assertMessageSent()`, `assertEmailSent()`
Add your app's menu to Tawked Chat (connected app)	`Tawked::chat()->menus->create()`	Chat menus
Run anything the console does, for a script or an AI agent	`Tawked::account()`	Account API

Requirements

Laravel	PHP
13	8.3 or newer
12	8.2 or newer
11	8.2 or newer

Built on tawked/tawked-php ^0.1; Symfony Mailer 7 or 8.

Configuration

Every option has an environment variable; the config file (config/tawked.php) is needed only to change one in code.

Config key	Environment	Default	Notes
`api_key`	`TAWKED_API_KEY`		An application key, a partner key or a connected app's key
`account_token`	`TAWKED_TOKEN`		The Account API's token, for `Tawked::account()`
`account_language`	`TAWKED_ACCOUNT_LANGUAGE`		`ar` or `en`: the language of the Account API's messages
`base_url`	`TAWKED_BASE_URL`	`https://tawked.com`	Change it only for a local stand-in in tests
`timeout`	`TAWKED_TIMEOUT`	`30`	Seconds per try
`connect_timeout`	`TAWKED_CONNECT_TIMEOUT`	`10`	Seconds
`max_retries`	`TAWKED_MAX_RETRIES`	`2`	More tries for a call that is safe to repeat
`webhook.secret`	`TAWKED_WEBHOOK_SECRET`		One or more secrets, separated by commas
`webhook.tolerance`	`TAWKED_WEBHOOK_TOLERANCE`	`300`	Seconds; `none` turns the check off
`webhook.path`	`TAWKED_WEBHOOK_PATH`	`tawked/webhook`	`null` turns the route off

Each call also takes options as its last array: idempotency_key, timeout, max_retries and headers.

use Tawked\Laravel\Facades\Tawked;

Tawked::sendCode('0512345678', ['reference' => 'signin-7781'], ['idempotency_key' => 'signin-7781', 'timeout' => 10]);

After a timeout, call again with the same idempotency_key, never a new one: if the first call went through, Tawked answers its result and nothing is sent or charged twice. Which calls are retried, and how: tawked/tawked-php and Reliability.

Tawked Email (Early Access)

Tawked's team opens Email for an account on request, from the console. Until then every Email call answers email_early_access.

Set the mailer, and every mail Laravel sends is one call to Tawked:

MAIL_MAILER=tawked
MAIL_FROM_ADDRESS=orders@acme.sa     # an address on your verified domain
MAIL_FROM_NAME="متجر أكمي"

No entry in config/mail.php is needed (add 'tawked' => ['transport' => 'tawked'] there to give it options). The mailer sends with TAWKED_API_KEY, or with services.tawked.key when mail has a key of its own.

use Illuminate\Support\Facades\Mail;

Mail::to('sara@example.com')->send(new OrderConfirmation($order));

To, Cc, Bcc, Reply-To, the From name and address, the HTML and text bodies and the attachments (inline images by their content id) all go in that one call. Your own headers go as they are; Tawked refuses the ones it sets itself (From, Message-ID, any X-Tawked- header, ...) with 422 header_not_allowed, which the transport throws as a TransportException naming the header.

A Mailable's tags and metadata become Tawked's tags, returned on the message and its webhooks and filterable in the list. The X-Tawked-Idempotency-Key header gives a mail a key of your own (it is taken off before sending):

use Illuminate\Mail\Mailable;
use Illuminate\Mail\Mailables\Envelope;
use Illuminate\Mail\Mailables\Headers;

class OrderConfirmation extends Mailable
{
    public function __construct(public Order $order) {}

    public function envelope(): Envelope
    {
        return new Envelope(
            subject: 'طلبك رقم 1042 قيد التجهيز',
            tags: ['order-confirmation'],        // {name: 'order-confirmation', value: 'true'}
            metadata: ['order' => '1042'],       // {name: 'order', value: '1042'}
        );
    }

    public function headers(): Headers
    {
        return new Headers(text: ['X-Tawked-Idempotency-Key' => 'order-'.$this->order->id.'-confirmation']);
    }
}

Each tag name and value is 1 to 256 ASCII letters, digits, _ or -, a tag is never named like a metadata key, and Tawked accepts at most 20 on a message: anything else is refused before sending.

Sending twice never sends twice. Every mail carries an Idempotency-Key. Inside a queued job (a queued Mailable or notification, or your own job) it is made from the job's id, the recipients and the subject, the same on every attempt, so a job retried after a timeout gets Tawked's first answer instead of a second email. A job that sends other mails on a retry should give each the X-Tawked-Idempotency-Key of its business event, as above.

Tawked's id of the message is on the sent message:

use Illuminate\Support\Facades\Mail;
use Tawked\Laravel\Facades\Tawked;

$sent = Mail::to('sara@example.com')->send(new OrderConfirmation($order));
$id = $sent->getSymfonySentMessage()->getOriginalMessage()->getHeaders()->getHeaderBody('X-Tawked-Email-Id');

Tawked::email()->messages->get($id)->status;   // accepted, sent, delivered, bounced or failed (each recipient's own in recipients)

Without a Mailable, send through Tawked::email(). The sender is an object of a name and an address:

use Tawked\Laravel\Facades\Tawked;

$sent = Tawked::email()->messages->send([
    'from' => ['name' => 'متجر أكمي', 'address' => 'orders@acme.sa'],
    'to' => 'sara@example.com',
    'subject' => 'طلبك رقم 1042 قيد التجهيز',
    'html' => '<p>استلمنا طلبك رقم 1042.</p>',
    'text' => 'استلمنا طلبك رقم 1042.',
    'scheduled_at' => now()->addHours(2),
], ['idempotency_key' => 'order-1042-confirmation']);

Tawked::email()->messages->update($sent->id, ['scheduled_at' => now()->addHours(3)]);
Tawked::email()->messages->cancel($sent->id);

The rest of Tawked Email is on Tawked::email():

messages: sendBatch() (Tawked accepts up to 100 emails per batch, under one key), list() and iterate(), get(), content();
domains, templates, suppressions and metrics: your sending domains, stored templates, the suppression list and the delivery figures;
inbound: received email, with list(), iterate(), get(), raw(), forward(), delete(), and test() to simulate one with a test key;
checkKey(): whether this key can send.

Tawked accepts up to 10 attachments on a message, 10 MiB in all. Senders and domains: Email senders; sending over SMTP instead: SMTP.

Tawked Verify

SMS OTP codes for Saudi mobile numbers, with your application's key. Sending and checking are in the Quick start; the whole of Tawked Verify is on Tawked::verify(): start(), check(), get(), resend() and cancel().

use Tawked\Laravel\Facades\Tawked;
use Tawked\Laravel\Rules\SaudiMobile;

$request->validate(['phone' => 'required|saudi_mobile']);   // the rule by name
SaudiMobile::normalize('٠٥١٢٣٤٥٦٧٨');                         // +966512345678

$id = session('verification_id');
Tawked::verify()->get($id)->status;     // the verification as it stands
Tawked::verify()->resend($id);          // a new code on the same id; the previous one stops working
Tawked::verify()->cancel($id);

The rule accepts every format the API accepts (0512345678, +966512345678, Arabic-Indic digits, ...). Number formats.

WhatsApp Business API

WhatsApp template messages to your customers from your business's own number, with your application's key. Add the tawked channel and a toTawked() method to a notification:

use Illuminate\Notifications\Notification;
use Tawked\Laravel\Notifications\TawkedWhatsAppMessage;

class OrderShipped extends Notification
{
    public function __construct(public Order $order) {}

    public function via(object $notifiable): array
    {
        return ['tawked'];
    }

    public function toTawked(object $notifiable): TawkedWhatsAppMessage
    {
        return TawkedWhatsAppMessage::template('order_shipped')
            ->language('ar')
            ->variables(['name' => $this->order->customer_name, 'order' => $this->order->number])
            ->reference('order-'.$this->order->id);
    }
}

Send it to a user, or to a number with no user behind it:

use Illuminate\Support\Facades\Notification;

$user->notify(new OrderShipped($order));
Notification::route('tawked', '0512345678')->notify(new OrderShipped($order));

The number is the message's ->to(), else the notifiable's routeNotificationForTawked(), else its phone (then phone_number) attribute. With no number the notification is skipped for that notifiable. A message also takes ->headerText(), ->headerImage($httpsLink), ->button($index, $parameter) and, with a partner key, ->application($externalId).

Each send carries an Idempotency-Key made from the notification's id and the number, so a queued notification retried after a failure is never sent twice. Set your own with ->idempotencyKey(), or drop it with ->withoutIdempotencyKey().

Read messages and templates with Tawked::whatsapp():

use Tawked\Laravel\Facades\Tawked;

Tawked::whatsapp()->messages->get($id)->status;   // accepted, sent, delivered, read or failed
$templates = Tawked::whatsapp()->templates->list();   // each with its id, its placeholders and `managed`
$template = Tawked::whatsapp()->templates->get($templates->data[0]->id);   // status, quality, components, examples

One template id is one language of a template. Meta reviews every template before it can be sent.

Connected apps' keys only. Creating, editing and deleting a template are for the key a business's approved connection hands an app. Your application's own key, full access included, cannot do this; it gets insufficient_scope (an InsufficientScopeException whose requiredScope() is notifications:templates). An app built on Laravel holds one key per connection and makes a client for it:

use Tawked\TawkedClient;

$connection = new TawkedClient($connectionKey);   // the key of one business's connection

$created = $connection->whatsapp->templates->create([
    'name' => 'order_shipped_v1',
    'language' => 'ar',
    'category' => 'UTILITY',
    'body' => 'طلبك رقم {{1}} في الطريق إليك.',
    'examples' => ['body:1' => '1042'],   // one sample per placeholder: Meta reviews with them
], ['idempotency_key' => 'template-order-shipped-v1']);

$connection->whatsapp->templates->update($created->id, [   // the whole new content; Meta reviews it again
    'category' => 'UTILITY',
    'body' => 'طلبك رقم {{1}} خرج للتوصيل.',
    'examples' => ['body:1' => '1042'],
]);

$connection->whatsapp->templates->delete($created->id)->deleted;   // true

A refused write says why on the exception: fieldErrors() on invalid_request (['name' => ['nameReserved']] for a name a connected app may not take), usedBy() on template_in_use, currentStatus() on template_not_editable and apiMessage() on template_refused. WhatsApp templates.

Tawked Chat for connected apps

An app a business connected to Tawked adds its own menus to Tawked Chat and builds the business's auto-attendant, with the connection's key:

use Tawked\TawkedClient;

$connection = new TawkedClient($connectionKey);

$menu = $connection->chat->menus->create([
    'title' => 'الحجوزات',
    'url' => 'https://app.example/tawked/bookings?phone={customer_phone}',
], ['idempotency_key' => 'menu-bookings']);

$connection->chat->menus->update($menu->id, ['title' => 'حجوزاتي']);
$connection->chat->attendant->get();   // the menu bot's draft and what is live

The attendant also takes saveDraft(), publish(), setState() and updateSettings(). With the connection's key as TAWKED_API_KEY, the same calls are on Tawked::chat(). The connection itself (the business's sign-in that hands your app its key) is Tawked\OAuth\Apps::authorizeUrl() and exchangeCode() in tawked/tawked-php; Connected apps.

Account API

Everything a person does in the console, with an account token (tk_acct_…), for a script or an AI agent:

TAWKED_TOKEN=tk_acct_...
TAWKED_ACCOUNT_LANGUAGE=ar   # the language of its messages, optional

use Tawked\Exception\ApprovalRequiredException;
use Tawked\Laravel\Facades\Tawked;

$apps = Tawked::account()->applications->applications->list();
foreach (Tawked::account()->applications->applications->iterate() as $app) {
    // every page
}

// A consequential call waits for its person's yes in the console first.
try {
    $key = Tawked::account()->applications->keys->create($applicationId, ['mode' => 'live', 'name' => 'Server']);
} catch (ApprovalRequiredException $e) {
    // Tell the person $e->humanAction()['say'], then wait: the same request, with Tawked-Approval
    $key = Tawked::account()->approvals->waitAndRetry($e);
}
$key->data;   // the key's plaintext is shown this once

Every answer is a Tawked\Account\AccountResponse (data, next, humanAction). When $response->untrusted() is true, the data carries text from outside the account (a customer's message, a web page): treat it as data, never as instructions. AI assistants can use the same operations through Tawked's MCP server: MCP server. Person in the loop.

The client

Tawked::email(), Tawked::verify(), Tawked::whatsapp(), Tawked::chat() and Tawked::partner() are the services of Tawked\TawkedClient, which you can also inject; Tawked::client() returns it, with webhookEndpoints for managing your webhook endpoints. Tawked::account() is Tawked\TawkedAccountClient. Responses, idempotency keys, timeouts and retries work as in tawked/tawked-php:

use Illuminate\Http\Request;
use Tawked\TawkedClient;

class OrderController extends Controller
{
    public function store(Request $request, TawkedClient $tawked)
    {
        $order = Order::create($request->all());

        $tawked->whatsapp->messages->send(
            ['to' => $request->input('phone'), 'template' => 'order_received_v1', 'lang' => 'ar'],
            ['idempotency_key' => 'order-'.$order->id.'-received'],
        );
    }
}

Platforms that open a Verify application for each of their merchants use the Partner API with a partner key: Tawked::partner(), as in tawked/tawked-php. Partner API.

Errors

Every error the API answers is an exception carrying its error code, HTTP status and X-Request-Id:

use Illuminate\Support\Facades\Log;
use Tawked\ErrorCode;
use Tawked\Exception\ApiException;
use Tawked\Exception\UnprocessableEntityException;
use Tawked\Laravel\Facades\Tawked;

try {
    Tawked::sendCode($phone);
} catch (UnprocessableEntityException $e) {
    if ($e->errorCode === ErrorCode::INVALID_DESTINATION) {
        // ask for a Saudi mobile number
    }
} catch (ApiException $e) {
    Log::warning("Tawked {$e->errorCode} ({$e->statusCode}), request {$e->requestId}");
}

The exceptions by status are listed in tawked/tawked-php, every error code in Errors.

Webhooks

With TAWKED_WEBHOOK_SECRET set, the package answers POST /tawked/webhook: it checks each delivery's signature and timestamp, dispatches TawkedWebhookReceived and the event of its family, and answers 200. Point your webhook at https://your-app.example/tawked/webhook in the console and listen to the family you handle:

use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Log;
use Tawked\Laravel\Events\EmailEventReceived;
use Tawked\Laravel\Events\TawkedWebhookReceived;

Event::listen(function (EmailEventReceived $received) {
    if ($received->name() === 'email.bounced') {
        // $received->event->data['id'], and data['recipient'] on a message of several recipients
    }
});

Event::listen(function (TawkedWebhookReceived $received) {
    Log::info('Tawked webhook', ['event' => $received->name(), 'test' => $received->isTestMode()]);
});

Event	Carries
`EmailEventReceived`	Tawked Email's `email.`, `domain.` and `suppression.*`
`EmailReceivedEventReceived`	`email.received`: a received email, never a sent message's outcome
`MessageEventReceived`	WhatsApp's `message.*`
`VerificationEventReceived`	Tawked Verify's `verification.*`
`PartnerEventReceived`	an application's `service.*`, and `balance.low`

Deliveries arrive at least once: make your listener idempotent on $received->webhookId() (the tawked-webhook-id header, or webhook-id). Webhook events.

Both of Tawked's signature schemes are checked: tawked-signature with your webhook's secret, and Standard Webhooks (webhook-signature) with a secret that starts whsec_. The secrets decide the scheme, never the headers that arrive: with a whsec_ secret only webhook-signature is checked, otherwise tawked-signature. Give the secrets of the endpoint this route serves, separated by commas, which is also how you rotate one (the old and the new are both accepted):

TAWKED_WEBHOOK_SECRET=old-secret,new-secret

Never mix the secrets of two endpoints signed with different schemes on one route. Give the other endpoint (the partner webhook, or one without Standard signing) a route of its own, with its secrets under another config key named as the middleware's parameter, and read the verified event there:

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
use Tawked\Laravel\Http\Middleware\VerifyTawkedWebhook;

Route::post('/webhooks/tawked-partner', function (Request $request) {
    $event = VerifyTawkedWebhook::event($request);
    $id = VerifyTawkedWebhook::webhookId($request);   // the same on every retry

    return response()->noContent();
})->middleware('tawked.webhook:services.tawked.partner_webhook_secret');

The route sits outside the web group, so CSRF does not apply. Change its address with TAWKED_WEBHOOK_PATH, or turn it off with 'path' => null in the config. A delivery whose signature does not match is refused. Deliveries older than five minutes are refused too (TAWKED_WEBHOOK_TOLERANCE, none turns the check off). Both are answered 403 with the reason.

Testing

Tawked::fake() swaps the client for one that never reaches Tawked. Every call is recorded and answered from the API's documented examples, through the real client, so your code gets the same typed objects and exceptions it gets in production. Mail through the tawked mailer, Chat menus and the Account API are faked as well:

use Tawked\Laravel\Facades\Tawked;
use Tawked\Laravel\Testing\RecordedRequest;
use Tests\TestCase;

class CheckoutTest extends TestCase
{
    public function test_the_code_is_sent(): void
    {
        Tawked::fake();

        $this->post('/login/phone', ['phone' => '0512345678']);

        Tawked::assertCodeSent('+966512345678');   // any format of the number
        Tawked::assertMessageNotSent();
    }

    public function test_the_customer_hears_about_the_order(): void
    {
        Tawked::fake();

        $this->post('/orders/1042/ship');

        Tawked::assertMessageSent('order_shipped', to: '0512345678');
        Tawked::assertMessageSent(fn (array $body) => $body['params']['order'] === '1042');
        Tawked::assertEmailSent('sara@example.com', 'طلبك رقم 1042 قيد التجهيز');
        Tawked::assertEmailSent(fn (array $email) => in_array(
            ['name' => 'order', 'value' => '1042'],
            $email['tags'] ?? [],
            true,
        ));
        Tawked::assertSent('chat-menu-update', fn (RecordedRequest $r) => $r->input('title') === 'حجوزاتي');
    }
}

Answer an endpoint your own way, by METHOD /path (with * wildcards) or by its name:

use Tawked\Laravel\Facades\Tawked;
use Tawked\Laravel\Testing\RecordedRequest;

Tawked::fake([
    'POST /v1/verify/check' => Tawked::example('check', 'Wrong code'),
    'POST /v1/whatsapp/messages' => Tawked::error('insufficient_credits'),
    'resend' => Tawked::error('resend_limit_reached'),
    'whatsapp-template-create' => Tawked::error('insufficient_scope'),   // any key but a connected app's
    'check' => fn (RecordedRequest $request) => $request->input('code') === '424242'
        ? ['verified' => true, 'status' => 'verified']
        : null,   // null: the next stub, then the documented example
]);

The fake does not judge whose key it is: stub the refusal a key would get. The Account API publishes no example answers: its operations answer {"data": {}} (a list {"data": [], "next_cursor": null}) unless you stub them by their operation id, such as 'applications.applications.show' => ['data' => [...]].

Assertion	Checks
`assertEmailSent($to, $subject, $times)`	An email was sent, or a closure over its body matched; each email of a batch counts
`assertEmailNotSent()`	No email was sent
`assertMenuCreated($title, $times)`	A Tawked Chat menu was created
`assertCodeSent($to, $times)`	A Verify code was sent to the number, in any format
`assertCodeNotSent()`	No code was sent
`assertCodeChecked($id, $code)`	A code was checked
`assertCodeNotChecked()`	No code was checked
`assertMessageSent($template, $to, $times)`	A WhatsApp template message was sent, or a closure over its body matched
`assertMessageNotSent()`	No WhatsApp message was sent
`assertNothingSent()`	No call reached the fake
`assertSent($endpoint, $callback, $times)`	A request to an endpoint by its id (`email-send`, `chat-menu-update`, `partner-provision`, an Account operation id), or a closure over every request
`assertNotSent($endpoint, $callback)`	No such request was made
`assertSentCount($n)`	The number of requests made
`recorded()`	The requests themselves, as `RecordedRequest`

A request that repeats an Idempotency-Key gets the first answer again and is not counted as a send; another body under the same key gets 409 idempotency_key_reused, as from Tawked.

What a test key (tk_test_…) does depends on the product:

Verify: a test key sends real codes, charged, to the phone the account owner verified at signup only, stamped [TEST], and at most 10 per application (Tawked's limit).
WhatsApp: refuses every test key (live_key_required).
Email: a test key sends in test mode. Nothing reaches anyone and nothing is charged; only the simulator addresses at sim.tawked.com are accepted. More in Test keys.

To run against a local stand-in for the API of your own instead, set TAWKED_BASE_URL.

Versioning

This package follows Semantic Versioning. Before 1.0, a minor release may change the public API and lists what changed under Breaking in the changelog; a patch adds endpoints and fixes. Before 1.0 it is released with every minor of tawked/tawked-php and may release patches of its own.

Security

Your API key and account token are server-side secrets. Keep them in .env, never in a browser, a mobile app or your repository. The client never logs or prints them.

To report a vulnerability, do not open a public issue. Report it privately through GitHub's private vulnerability reporting (the Report a vulnerability button on this repository's Security tab), or by email to support@tawked.com with "Security" in the subject. Include the package and its version, the impact and the steps to reproduce, and never a real key or customer data. We reply to every report.

Support and contributing

Help with your account or your integration: support@tawked.com and the documentation. Service status: tawked.com/en/status.
A bug in this package, a wrong example or a version that fails: open an issue with the package version, your Laravel and PHP versions, and the X-Request-Id of a failing call, never a key.
This repository is a read-only mirror: the package is developed in Tawked's own repository beside the API it calls, and every release is published here from there. A pull request is read as a proposal; if we take the change, we make it there and credit you as a co-author.
CI in this repository runs the unit and feature tests on Laravel 11, 12 and 13 across PHP 8.2 to 8.5, at the lowest and the highest dependencies and against the newest tawked/tawked-php, with static analysis and the code style check. The tests that read the API's contract run in Tawked's repository before every release.

For assistants: docs.tawked.com/llms.txt, llms-full.txt, and what Tawked is in one file: tawked.com/llms.txt.

License

MIT. See LICENSE.

tawked / laravel

Package info

Security

Statistics

README

Tawked for Laravel

Installation

Before you start

Quick start

What you can do

Requirements

Configuration

Tawked Email (Early Access)

Tawked Verify

WhatsApp Business API

Tawked Chat for connected apps

Account API

The client

Errors

Webhooks

Testing

Versioning

Security

Support and contributing

License