composer require cloudme/notify-laravel

NOTIFY_ENVIRONMENT=sandbox
NOTIFY_CLIENT_ID=your_client_id
NOTIFY_API_KEY=your_api_key
NOTIFY_PRIVATE_KEY_PATH=storage/app/notify/private.pem
NOTIFY_TOKEN_STORE=cache
NOTIFY_LOCALE=uz

php artisan notify:doctor

Environment ........ sandbox
Base URL ........... https://sandbox.notify.cloudme.uz/api/v1
Client ID .......... configured
API key ............ configured
Private key file ... readable
Token store ........ cache
Cache store reachable  yes

All checks passed. No messages were sent.

use CloudMe\Notify\NotifyClient;

$notify = app(NotifyClient::class);

$response = $notify->sms()->send(
    '+998901234567',
    'Salom! Bu CloudMe Notify orqali yuborilgan SMS.'
);

use CloudMe\NotifyLaravel\Facades\Notify;

Notify::sms()->send(
    '+998901234567',
    'Salom! Bu CloudMe Notify orqali yuborilgan SMS.'
);

$response->messageId;
$response->status;
$response->price;
$response->currency;
$response->balance;
$response->environment;

$status = $notify->message($response->messageId);

$status->messageId;
$status->channel;
$status->recipient;
$status->status;
$status->smsType;
$status->price;
$status->currency;
$status->errorCode;
$status->createdAt;
$status->sentAt;
$status->deliveredAt;
$status->environment;

$balance = $notify->balance();

$balance->balance;
$balance->reservedBalance;
$balance->currency;

$response = Notify::sms()->send('+998901234567', 'Yozgi chegirma -50%!');

$response->status;                // "moderation"
$response->isHeldForModeration(); // true

Notify::message($response->messageId)->isRejected();

use CloudMe\Notify\Exceptions\RateLimitException;
use CloudMe\NotifyLaravel\Facades\Notify;

// 1. Kod yuborish - otp_id ni saqlab qo'ying
try {
    $otp = Notify::otp()->send(to: '+998901234567'); // channel: 'sms' | 'telegram' | 'whatsapp' | 'email'
} catch (RateLimitException $e) {
    // OTP_RESEND_TOO_SOON - $e->retryAfterSeconds
}

session(['otp_id' => $otp->otpId]);

$otp->codeLength;  // 6
$otp->expiresIn;   // 300
$otp->maxAttempts; // 3
$otp->code;        // production'da null, sandbox'da kodning o'zi (test uchun)

// 2. Foydalanuvchi kiritgan kodni tekshirish
$result = Notify::otp()->verify(session('otp_id'), $request->code);

if ($result->verified) {
    // telefon tasdiqlandi
} elseif ($result->canRetry()) {
    // kod noto'g'ri - $result->attemptsLeft ta urinish qoldi
} else {
    // muddati o'tgan / urinishlar tugagan / ishlatilgan - yangi kod yuboring
}

POST /api/v1/otp/send
{ "to": "998901234567", "channel": "sms" }

200 { "otp_id": "0f6c1a52-...", "status": "pending", "code_length": 6,
      "max_attempts": 3, "expires_in": 300, "message_id": "...", "price": "120.0000" }

POST /api/v1/otp/verify
{ "otp_id": "0f6c1a52-...", "code": "481201" }

200 { "verified": true, "status": "verified" }
422 { "verified": false, "attempts_left": 2, "error": { "code": "OTP_INVALID" } }

$notify->telegram()->send(to: "998901234567", message: "Hello", channelAccountId: 7);
$notify->push()->registerDevice("998901234567", $fcmToken, channelAccountId: 12);
$notify->push()->send(to: "998901234567", message: "Hello", channelAccountId: 12);
NotifyMessage::make()->channel("telegram")->channelAccount(7)->message("Hello");

$notify->telegram()->send('123456789', 'Buyurtmangiz tayyor.');

$binding = $notify->telegram()->bindingLink('+998901234567');
if (! $binding->bound) {
    $notify->sms()->send('+998901234567', "Telegram: {$binding->link}");
}

$notify->whatsapp()->send('+998901234567', 'Buyurtmangiz tayyor.');

$notify->voice()->call('+998901234567', 'Sizning buyurtmangiz tayyor.');

$notify->email()->send(
    to: 'customer@example.com',
    message: 'Buyurtmangiz tayyor.',
    subject: 'Buyurtma holati'
);

$notify->push()->send(
    to: '+998901234567',
    message: 'Buyurtmangiz tayyor.',
    subject: 'Buyurtma tayyor'
);

$notify->push()->registerDevice(
    phone: $user->phone,
    fcmToken: $request->fcm_token
);

$notify->sms()->send(
    to: '+998901234567',
    templateId: 42,
    variables: ['name' => 'Aziz', 'order_id' => '10293']
);

foreach ($notify->templates()->list('sms') as $template) {
    $template->id;        // templateId
    $template->variables; // ['name', 'order_id']
}

$notify->sms()->send(
    to: '+998901234567',
    message: 'Buyurtmangiz tayyor.',
    idempotencyKey: (string) $order->id
);

use Illuminate\Support\Carbon;

$notify->reports()->daily(Carbon::today()->subDays(7), Carbon::today());
$notify->reports()->monthly();

Notify::telegram()->send(
    to: '+998901234567',
    message: "<b>Buyurtmangiz tayyor</b>\nModel: DAF XF106",
    photoUrl: 'https://example.com/photos/order.jpg',
);

// Laravel Notification
NotifyMessage::make()
    ->channel('whatsapp')
    ->message('*Buyurtmangiz tayyor*')
    ->photo('https://example.com/photos/order.jpg');

$debt = Notify::debts()->create(
    name: 'Aziz Karimov',
    phone: '+998901234567',
    amount: 1250000,
    dueDate: '2026-10-15',
    externalId: 'INV-1001',
);

$debt->id;             // "0f6c1a52-..."
$debt->nextReminderAt; // "2026-10-16T10:00:00+05:00"

$result = Notify::debts()->recordPayment($debt->id, 1250000, externalId: 'PAY-5001');

$result->debt->isPaid();             // true
$result->payment->attributedChannel; // "sms"
$result->payment->daysLate;          // 2

Notify::debts()->find($debt->id)->payments;
Notify::debts()->cancel($debt->id);

use CloudMe\Notify\ScheduledMessages\Recurrence;

$schedule = Notify::scheduledMessages()->create(
    channel: 'sms',
    startsAt: '2026-10-06T10:00:00+05:00',
    recipient: '+998901234567',
    message: 'Eslatma: bugun soat 15:00 da uchrashuv',
);

$schedule->id;        // "7b1e0c4a-..."
$schedule->nextRunAt; // "2026-10-06T10:00:00+05:00"

Notify::scheduledMessages()->create(
    channel: 'telegram',
    startsAt: '2026-10-05T09:00:00+05:00',
    contactGroupId: 12,
    message: 'Salom, {{name}}! Haftalik yangiliklar...',
    recurrence: Recurrence::weekly([1, 4]), // Recurrence::every(2, 'hours'), Recurrence::monthly([1, 15])
);

Notify::scheduledMessages()->update($schedule->id, channel: 'sms', startsAt: '2026-10-07T10:00:00+05:00', recipient: '+998901234567', message: 'Uchrashuv ertaga');
Notify::scheduledMessages()->pause($schedule->id);
Notify::scheduledMessages()->resume($schedule->id);
Notify::scheduledMessages()->cancel($schedule->id);
Notify::scheduledMessages()->list(status: 'active')->items;

// .env
NOTIFY_WEBHOOK_SECRET=whsec_xxxxxxxxxxxxxxxx

// routes/web.php
Route::post('/webhooks/notify', NotifyWebhookController::class)->middleware('notify.webhook');

// NotifyWebhookController
use CloudMe\NotifyLaravel\Http\Middleware\VerifyNotifyWebhook;

public function __invoke(Request $request)
{
    $event = VerifyNotifyWebhook::event($request);

    // $event->id, $event->event, $event->messageId, $event->status, $event->errorCode
    if ($event->event === 'message.failed') {
        // ...
    }

    return response()->noContent();
}

use CloudMe\Notify\Exceptions\InsufficientBalanceException;
use CloudMe\Notify\Exceptions\ValidationException;
use CloudMe\Notify\Exceptions\RateLimitException;

try {
    $response = $notify->sms()->send('+998901234567', 'Salom!');
} catch (InsufficientBalanceException $e) {
    // $e->errorCode: INSUFFICIENT_BALANCE | SPENDING_LIMIT_EXCEEDED
    // $e->hint() - nima qilish kerak, $e->docsUrl() - hujjatdagi shu xato (NOTIFY_LOCALE tilida)
    // balans yetarli emas
} catch (ValidationException $e) {
    $e->errors;
} catch (RateLimitException $e) {
    $e->retryAfterSeconds;
}

composer require cloudme/notify-laravel

NOTIFY_ENVIRONMENT=sandbox
NOTIFY_CLIENT_ID=your_client_id
NOTIFY_API_KEY=your_api_key
NOTIFY_PRIVATE_KEY_PATH=storage/app/notify/private.pem
NOTIFY_TOKEN_STORE=cache
NOTIFY_LOCALE=uz-Cyrl

php artisan notify:doctor

Environment ........ sandbox
Base URL ........... https://sandbox.notify.cloudme.uz/api/v1
Client ID .......... configured
API key ............ configured
Private key file ... readable
Token store ........ cache
Cache store reachable  yes

All checks passed. No messages were sent.

use CloudMe\Notify\NotifyClient;

$notify = app(NotifyClient::class);

$response = $notify->sms()->send(
    '+998901234567',
    'Salom! Bu CloudMe Notify orqali yuborilgan SMS.'
);

use CloudMe\NotifyLaravel\Facades\Notify;

Notify::sms()->send(
    '+998901234567',
    'Salom! Bu CloudMe Notify orqali yuborilgan SMS.'
);

$response->messageId;
$response->status;
$response->price;
$response->currency;
$response->balance;
$response->environment;

$status = $notify->message($response->messageId);

$status->messageId;
$status->channel;
$status->recipient;
$status->status;
$status->smsType;
$status->price;
$status->currency;
$status->errorCode;
$status->createdAt;
$status->sentAt;
$status->deliveredAt;
$status->environment;

$balance = $notify->balance();

$balance->balance;
$balance->reservedBalance;
$balance->currency;

$response = Notify::sms()->send('+998901234567', 'Ёзги чегирма -50%!');

$response->status;                // "moderation"
$response->isHeldForModeration(); // true

Notify::message($response->messageId)->isRejected();

use CloudMe\Notify\Exceptions\RateLimitException;
use CloudMe\NotifyLaravel\Facades\Notify;

// 1. Код юбориш - otp_id ни сақлаб қўйинг
try {
    $otp = Notify::otp()->send(to: '+998901234567'); // channel: 'sms' | 'telegram' | 'whatsapp' | 'email'
} catch (RateLimitException $e) {
    // OTP_RESEND_TOO_SOON - $e->retryAfterSeconds
}

session(['otp_id' => $otp->otpId]);

$otp->codeLength;  // 6
$otp->expiresIn;   // 300
$otp->maxAttempts; // 3
$otp->code;        // production'да null, sandbox'да коднинг ўзи (тест учун)

// 2. Фойдаланувчи киритган кодни текшириш
$result = Notify::otp()->verify(session('otp_id'), $request->code);

if ($result->verified) {
    // телефон тасдиқланди
} elseif ($result->canRetry()) {
    // код нотўғри - $result->attemptsLeft та уриниш қолди
} else {
    // муддати ўтган / уринишлар тугаган / ишлатилган - янги код юборинг
}

POST /api/v1/otp/send
{ "to": "998901234567", "channel": "sms" }

200 { "otp_id": "0f6c1a52-...", "status": "pending", "code_length": 6,
      "max_attempts": 3, "expires_in": 300, "message_id": "...", "price": "120.0000" }

POST /api/v1/otp/verify
{ "otp_id": "0f6c1a52-...", "code": "481201" }

200 { "verified": true, "status": "verified" }
422 { "verified": false, "attempts_left": 2, "error": { "code": "OTP_INVALID" } }

$notify->telegram()->send(to: "998901234567", message: "Hello", channelAccountId: 7);
$notify->push()->registerDevice("998901234567", $fcmToken, channelAccountId: 12);
$notify->push()->send(to: "998901234567", message: "Hello", channelAccountId: 12);
NotifyMessage::make()->channel("telegram")->channelAccount(7)->message("Hello");

$notify->telegram()->send('123456789', 'Buyurtmangiz tayyor.');

$binding = $notify->telegram()->bindingLink('+998901234567');
if (! $binding->bound) {
    $notify->sms()->send('+998901234567', "Telegram: {$binding->link}");
}

$notify->whatsapp()->send('+998901234567', 'Buyurtmangiz tayyor.');

$notify->voice()->call('+998901234567', 'Sizning buyurtmangiz tayyor.');

$notify->email()->send(
    to: 'customer@example.com',
    message: 'Buyurtmangiz tayyor.',
    subject: 'Buyurtma holati'
);

$notify->push()->send(
    to: '+998901234567',
    message: 'Buyurtmangiz tayyor.',
    subject: 'Buyurtma tayyor'
);

$notify->push()->registerDevice(
    phone: $user->phone,
    fcmToken: $request->fcm_token
);

$notify->sms()->send(
    to: '+998901234567',
    templateId: 42,
    variables: ['name' => 'Aziz', 'order_id' => '10293']
);

foreach ($notify->templates()->list('sms') as $template) {
    $template->id;        // templateId
    $template->variables; // ['name', 'order_id']
}

$notify->sms()->send(
    to: '+998901234567',
    message: 'Buyurtmangiz tayyor.',
    idempotencyKey: (string) $order->id
);

use Illuminate\Support\Carbon;

$notify->reports()->daily(Carbon::today()->subDays(7), Carbon::today());
$notify->reports()->monthly();

Notify::telegram()->send(
    to: '+998901234567',
    message: "<b>Buyurtmangiz tayyor</b>\nModel: DAF XF106",
    photoUrl: 'https://example.com/photos/order.jpg',
);

// Laravel Notification
NotifyMessage::make()
    ->channel('whatsapp')
    ->message('*Buyurtmangiz tayyor*')
    ->photo('https://example.com/photos/order.jpg');

$debt = Notify::debts()->create(
    name: 'Aziz Karimov',
    phone: '+998901234567',
    amount: 1250000,
    dueDate: '2026-10-15',
    externalId: 'INV-1001',
);

$debt->id;             // "0f6c1a52-..."
$debt->nextReminderAt; // "2026-10-16T10:00:00+05:00"

$result = Notify::debts()->recordPayment($debt->id, 1250000, externalId: 'PAY-5001');

$result->debt->isPaid();             // true
$result->payment->attributedChannel; // "sms"
$result->payment->daysLate;          // 2

Notify::debts()->find($debt->id)->payments;
Notify::debts()->cancel($debt->id);

use CloudMe\Notify\ScheduledMessages\Recurrence;

$schedule = Notify::scheduledMessages()->create(
    channel: 'sms',
    startsAt: '2026-10-06T10:00:00+05:00',
    recipient: '+998901234567',
    message: 'Eslatma: bugun soat 15:00 da uchrashuv',
);

$schedule->id;        // "7b1e0c4a-..."
$schedule->nextRunAt; // "2026-10-06T10:00:00+05:00"

Notify::scheduledMessages()->create(
    channel: 'telegram',
    startsAt: '2026-10-05T09:00:00+05:00',
    contactGroupId: 12,
    message: 'Salom, {{name}}! Haftalik yangiliklar...',
    recurrence: Recurrence::weekly([1, 4]), // Recurrence::every(2, 'hours'), Recurrence::monthly([1, 15])
);

Notify::scheduledMessages()->update($schedule->id, channel: 'sms', startsAt: '2026-10-07T10:00:00+05:00', recipient: '+998901234567', message: 'Uchrashuv ertaga');
Notify::scheduledMessages()->pause($schedule->id);
Notify::scheduledMessages()->resume($schedule->id);
Notify::scheduledMessages()->cancel($schedule->id);
Notify::scheduledMessages()->list(status: 'active')->items;

// .env
NOTIFY_WEBHOOK_SECRET=whsec_xxxxxxxxxxxxxxxx

// routes/web.php
Route::post('/webhooks/notify', NotifyWebhookController::class)->middleware('notify.webhook');

// NotifyWebhookController
use CloudMe\NotifyLaravel\Http\Middleware\VerifyNotifyWebhook;

public function __invoke(Request $request)
{
    $event = VerifyNotifyWebhook::event($request);

    // $event->id, $event->event, $event->messageId, $event->status, $event->errorCode
    if ($event->event === 'message.failed') {
        // ...
    }

    return response()->noContent();
}

use CloudMe\Notify\Exceptions\InsufficientBalanceException;
use CloudMe\Notify\Exceptions\ValidationException;
use CloudMe\Notify\Exceptions\RateLimitException;

try {
    $response = $notify->sms()->send('+998901234567', 'Salom!');
} catch (InsufficientBalanceException $e) {
    // $e->errorCode: INSUFFICIENT_BALANCE | SPENDING_LIMIT_EXCEEDED
    // $e->hint() - нима қилиш керак, $e->docsUrl() - ҳужжатдаги шу хато (NOTIFY_LOCALE тилида)
    // balans yetarli emas
} catch (ValidationException $e) {
    $e->errors;
} catch (RateLimitException $e) {
    $e->retryAfterSeconds;
}

composer require cloudme/notify-laravel

NOTIFY_ENVIRONMENT=sandbox
NOTIFY_CLIENT_ID=your_client_id
NOTIFY_API_KEY=your_api_key
NOTIFY_PRIVATE_KEY_PATH=storage/app/notify/private.pem
NOTIFY_TOKEN_STORE=cache
NOTIFY_LOCALE=ru

php artisan notify:doctor

Environment ........ sandbox
Base URL ........... https://sandbox.notify.cloudme.uz/api/v1
Client ID .......... configured
API key ............ configured
Private key file ... readable
Token store ........ cache
Cache store reachable  yes

All checks passed. No messages were sent.

use CloudMe\Notify\NotifyClient;

$notify = app(NotifyClient::class);

$response = $notify->sms()->send(
    '+998901234567',
    'Salom! Bu CloudMe Notify orqali yuborilgan SMS.'
);

use CloudMe\NotifyLaravel\Facades\Notify;

Notify::sms()->send(
    '+998901234567',
    'Salom! Bu CloudMe Notify orqali yuborilgan SMS.'
);

$response->messageId;
$response->status;
$response->price;
$response->currency;
$response->balance;
$response->environment;

$status = $notify->message($response->messageId);

$status->messageId;
$status->channel;
$status->recipient;
$status->status;
$status->smsType;
$status->price;
$status->currency;
$status->errorCode;
$status->createdAt;
$status->sentAt;
$status->deliveredAt;
$status->environment;

$balance = $notify->balance();

$balance->balance;
$balance->reservedBalance;
$balance->currency;

$response = Notify::sms()->send('+998901234567', 'Летняя скидка -50%!');

$response->status;                // "moderation"
$response->isHeldForModeration(); // true

Notify::message($response->messageId)->isRejected();

use CloudMe\Notify\Exceptions\RateLimitException;
use CloudMe\NotifyLaravel\Facades\Notify;

// 1. Отправка кода - сохраните otp_id
try {
    $otp = Notify::otp()->send(to: '+998901234567'); // channel: 'sms' | 'telegram' | 'whatsapp' | 'email'
} catch (RateLimitException $e) {
    // OTP_RESEND_TOO_SOON - $e->retryAfterSeconds
}

session(['otp_id' => $otp->otpId]);

$otp->codeLength;  // 6
$otp->expiresIn;   // 300
$otp->maxAttempts; // 3
$otp->code;        // в production - null, в sandbox - сам код (для тестов)

// 2. Проверка кода, введённого пользователем
$result = Notify::otp()->verify(session('otp_id'), $request->code);

if ($result->verified) {
    // телефон подтверждён
} elseif ($result->canRetry()) {
    // неверный код - осталось $result->attemptsLeft попыток
} else {
    // истёк / попытки исчерпаны / уже использован - отправьте новый код
}

POST /api/v1/otp/send
{ "to": "998901234567", "channel": "sms" }

200 { "otp_id": "0f6c1a52-...", "status": "pending", "code_length": 6,
      "max_attempts": 3, "expires_in": 300, "message_id": "...", "price": "120.0000" }

POST /api/v1/otp/verify
{ "otp_id": "0f6c1a52-...", "code": "481201" }

200 { "verified": true, "status": "verified" }
422 { "verified": false, "attempts_left": 2, "error": { "code": "OTP_INVALID" } }

$notify->telegram()->send(to: "998901234567", message: "Hello", channelAccountId: 7);
$notify->push()->registerDevice("998901234567", $fcmToken, channelAccountId: 12);
$notify->push()->send(to: "998901234567", message: "Hello", channelAccountId: 12);
NotifyMessage::make()->channel("telegram")->channelAccount(7)->message("Hello");

$notify->telegram()->send('123456789', 'Buyurtmangiz tayyor.');

$binding = $notify->telegram()->bindingLink('+998901234567');
if (! $binding->bound) {
    $notify->sms()->send('+998901234567', "Telegram: {$binding->link}");
}

$notify->whatsapp()->send('+998901234567', 'Buyurtmangiz tayyor.');

$notify->voice()->call('+998901234567', 'Sizning buyurtmangiz tayyor.');

$notify->email()->send(
    to: 'customer@example.com',
    message: 'Buyurtmangiz tayyor.',
    subject: 'Buyurtma holati'
);

$notify->push()->send(
    to: '+998901234567',
    message: 'Buyurtmangiz tayyor.',
    subject: 'Buyurtma tayyor'
);

$notify->push()->registerDevice(
    phone: $user->phone,
    fcmToken: $request->fcm_token
);

$notify->sms()->send(
    to: '+998901234567',
    templateId: 42,
    variables: ['name' => 'Aziz', 'order_id' => '10293']
);

foreach ($notify->templates()->list('sms') as $template) {
    $template->id;        // templateId
    $template->variables; // ['name', 'order_id']
}

$notify->sms()->send(
    to: '+998901234567',
    message: 'Buyurtmangiz tayyor.',
    idempotencyKey: (string) $order->id
);

use Illuminate\Support\Carbon;

$notify->reports()->daily(Carbon::today()->subDays(7), Carbon::today());
$notify->reports()->monthly();

Notify::telegram()->send(
    to: '+998901234567',
    message: "<b>Buyurtmangiz tayyor</b>\nModel: DAF XF106",
    photoUrl: 'https://example.com/photos/order.jpg',
);

// Laravel Notification
NotifyMessage::make()
    ->channel('whatsapp')
    ->message('*Buyurtmangiz tayyor*')
    ->photo('https://example.com/photos/order.jpg');

$debt = Notify::debts()->create(
    name: 'Aziz Karimov',
    phone: '+998901234567',
    amount: 1250000,
    dueDate: '2026-10-15',
    externalId: 'INV-1001',
);

$debt->id;             // "0f6c1a52-..."
$debt->nextReminderAt; // "2026-10-16T10:00:00+05:00"

$result = Notify::debts()->recordPayment($debt->id, 1250000, externalId: 'PAY-5001');

$result->debt->isPaid();             // true
$result->payment->attributedChannel; // "sms"
$result->payment->daysLate;          // 2

Notify::debts()->find($debt->id)->payments;
Notify::debts()->cancel($debt->id);

use CloudMe\Notify\ScheduledMessages\Recurrence;

$schedule = Notify::scheduledMessages()->create(
    channel: 'sms',
    startsAt: '2026-10-06T10:00:00+05:00',
    recipient: '+998901234567',
    message: 'Eslatma: bugun soat 15:00 da uchrashuv',
);

$schedule->id;        // "7b1e0c4a-..."
$schedule->nextRunAt; // "2026-10-06T10:00:00+05:00"

Notify::scheduledMessages()->create(
    channel: 'telegram',
    startsAt: '2026-10-05T09:00:00+05:00',
    contactGroupId: 12,
    message: 'Salom, {{name}}! Haftalik yangiliklar...',
    recurrence: Recurrence::weekly([1, 4]), // Recurrence::every(2, 'hours'), Recurrence::monthly([1, 15])
);

Notify::scheduledMessages()->update($schedule->id, channel: 'sms', startsAt: '2026-10-07T10:00:00+05:00', recipient: '+998901234567', message: 'Uchrashuv ertaga');
Notify::scheduledMessages()->pause($schedule->id);
Notify::scheduledMessages()->resume($schedule->id);
Notify::scheduledMessages()->cancel($schedule->id);
Notify::scheduledMessages()->list(status: 'active')->items;

// .env
NOTIFY_WEBHOOK_SECRET=whsec_xxxxxxxxxxxxxxxx

// routes/web.php
Route::post('/webhooks/notify', NotifyWebhookController::class)->middleware('notify.webhook');

// NotifyWebhookController
use CloudMe\NotifyLaravel\Http\Middleware\VerifyNotifyWebhook;

public function __invoke(Request $request)
{
    $event = VerifyNotifyWebhook::event($request);

    // $event->id, $event->event, $event->messageId, $event->status, $event->errorCode
    if ($event->event === 'message.failed') {
        // ...
    }

    return response()->noContent();
}

use CloudMe\Notify\Exceptions\InsufficientBalanceException;
use CloudMe\Notify\Exceptions\ValidationException;
use CloudMe\Notify\Exceptions\RateLimitException;

try {
    $response = $notify->sms()->send('+998901234567', 'Salom!');
} catch (InsufficientBalanceException $e) {
    // $e->errorCode: INSUFFICIENT_BALANCE | SPENDING_LIMIT_EXCEEDED
    // $e->hint() - что сделать, $e->docsUrl() - эта ошибка в документации (на языке NOTIFY_LOCALE)
    // nedostatochno balansa
} catch (ValidationException $e) {
    $e->errors;
} catch (RateLimitException $e) {
    $e->retryAfterSeconds;
}

composer require cloudme/notify-laravel

NOTIFY_ENVIRONMENT=sandbox
NOTIFY_CLIENT_ID=your_client_id
NOTIFY_API_KEY=your_api_key
NOTIFY_PRIVATE_KEY_PATH=storage/app/notify/private.pem
NOTIFY_TOKEN_STORE=cache
NOTIFY_LOCALE=en

php artisan notify:doctor

Environment ........ sandbox
Base URL ........... https://sandbox.notify.cloudme.uz/api/v1
Client ID .......... configured
API key ............ configured
Private key file ... readable
Token store ........ cache
Cache store reachable  yes

All checks passed. No messages were sent.

use CloudMe\Notify\NotifyClient;

$notify = app(NotifyClient::class);

$response = $notify->sms()->send(
    '+998901234567',
    'Salom! Bu CloudMe Notify orqali yuborilgan SMS.'
);

use CloudMe\NotifyLaravel\Facades\Notify;

Notify::sms()->send(
    '+998901234567',
    'Salom! Bu CloudMe Notify orqali yuborilgan SMS.'
);

$response->messageId;
$response->status;
$response->price;
$response->currency;
$response->balance;
$response->environment;

$status = $notify->message($response->messageId);

$status->messageId;
$status->channel;
$status->recipient;
$status->status;
$status->smsType;
$status->price;
$status->currency;
$status->errorCode;
$status->createdAt;
$status->sentAt;
$status->deliveredAt;
$status->environment;

$balance = $notify->balance();

$balance->balance;
$balance->reservedBalance;
$balance->currency;

$response = Notify::sms()->send('+998901234567', 'Summer sale -50%!');

$response->status;                // "moderation"
$response->isHeldForModeration(); // true

Notify::message($response->messageId)->isRejected();

use CloudMe\Notify\Exceptions\RateLimitException;
use CloudMe\NotifyLaravel\Facades\Notify;

// 1. Send a code - keep the otp_id
try {
    $otp = Notify::otp()->send(to: '+998901234567'); // channel: 'sms' | 'telegram' | 'whatsapp' | 'email'
} catch (RateLimitException $e) {
    // OTP_RESEND_TOO_SOON - $e->retryAfterSeconds
}

session(['otp_id' => $otp->otpId]);

$otp->codeLength;  // 6
$otp->expiresIn;   // 300
$otp->maxAttempts; // 3
$otp->code;        // null in production; the code itself in the sandbox (for testing)

// 2. Verify what the user typed
$result = Notify::otp()->verify(session('otp_id'), $request->code);

if ($result->verified) {
    // phone confirmed
} elseif ($result->canRetry()) {
    // wrong code - $result->attemptsLeft tries left
} else {
    // expired / attempts used up / already used - send a new code
}

POST /api/v1/otp/send
{ "to": "998901234567", "channel": "sms" }

200 { "otp_id": "0f6c1a52-...", "status": "pending", "code_length": 6,
      "max_attempts": 3, "expires_in": 300, "message_id": "...", "price": "120.0000" }

POST /api/v1/otp/verify
{ "otp_id": "0f6c1a52-...", "code": "481201" }

200 { "verified": true, "status": "verified" }
422 { "verified": false, "attempts_left": 2, "error": { "code": "OTP_INVALID" } }

$notify->telegram()->send(to: "998901234567", message: "Hello", channelAccountId: 7);
$notify->push()->registerDevice("998901234567", $fcmToken, channelAccountId: 12);
$notify->push()->send(to: "998901234567", message: "Hello", channelAccountId: 12);
NotifyMessage::make()->channel("telegram")->channelAccount(7)->message("Hello");

$notify->telegram()->send('123456789', 'Buyurtmangiz tayyor.');

$binding = $notify->telegram()->bindingLink('+998901234567');
if (! $binding->bound) {
    $notify->sms()->send('+998901234567', "Telegram: {$binding->link}");
}

$notify->whatsapp()->send('+998901234567', 'Buyurtmangiz tayyor.');

$notify->voice()->call('+998901234567', 'Sizning buyurtmangiz tayyor.');

$notify->email()->send(
    to: 'customer@example.com',
    message: 'Buyurtmangiz tayyor.',
    subject: 'Buyurtma holati'
);

$notify->push()->send(
    to: '+998901234567',
    message: 'Buyurtmangiz tayyor.',
    subject: 'Buyurtma tayyor'
);

$notify->push()->registerDevice(
    phone: $user->phone,
    fcmToken: $request->fcm_token
);

$notify->sms()->send(
    to: '+998901234567',
    templateId: 42,
    variables: ['name' => 'Aziz', 'order_id' => '10293']
);

foreach ($notify->templates()->list('sms') as $template) {
    $template->id;        // templateId
    $template->variables; // ['name', 'order_id']
}

$notify->sms()->send(
    to: '+998901234567',
    message: 'Buyurtmangiz tayyor.',
    idempotencyKey: (string) $order->id
);

use Illuminate\Support\Carbon;

$notify->reports()->daily(Carbon::today()->subDays(7), Carbon::today());
$notify->reports()->monthly();

Notify::telegram()->send(
    to: '+998901234567',
    message: "<b>Buyurtmangiz tayyor</b>\nModel: DAF XF106",
    photoUrl: 'https://example.com/photos/order.jpg',
);

// Laravel Notification
NotifyMessage::make()
    ->channel('whatsapp')
    ->message('*Buyurtmangiz tayyor*')
    ->photo('https://example.com/photos/order.jpg');

$debt = Notify::debts()->create(
    name: 'Aziz Karimov',
    phone: '+998901234567',
    amount: 1250000,
    dueDate: '2026-10-15',
    externalId: 'INV-1001',
);

$debt->id;             // "0f6c1a52-..."
$debt->nextReminderAt; // "2026-10-16T10:00:00+05:00"

$result = Notify::debts()->recordPayment($debt->id, 1250000, externalId: 'PAY-5001');

$result->debt->isPaid();             // true
$result->payment->attributedChannel; // "sms"
$result->payment->daysLate;          // 2

Notify::debts()->find($debt->id)->payments;
Notify::debts()->cancel($debt->id);

use CloudMe\Notify\ScheduledMessages\Recurrence;

$schedule = Notify::scheduledMessages()->create(
    channel: 'sms',
    startsAt: '2026-10-06T10:00:00+05:00',
    recipient: '+998901234567',
    message: 'Eslatma: bugun soat 15:00 da uchrashuv',
);

$schedule->id;        // "7b1e0c4a-..."
$schedule->nextRunAt; // "2026-10-06T10:00:00+05:00"

Notify::scheduledMessages()->create(
    channel: 'telegram',
    startsAt: '2026-10-05T09:00:00+05:00',
    contactGroupId: 12,
    message: 'Salom, {{name}}! Haftalik yangiliklar...',
    recurrence: Recurrence::weekly([1, 4]), // Recurrence::every(2, 'hours'), Recurrence::monthly([1, 15])
);

Notify::scheduledMessages()->update($schedule->id, channel: 'sms', startsAt: '2026-10-07T10:00:00+05:00', recipient: '+998901234567', message: 'Uchrashuv ertaga');
Notify::scheduledMessages()->pause($schedule->id);
Notify::scheduledMessages()->resume($schedule->id);
Notify::scheduledMessages()->cancel($schedule->id);
Notify::scheduledMessages()->list(status: 'active')->items;

// .env
NOTIFY_WEBHOOK_SECRET=whsec_xxxxxxxxxxxxxxxx

// routes/web.php
Route::post('/webhooks/notify', NotifyWebhookController::class)->middleware('notify.webhook');

// NotifyWebhookController
use CloudMe\NotifyLaravel\Http\Middleware\VerifyNotifyWebhook;

public function __invoke(Request $request)
{
    $event = VerifyNotifyWebhook::event($request);

    // $event->id, $event->event, $event->messageId, $event->status, $event->errorCode
    if ($event->event === 'message.failed') {
        // ...
    }

    return response()->noContent();
}

use CloudMe\Notify\Exceptions\InsufficientBalanceException;
use CloudMe\Notify\Exceptions\ValidationException;
use CloudMe\Notify\Exceptions\RateLimitException;

try {
    $response = $notify->sms()->send('+998901234567', 'Salom!');
} catch (InsufficientBalanceException $e) {
    // $e->errorCode: INSUFFICIENT_BALANCE | SPENDING_LIMIT_EXCEEDED
    // $e->hint() - what to do next, $e->docsUrl() - this error in the docs (in the NOTIFY_LOCALE language)
    // balance too low
} catch (ValidationException $e) {
    $e->errors;
} catch (RateLimitException $e) {
    $e->retryAfterSeconds;
}

$notify->telegram()->send(to: "998901234567", message: "Hello", channelAccountId: 7);
$notify->push()->registerDevice("998901234567", $fcmToken, channelAccountId: 12);
$notify->push()->send(to: "998901234567", message: "Hello", channelAccountId: 12);

use CloudMe\Notify\NotifyClient;

$notify = new NotifyClient(
    clientId: getenv('NOTIFY_CLIENT_ID'),
    apiKey: getenv('NOTIFY_API_KEY'),
    privateKey: '/secure/path/private.pem',
    baseUrl: 'https://sandbox.notify.cloudme.uz/api/v1',
    locale: 'uz', // ixtiyoriy: xato matnlari tili - uz, uz-Cyrl, ru, en
);

$response = $notify->sms()->send('+998901234567', 'Salom!');

// 1. Kod yuborish - otp_id ni saqlab qo'ying
$otp = $notify->otp()->send(to: '+998901234567');

// 2. Foydalanuvchi kiritgan kodni tekshirish
$result = $notify->otp()->verify($otp->otpId, $codeFromUser);

$result->verified;     // true | false
$result->errorCode;    // OTP_INVALID | OTP_EXPIRED | OTP_ATTEMPTS_EXCEEDED | OTP_ALREADY_VERIFIED
$result->attemptsLeft;
$result->canRetry();

$notify->telegram()->send(
    to: '+998901234567',
    message: "<b>Buyurtmangiz tayyor</b>\nModel: DAF XF106",
    photoUrl: 'https://example.com/photos/order.jpg',
);

$notify->whatsapp()->send(to: '+998901234567', message: '*Buyurtmangiz tayyor*', photoUrl: 'https://example.com/photos/order.jpg');

$debt = $notify->debts()->create(
    name: 'Aziz Karimov',
    phone: '+998901234567',
    amount: 1250000,
    dueDate: '2026-10-15',
    externalId: 'INV-1001',
);

$debt->id;             // "0f6c1a52-..."
$debt->nextReminderAt; // "2026-10-16T10:00:00+05:00"

$result = $notify->debts()->recordPayment($debt->id, 1250000, externalId: 'PAY-5001');

$result->debt->isPaid();             // true
$result->payment->attributedChannel; // "sms"
$result->payment->daysLate;          // 2

$notify->debts()->find($debt->id)->payments;
$notify->debts()->cancel($debt->id);

use CloudMe\Notify\ScheduledMessages\Recurrence;

$schedule = $notify->scheduledMessages()->create(
    channel: 'sms',
    startsAt: '2026-10-06T10:00:00+05:00',
    recipient: '+998901234567',
    message: 'Eslatma: bugun soat 15:00 da uchrashuv',
);

$schedule->id;        // "7b1e0c4a-..."
$schedule->nextRunAt; // "2026-10-06T10:00:00+05:00"

$notify->scheduledMessages()->create(
    channel: 'telegram',
    startsAt: '2026-10-05T09:00:00+05:00',
    contactGroupId: 12,
    message: 'Salom, {{name}}! Haftalik yangiliklar...',
    recurrence: Recurrence::weekly([1, 4]), // Recurrence::every(2, 'hours'), Recurrence::monthly([1, 15])
);

$notify->scheduledMessages()->update($schedule->id, channel: 'sms', startsAt: '2026-10-07T10:00:00+05:00', recipient: '+998901234567', message: 'Uchrashuv ertaga');
$notify->scheduledMessages()->pause($schedule->id);
$notify->scheduledMessages()->resume($schedule->id);
$notify->scheduledMessages()->cancel($schedule->id);
$notify->scheduledMessages()->list(status: 'active')->items;

use CloudMe\Notify\Exceptions\InvalidWebhookSignatureException;
use CloudMe\Notify\Webhooks\WebhookVerifier;

$verifier = new WebhookVerifier(getenv('NOTIFY_WEBHOOK_SECRET'));

try {
    $event = $verifier->parse(file_get_contents('php://input'), getallheaders());
} catch (InvalidWebhookSignatureException) {
    http_response_code(401);
    exit;
}

// $event->id, $event->event, $event->messageId, $event->status, $event->errorCode
http_response_code(200);

$notify->telegram()->send(to: "998901234567", message: "Hello", channelAccountId: 7);
$notify->push()->registerDevice("998901234567", $fcmToken, channelAccountId: 12);
$notify->push()->send(to: "998901234567", message: "Hello", channelAccountId: 12);

use CloudMe\Notify\NotifyClient;

$notify = new NotifyClient(
    clientId: getenv('NOTIFY_CLIENT_ID'),
    apiKey: getenv('NOTIFY_API_KEY'),
    privateKey: '/secure/path/private.pem',
    baseUrl: 'https://sandbox.notify.cloudme.uz/api/v1',
    locale: 'uz-Cyrl', // ихтиёрий: хато матнлари тили - uz, uz-Cyrl, ru, en
);

$response = $notify->sms()->send('+998901234567', 'Salom!');

// 1. Код юбориш - otp_id ни сақлаб қўйинг
$otp = $notify->otp()->send(to: '+998901234567');

// 2. Фойдаланувчи киритган кодни текшириш
$result = $notify->otp()->verify($otp->otpId, $codeFromUser);

$result->verified;     // true | false
$result->errorCode;    // OTP_INVALID | OTP_EXPIRED | OTP_ATTEMPTS_EXCEEDED | OTP_ALREADY_VERIFIED
$result->attemptsLeft;
$result->canRetry();

$notify->telegram()->send(
    to: '+998901234567',
    message: "<b>Buyurtmangiz tayyor</b>\nModel: DAF XF106",
    photoUrl: 'https://example.com/photos/order.jpg',
);

$notify->whatsapp()->send(to: '+998901234567', message: '*Buyurtmangiz tayyor*', photoUrl: 'https://example.com/photos/order.jpg');

$debt = $notify->debts()->create(
    name: 'Aziz Karimov',
    phone: '+998901234567',
    amount: 1250000,
    dueDate: '2026-10-15',
    externalId: 'INV-1001',
);

$debt->id;             // "0f6c1a52-..."
$debt->nextReminderAt; // "2026-10-16T10:00:00+05:00"

$result = $notify->debts()->recordPayment($debt->id, 1250000, externalId: 'PAY-5001');

$result->debt->isPaid();             // true
$result->payment->attributedChannel; // "sms"
$result->payment->daysLate;          // 2

$notify->debts()->find($debt->id)->payments;
$notify->debts()->cancel($debt->id);

use CloudMe\Notify\ScheduledMessages\Recurrence;

$schedule = $notify->scheduledMessages()->create(
    channel: 'sms',
    startsAt: '2026-10-06T10:00:00+05:00',
    recipient: '+998901234567',
    message: 'Eslatma: bugun soat 15:00 da uchrashuv',
);

$schedule->id;        // "7b1e0c4a-..."
$schedule->nextRunAt; // "2026-10-06T10:00:00+05:00"

$notify->scheduledMessages()->create(
    channel: 'telegram',
    startsAt: '2026-10-05T09:00:00+05:00',
    contactGroupId: 12,
    message: 'Salom, {{name}}! Haftalik yangiliklar...',
    recurrence: Recurrence::weekly([1, 4]), // Recurrence::every(2, 'hours'), Recurrence::monthly([1, 15])
);

$notify->scheduledMessages()->update($schedule->id, channel: 'sms', startsAt: '2026-10-07T10:00:00+05:00', recipient: '+998901234567', message: 'Uchrashuv ertaga');
$notify->scheduledMessages()->pause($schedule->id);
$notify->scheduledMessages()->resume($schedule->id);
$notify->scheduledMessages()->cancel($schedule->id);
$notify->scheduledMessages()->list(status: 'active')->items;

use CloudMe\Notify\Exceptions\InvalidWebhookSignatureException;
use CloudMe\Notify\Webhooks\WebhookVerifier;

$verifier = new WebhookVerifier(getenv('NOTIFY_WEBHOOK_SECRET'));

try {
    $event = $verifier->parse(file_get_contents('php://input'), getallheaders());
} catch (InvalidWebhookSignatureException) {
    http_response_code(401);
    exit;
}

// $event->id, $event->event, $event->messageId, $event->status, $event->errorCode
http_response_code(200);

$notify->telegram()->send(to: "998901234567", message: "Hello", channelAccountId: 7);
$notify->push()->registerDevice("998901234567", $fcmToken, channelAccountId: 12);
$notify->push()->send(to: "998901234567", message: "Hello", channelAccountId: 12);

use CloudMe\Notify\NotifyClient;

$notify = new NotifyClient(
    clientId: getenv('NOTIFY_CLIENT_ID'),
    apiKey: getenv('NOTIFY_API_KEY'),
    privateKey: '/secure/path/private.pem',
    baseUrl: 'https://sandbox.notify.cloudme.uz/api/v1',
    locale: 'ru', // необязательно: язык текстов ошибок - uz, uz-Cyrl, ru, en
);

$response = $notify->sms()->send('+998901234567', 'Salom!');

// 1. Отправка кода - сохраните otp_id
$otp = $notify->otp()->send(to: '+998901234567');

// 2. Проверка кода, введённого пользователем
$result = $notify->otp()->verify($otp->otpId, $codeFromUser);

$result->verified;     // true | false
$result->errorCode;    // OTP_INVALID | OTP_EXPIRED | OTP_ATTEMPTS_EXCEEDED | OTP_ALREADY_VERIFIED
$result->attemptsLeft;
$result->canRetry();

$notify->telegram()->send(
    to: '+998901234567',
    message: "<b>Buyurtmangiz tayyor</b>\nModel: DAF XF106",
    photoUrl: 'https://example.com/photos/order.jpg',
);

$notify->whatsapp()->send(to: '+998901234567', message: '*Buyurtmangiz tayyor*', photoUrl: 'https://example.com/photos/order.jpg');

$debt = $notify->debts()->create(
    name: 'Aziz Karimov',
    phone: '+998901234567',
    amount: 1250000,
    dueDate: '2026-10-15',
    externalId: 'INV-1001',
);

$debt->id;             // "0f6c1a52-..."
$debt->nextReminderAt; // "2026-10-16T10:00:00+05:00"

$result = $notify->debts()->recordPayment($debt->id, 1250000, externalId: 'PAY-5001');

$result->debt->isPaid();             // true
$result->payment->attributedChannel; // "sms"
$result->payment->daysLate;          // 2

$notify->debts()->find($debt->id)->payments;
$notify->debts()->cancel($debt->id);

use CloudMe\Notify\ScheduledMessages\Recurrence;

$schedule = $notify->scheduledMessages()->create(
    channel: 'sms',
    startsAt: '2026-10-06T10:00:00+05:00',
    recipient: '+998901234567',
    message: 'Eslatma: bugun soat 15:00 da uchrashuv',
);

$schedule->id;        // "7b1e0c4a-..."
$schedule->nextRunAt; // "2026-10-06T10:00:00+05:00"

$notify->scheduledMessages()->create(
    channel: 'telegram',
    startsAt: '2026-10-05T09:00:00+05:00',
    contactGroupId: 12,
    message: 'Salom, {{name}}! Haftalik yangiliklar...',
    recurrence: Recurrence::weekly([1, 4]), // Recurrence::every(2, 'hours'), Recurrence::monthly([1, 15])
);

$notify->scheduledMessages()->update($schedule->id, channel: 'sms', startsAt: '2026-10-07T10:00:00+05:00', recipient: '+998901234567', message: 'Uchrashuv ertaga');
$notify->scheduledMessages()->pause($schedule->id);
$notify->scheduledMessages()->resume($schedule->id);
$notify->scheduledMessages()->cancel($schedule->id);
$notify->scheduledMessages()->list(status: 'active')->items;

use CloudMe\Notify\Exceptions\InvalidWebhookSignatureException;
use CloudMe\Notify\Webhooks\WebhookVerifier;

$verifier = new WebhookVerifier(getenv('NOTIFY_WEBHOOK_SECRET'));

try {
    $event = $verifier->parse(file_get_contents('php://input'), getallheaders());
} catch (InvalidWebhookSignatureException) {
    http_response_code(401);
    exit;
}

// $event->id, $event->event, $event->messageId, $event->status, $event->errorCode
http_response_code(200);

$notify->telegram()->send(to: "998901234567", message: "Hello", channelAccountId: 7);
$notify->push()->registerDevice("998901234567", $fcmToken, channelAccountId: 12);
$notify->push()->send(to: "998901234567", message: "Hello", channelAccountId: 12);

use CloudMe\Notify\NotifyClient;

$notify = new NotifyClient(
    clientId: getenv('NOTIFY_CLIENT_ID'),
    apiKey: getenv('NOTIFY_API_KEY'),
    privateKey: '/secure/path/private.pem',
    baseUrl: 'https://sandbox.notify.cloudme.uz/api/v1',
    locale: 'en', // optional: language of error messages - uz, uz-Cyrl, ru, en
);

$response = $notify->sms()->send('+998901234567', 'Salom!');

// 1. Send a code - keep the otp_id
$otp = $notify->otp()->send(to: '+998901234567');

// 2. Verify what the user typed
$result = $notify->otp()->verify($otp->otpId, $codeFromUser);

$result->verified;     // true | false
$result->errorCode;    // OTP_INVALID | OTP_EXPIRED | OTP_ATTEMPTS_EXCEEDED | OTP_ALREADY_VERIFIED
$result->attemptsLeft;
$result->canRetry();

$notify->telegram()->send(
    to: '+998901234567',
    message: "<b>Buyurtmangiz tayyor</b>\nModel: DAF XF106",
    photoUrl: 'https://example.com/photos/order.jpg',
);

$notify->whatsapp()->send(to: '+998901234567', message: '*Buyurtmangiz tayyor*', photoUrl: 'https://example.com/photos/order.jpg');

$debt = $notify->debts()->create(
    name: 'Aziz Karimov',
    phone: '+998901234567',
    amount: 1250000,
    dueDate: '2026-10-15',
    externalId: 'INV-1001',
);

$debt->id;             // "0f6c1a52-..."
$debt->nextReminderAt; // "2026-10-16T10:00:00+05:00"

$result = $notify->debts()->recordPayment($debt->id, 1250000, externalId: 'PAY-5001');

$result->debt->isPaid();             // true
$result->payment->attributedChannel; // "sms"
$result->payment->daysLate;          // 2

$notify->debts()->find($debt->id)->payments;
$notify->debts()->cancel($debt->id);

use CloudMe\Notify\ScheduledMessages\Recurrence;

$schedule = $notify->scheduledMessages()->create(
    channel: 'sms',
    startsAt: '2026-10-06T10:00:00+05:00',
    recipient: '+998901234567',
    message: 'Eslatma: bugun soat 15:00 da uchrashuv',
);

$schedule->id;        // "7b1e0c4a-..."
$schedule->nextRunAt; // "2026-10-06T10:00:00+05:00"

$notify->scheduledMessages()->create(
    channel: 'telegram',
    startsAt: '2026-10-05T09:00:00+05:00',
    contactGroupId: 12,
    message: 'Salom, {{name}}! Haftalik yangiliklar...',
    recurrence: Recurrence::weekly([1, 4]), // Recurrence::every(2, 'hours'), Recurrence::monthly([1, 15])
);

$notify->scheduledMessages()->update($schedule->id, channel: 'sms', startsAt: '2026-10-07T10:00:00+05:00', recipient: '+998901234567', message: 'Uchrashuv ertaga');
$notify->scheduledMessages()->pause($schedule->id);
$notify->scheduledMessages()->resume($schedule->id);
$notify->scheduledMessages()->cancel($schedule->id);
$notify->scheduledMessages()->list(status: 'active')->items;

use CloudMe\Notify\Exceptions\InvalidWebhookSignatureException;
use CloudMe\Notify\Webhooks\WebhookVerifier;

$verifier = new WebhookVerifier(getenv('NOTIFY_WEBHOOK_SECRET'));

try {
    $event = $verifier->parse(file_get_contents('php://input'), getallheaders());
} catch (InvalidWebhookSignatureException) {
    http_response_code(401);
    exit;
}

// $event->id, $event->event, $event->messageId, $event->status, $event->errorCode
http_response_code(200);

pip install cloudme-notify

import os
from cloudme_notify import NotifyClient

notify = NotifyClient(
    client_id=os.environ["NOTIFY_CLIENT_ID"],
    api_key=os.environ["NOTIFY_API_KEY"],
    private_key="/secure/path/private.pem",
    base_url=NotifyClient.SANDBOX_URL,   # NotifyClient.PRODUCTION_URL
    locale="uz",                         # uz, uz-Cyrl, ru, en
)

response = notify.sms.send(to="+998901234567", message="Salom!")
response.message_id    # "0f6c1a52-..."
response.environment   # "sandbox"

notify.sms.send(to="+998901234567", message="Salom!", sms_type="service")
notify.telegram.send(to="+998901234567", message="<b>Tayyor</b>", photo_url="https://example.com/a.jpg")
notify.whatsapp.send(to="+998901234567", message="*Tayyor*")
notify.email.send(to="user@example.com", subject="Hisob-faktura", message="...")
notify.push.send(to="+998901234567", subject="Yangi xabar", message="...")
notify.voice.call(to="+998901234567", message="Buyurtmangiz tayyor")

notify.sms.send(to="+998901234567", template_id=42, variables={"name": "Aziz"})
notify.sms.send(to="+998901234567", message="...", idempotency_key="order-1001")

notify.message(response.message_id).status   # "delivered"
notify.balance().balance                       # "1000000.00"

for template in notify.templates.list(channel="sms"):
    print(template.id, template.name, template.variables)

binding = notify.telegram.binding_link("+998901234567")
binding.bound   # True once linked
binding.link    # "https://t.me/notify_bot?start=..."

notify.push.register_device(phone="+998901234567", fcm_token=token_from_app)

otp = notify.otp.send(to="+998901234567")   # channel="sms" | "telegram" | "whatsapp" | "email"

result = notify.otp.verify(otp.otp_id, code_from_user)
result.verified      # True / False
result.error_code    # OTP_INVALID | OTP_EXPIRED | OTP_ATTEMPTS_EXCEEDED | OTP_ALREADY_VERIFIED
result.can_retry()

from datetime import datetime
from zoneinfo import ZoneInfo
from cloudme_notify import Recurrence

schedule = notify.scheduled_messages.create(
    channel="sms",
    starts_at=datetime(2026, 10, 6, 10, 0, tzinfo=ZoneInfo("Asia/Tashkent")),
    recipient="+998901234567",
    message="Eslatma: bugun soat 15:00 da uchrashuv",
)

notify.scheduled_messages.create(
    channel="telegram",
    starts_at="2026-10-05T09:00:00+05:00",
    contact_group_id=12,
    message="Salom, {{name}}!",
    recurrence=Recurrence.weekly([1, 4]),   # Recurrence.every(2, "hours"), Recurrence.monthly([1, 15])
)

notify.scheduled_messages.pause(schedule.id)
notify.scheduled_messages.resume(schedule.id)
notify.scheduled_messages.cancel(schedule.id)
notify.scheduled_messages.list(status="active").items

from datetime import date

debt = notify.debts.create(
    name="Aziz Karimov",
    phone="+998901234567",
    amount=1250000,
    due_date=date(2026, 10, 15),
    external_id="INV-1001",
)

result = notify.debts.record_payment(debt.id, 1250000, external_id="PAY-5001")
result.debt.is_paid()               # True
result.payment.attributed_channel   # "sms"
notify.debts.cancel(debt.id)

from cloudme_notify import InvalidWebhookSignatureError, WebhookVerifier

verifier = WebhookVerifier(os.environ["NOTIFY_WEBHOOK_SECRET"])

try:
    event = verifier.parse(raw_body_bytes, request_headers)
except InvalidWebhookSignatureError:
    ...  # 401

if event.event == "message.failed":
    mark_failed(event.message_id, event.error_code)

from cloudme_notify import InsufficientBalanceError, NotifyError, ValidationError

try:
    notify.sms.send(to="+998901234567", message="...")
except InsufficientBalanceError:
    ...
except ValidationError as error:
    error.error_code, error.errors, error.hint
except NotifyError as error:
    error.error_code, error.status_code, error.docs_url

pip install cloudme-notify

import os
from cloudme_notify import NotifyClient

notify = NotifyClient(
    client_id=os.environ["NOTIFY_CLIENT_ID"],
    api_key=os.environ["NOTIFY_API_KEY"],
    private_key="/secure/path/private.pem",
    base_url=NotifyClient.SANDBOX_URL,   # NotifyClient.PRODUCTION_URL
    locale="uz",                         # uz, uz-Cyrl, ru, en
)

response = notify.sms.send(to="+998901234567", message="Salom!")
response.message_id    # "0f6c1a52-..."
response.environment   # "sandbox"

notify.sms.send(to="+998901234567", message="Salom!", sms_type="service")
notify.telegram.send(to="+998901234567", message="<b>Tayyor</b>", photo_url="https://example.com/a.jpg")
notify.whatsapp.send(to="+998901234567", message="*Tayyor*")
notify.email.send(to="user@example.com", subject="Hisob-faktura", message="...")
notify.push.send(to="+998901234567", subject="Yangi xabar", message="...")
notify.voice.call(to="+998901234567", message="Buyurtmangiz tayyor")

notify.sms.send(to="+998901234567", template_id=42, variables={"name": "Aziz"})
notify.sms.send(to="+998901234567", message="...", idempotency_key="order-1001")

notify.message(response.message_id).status   # "delivered"
notify.balance().balance                       # "1000000.00"

for template in notify.templates.list(channel="sms"):
    print(template.id, template.name, template.variables)

binding = notify.telegram.binding_link("+998901234567")
binding.bound   # True once linked
binding.link    # "https://t.me/notify_bot?start=..."

notify.push.register_device(phone="+998901234567", fcm_token=token_from_app)

otp = notify.otp.send(to="+998901234567")   # channel="sms" | "telegram" | "whatsapp" | "email"

result = notify.otp.verify(otp.otp_id, code_from_user)
result.verified      # True / False
result.error_code    # OTP_INVALID | OTP_EXPIRED | OTP_ATTEMPTS_EXCEEDED | OTP_ALREADY_VERIFIED
result.can_retry()

from datetime import datetime
from zoneinfo import ZoneInfo
from cloudme_notify import Recurrence

schedule = notify.scheduled_messages.create(
    channel="sms",
    starts_at=datetime(2026, 10, 6, 10, 0, tzinfo=ZoneInfo("Asia/Tashkent")),
    recipient="+998901234567",
    message="Eslatma: bugun soat 15:00 da uchrashuv",
)

notify.scheduled_messages.create(
    channel="telegram",
    starts_at="2026-10-05T09:00:00+05:00",
    contact_group_id=12,
    message="Salom, {{name}}!",
    recurrence=Recurrence.weekly([1, 4]),   # Recurrence.every(2, "hours"), Recurrence.monthly([1, 15])
)

notify.scheduled_messages.pause(schedule.id)
notify.scheduled_messages.resume(schedule.id)
notify.scheduled_messages.cancel(schedule.id)
notify.scheduled_messages.list(status="active").items

from datetime import date

debt = notify.debts.create(
    name="Aziz Karimov",
    phone="+998901234567",
    amount=1250000,
    due_date=date(2026, 10, 15),
    external_id="INV-1001",
)

result = notify.debts.record_payment(debt.id, 1250000, external_id="PAY-5001")
result.debt.is_paid()               # True
result.payment.attributed_channel   # "sms"
notify.debts.cancel(debt.id)

from cloudme_notify import InvalidWebhookSignatureError, WebhookVerifier

verifier = WebhookVerifier(os.environ["NOTIFY_WEBHOOK_SECRET"])

try:
    event = verifier.parse(raw_body_bytes, request_headers)
except InvalidWebhookSignatureError:
    ...  # 401

if event.event == "message.failed":
    mark_failed(event.message_id, event.error_code)

from cloudme_notify import InsufficientBalanceError, NotifyError, ValidationError

try:
    notify.sms.send(to="+998901234567", message="...")
except InsufficientBalanceError:
    ...
except ValidationError as error:
    error.error_code, error.errors, error.hint
except NotifyError as error:
    error.error_code, error.status_code, error.docs_url

pip install cloudme-notify

import os
from cloudme_notify import NotifyClient

notify = NotifyClient(
    client_id=os.environ["NOTIFY_CLIENT_ID"],
    api_key=os.environ["NOTIFY_API_KEY"],
    private_key="/secure/path/private.pem",
    base_url=NotifyClient.SANDBOX_URL,   # NotifyClient.PRODUCTION_URL
    locale="uz",                         # uz, uz-Cyrl, ru, en
)

response = notify.sms.send(to="+998901234567", message="Salom!")
response.message_id    # "0f6c1a52-..."
response.environment   # "sandbox"

notify.sms.send(to="+998901234567", message="Salom!", sms_type="service")
notify.telegram.send(to="+998901234567", message="<b>Tayyor</b>", photo_url="https://example.com/a.jpg")
notify.whatsapp.send(to="+998901234567", message="*Tayyor*")
notify.email.send(to="user@example.com", subject="Hisob-faktura", message="...")
notify.push.send(to="+998901234567", subject="Yangi xabar", message="...")
notify.voice.call(to="+998901234567", message="Buyurtmangiz tayyor")

notify.sms.send(to="+998901234567", template_id=42, variables={"name": "Aziz"})
notify.sms.send(to="+998901234567", message="...", idempotency_key="order-1001")

notify.message(response.message_id).status   # "delivered"
notify.balance().balance                       # "1000000.00"

for template in notify.templates.list(channel="sms"):
    print(template.id, template.name, template.variables)

binding = notify.telegram.binding_link("+998901234567")
binding.bound   # True once linked
binding.link    # "https://t.me/notify_bot?start=..."

notify.push.register_device(phone="+998901234567", fcm_token=token_from_app)

otp = notify.otp.send(to="+998901234567")   # channel="sms" | "telegram" | "whatsapp" | "email"

result = notify.otp.verify(otp.otp_id, code_from_user)
result.verified      # True / False
result.error_code    # OTP_INVALID | OTP_EXPIRED | OTP_ATTEMPTS_EXCEEDED | OTP_ALREADY_VERIFIED
result.can_retry()

from datetime import datetime
from zoneinfo import ZoneInfo
from cloudme_notify import Recurrence

schedule = notify.scheduled_messages.create(
    channel="sms",
    starts_at=datetime(2026, 10, 6, 10, 0, tzinfo=ZoneInfo("Asia/Tashkent")),
    recipient="+998901234567",
    message="Eslatma: bugun soat 15:00 da uchrashuv",
)

notify.scheduled_messages.create(
    channel="telegram",
    starts_at="2026-10-05T09:00:00+05:00",
    contact_group_id=12,
    message="Salom, {{name}}!",
    recurrence=Recurrence.weekly([1, 4]),   # Recurrence.every(2, "hours"), Recurrence.monthly([1, 15])
)

notify.scheduled_messages.pause(schedule.id)
notify.scheduled_messages.resume(schedule.id)
notify.scheduled_messages.cancel(schedule.id)
notify.scheduled_messages.list(status="active").items

from datetime import date

debt = notify.debts.create(
    name="Aziz Karimov",
    phone="+998901234567",
    amount=1250000,
    due_date=date(2026, 10, 15),
    external_id="INV-1001",
)

result = notify.debts.record_payment(debt.id, 1250000, external_id="PAY-5001")
result.debt.is_paid()               # True
result.payment.attributed_channel   # "sms"
notify.debts.cancel(debt.id)

from cloudme_notify import InvalidWebhookSignatureError, WebhookVerifier

verifier = WebhookVerifier(os.environ["NOTIFY_WEBHOOK_SECRET"])

try:
    event = verifier.parse(raw_body_bytes, request_headers)
except InvalidWebhookSignatureError:
    ...  # 401

if event.event == "message.failed":
    mark_failed(event.message_id, event.error_code)

from cloudme_notify import InsufficientBalanceError, NotifyError, ValidationError

try:
    notify.sms.send(to="+998901234567", message="...")
except InsufficientBalanceError:
    ...
except ValidationError as error:
    error.error_code, error.errors, error.hint
except NotifyError as error:
    error.error_code, error.status_code, error.docs_url

pip install cloudme-notify

import os
from cloudme_notify import NotifyClient

notify = NotifyClient(
    client_id=os.environ["NOTIFY_CLIENT_ID"],
    api_key=os.environ["NOTIFY_API_KEY"],
    private_key="/secure/path/private.pem",
    base_url=NotifyClient.SANDBOX_URL,   # NotifyClient.PRODUCTION_URL
    locale="uz",                         # uz, uz-Cyrl, ru, en
)

response = notify.sms.send(to="+998901234567", message="Salom!")
response.message_id    # "0f6c1a52-..."
response.environment   # "sandbox"

notify.sms.send(to="+998901234567", message="Salom!", sms_type="service")
notify.telegram.send(to="+998901234567", message="<b>Tayyor</b>", photo_url="https://example.com/a.jpg")
notify.whatsapp.send(to="+998901234567", message="*Tayyor*")
notify.email.send(to="user@example.com", subject="Hisob-faktura", message="...")
notify.push.send(to="+998901234567", subject="Yangi xabar", message="...")
notify.voice.call(to="+998901234567", message="Buyurtmangiz tayyor")

notify.sms.send(to="+998901234567", template_id=42, variables={"name": "Aziz"})
notify.sms.send(to="+998901234567", message="...", idempotency_key="order-1001")

notify.message(response.message_id).status   # "delivered"
notify.balance().balance                       # "1000000.00"

for template in notify.templates.list(channel="sms"):
    print(template.id, template.name, template.variables)

binding = notify.telegram.binding_link("+998901234567")
binding.bound   # True once linked
binding.link    # "https://t.me/notify_bot?start=..."

notify.push.register_device(phone="+998901234567", fcm_token=token_from_app)

otp = notify.otp.send(to="+998901234567")   # channel="sms" | "telegram" | "whatsapp" | "email"

result = notify.otp.verify(otp.otp_id, code_from_user)
result.verified      # True / False
result.error_code    # OTP_INVALID | OTP_EXPIRED | OTP_ATTEMPTS_EXCEEDED | OTP_ALREADY_VERIFIED
result.can_retry()

from datetime import datetime
from zoneinfo import ZoneInfo
from cloudme_notify import Recurrence

schedule = notify.scheduled_messages.create(
    channel="sms",
    starts_at=datetime(2026, 10, 6, 10, 0, tzinfo=ZoneInfo("Asia/Tashkent")),
    recipient="+998901234567",
    message="Eslatma: bugun soat 15:00 da uchrashuv",
)

notify.scheduled_messages.create(
    channel="telegram",
    starts_at="2026-10-05T09:00:00+05:00",
    contact_group_id=12,
    message="Salom, {{name}}!",
    recurrence=Recurrence.weekly([1, 4]),   # Recurrence.every(2, "hours"), Recurrence.monthly([1, 15])
)

notify.scheduled_messages.pause(schedule.id)
notify.scheduled_messages.resume(schedule.id)
notify.scheduled_messages.cancel(schedule.id)
notify.scheduled_messages.list(status="active").items

from datetime import date

debt = notify.debts.create(
    name="Aziz Karimov",
    phone="+998901234567",
    amount=1250000,
    due_date=date(2026, 10, 15),
    external_id="INV-1001",
)

result = notify.debts.record_payment(debt.id, 1250000, external_id="PAY-5001")
result.debt.is_paid()               # True
result.payment.attributed_channel   # "sms"
notify.debts.cancel(debt.id)

from cloudme_notify import InvalidWebhookSignatureError, WebhookVerifier

verifier = WebhookVerifier(os.environ["NOTIFY_WEBHOOK_SECRET"])

try:
    event = verifier.parse(raw_body_bytes, request_headers)
except InvalidWebhookSignatureError:
    ...  # 401

if event.event == "message.failed":
    mark_failed(event.message_id, event.error_code)

from cloudme_notify import InsufficientBalanceError, NotifyError, ValidationError

try:
    notify.sms.send(to="+998901234567", message="...")
except InsufficientBalanceError:
    ...
except ValidationError as error:
    error.error_code, error.errors, error.hint
except NotifyError as error:
    error.error_code, error.status_code, error.docs_url

pip install cloudme-notify-django

# settings.py
INSTALLED_APPS = [
    # ...
    "cloudme_notify_django",
]

NOTIFY = {
    "ENVIRONMENT": "sandbox",   # "production"
    "CLIENT_ID": os.environ["NOTIFY_CLIENT_ID"],
    "API_KEY": os.environ["NOTIFY_API_KEY"],
    "PRIVATE_KEY_PATH": BASE_DIR / "secrets" / "notify.pem",
    "WEBHOOK_SECRET": os.environ.get("NOTIFY_WEBHOOK_SECRET"),
    "LOCALE": "uz",
}

python manage.py notify_doctor

from cloudme_notify_django import notify

notify.sms.send(to="+998901234567", message="Buyurtmangiz tayyor")
notify.telegram.send(to=user.phone, template_id=42, variables={"name": user.first_name})

otp = notify.otp.send(to=request.POST["phone"])
request.session["otp_id"] = otp.otp_id

notify.scheduled_messages.create(
    channel="sms",
    starts_at=appointment.starts_at - timedelta(days=1),
    recipient=customer.phone,
    message="Eslatma: ertaga qabul",
)

# urls.py
from cloudme_notify_django.webhooks import webhook_view

urlpatterns = [path("webhooks/notify/", webhook_view)]

# yourapp/signals.py
from django.dispatch import receiver
from cloudme_notify_django.signals import webhook_received

@receiver(webhook_received)
def on_notify_event(sender, event, **kwargs):
    if event.event == "message.failed":
        Order.objects.filter(notify_message_id=event.message_id).update(sms_failed=True)

from cloudme_notify_django.webhooks import notify_webhook

@notify_webhook
def notify_events(request):
    event = request.notify_event
    return HttpResponse(status=204)

import httpx
from cloudme_notify import NotifyClient
from cloudme_notify_django import set_client

def handler(request):
    if request.url.path.endswith("/oauth/token"):
        return httpx.Response(200, json={"access_token": "t", "expires_in": 900, "refresh_token": "r"})
    return httpx.Response(200, json={"success": True, "message_id": "m-1", "status": "queued", "price": "0", "currency": "UZS"})

set_client(NotifyClient(client_id="c", api_key="k", private_key=TEST_PEM,
                        base_url=NotifyClient.SANDBOX_URL, transport=httpx.MockTransport(handler)))

pip install cloudme-notify-django

# settings.py
INSTALLED_APPS = [
    # ...
    "cloudme_notify_django",
]

NOTIFY = {
    "ENVIRONMENT": "sandbox",   # "production"
    "CLIENT_ID": os.environ["NOTIFY_CLIENT_ID"],
    "API_KEY": os.environ["NOTIFY_API_KEY"],
    "PRIVATE_KEY_PATH": BASE_DIR / "secrets" / "notify.pem",
    "WEBHOOK_SECRET": os.environ.get("NOTIFY_WEBHOOK_SECRET"),
    "LOCALE": "uz",
}

python manage.py notify_doctor

from cloudme_notify_django import notify

notify.sms.send(to="+998901234567", message="Buyurtmangiz tayyor")
notify.telegram.send(to=user.phone, template_id=42, variables={"name": user.first_name})

otp = notify.otp.send(to=request.POST["phone"])
request.session["otp_id"] = otp.otp_id

notify.scheduled_messages.create(
    channel="sms",
    starts_at=appointment.starts_at - timedelta(days=1),
    recipient=customer.phone,
    message="Eslatma: ertaga qabul",
)

# urls.py
from cloudme_notify_django.webhooks import webhook_view

urlpatterns = [path("webhooks/notify/", webhook_view)]

# yourapp/signals.py
from django.dispatch import receiver
from cloudme_notify_django.signals import webhook_received

@receiver(webhook_received)
def on_notify_event(sender, event, **kwargs):
    if event.event == "message.failed":
        Order.objects.filter(notify_message_id=event.message_id).update(sms_failed=True)

from cloudme_notify_django.webhooks import notify_webhook

@notify_webhook
def notify_events(request):
    event = request.notify_event
    return HttpResponse(status=204)

import httpx
from cloudme_notify import NotifyClient
from cloudme_notify_django import set_client

def handler(request):
    if request.url.path.endswith("/oauth/token"):
        return httpx.Response(200, json={"access_token": "t", "expires_in": 900, "refresh_token": "r"})
    return httpx.Response(200, json={"success": True, "message_id": "m-1", "status": "queued", "price": "0", "currency": "UZS"})

set_client(NotifyClient(client_id="c", api_key="k", private_key=TEST_PEM,
                        base_url=NotifyClient.SANDBOX_URL, transport=httpx.MockTransport(handler)))

pip install cloudme-notify-django

# settings.py
INSTALLED_APPS = [
    # ...
    "cloudme_notify_django",
]

NOTIFY = {
    "ENVIRONMENT": "sandbox",   # "production"
    "CLIENT_ID": os.environ["NOTIFY_CLIENT_ID"],
    "API_KEY": os.environ["NOTIFY_API_KEY"],
    "PRIVATE_KEY_PATH": BASE_DIR / "secrets" / "notify.pem",
    "WEBHOOK_SECRET": os.environ.get("NOTIFY_WEBHOOK_SECRET"),
    "LOCALE": "uz",
}

python manage.py notify_doctor

from cloudme_notify_django import notify

notify.sms.send(to="+998901234567", message="Buyurtmangiz tayyor")
notify.telegram.send(to=user.phone, template_id=42, variables={"name": user.first_name})

otp = notify.otp.send(to=request.POST["phone"])
request.session["otp_id"] = otp.otp_id

notify.scheduled_messages.create(
    channel="sms",
    starts_at=appointment.starts_at - timedelta(days=1),
    recipient=customer.phone,
    message="Eslatma: ertaga qabul",
)

# urls.py
from cloudme_notify_django.webhooks import webhook_view

urlpatterns = [path("webhooks/notify/", webhook_view)]

# yourapp/signals.py
from django.dispatch import receiver
from cloudme_notify_django.signals import webhook_received

@receiver(webhook_received)
def on_notify_event(sender, event, **kwargs):
    if event.event == "message.failed":
        Order.objects.filter(notify_message_id=event.message_id).update(sms_failed=True)

from cloudme_notify_django.webhooks import notify_webhook

@notify_webhook
def notify_events(request):
    event = request.notify_event
    return HttpResponse(status=204)

import httpx
from cloudme_notify import NotifyClient
from cloudme_notify_django import set_client

def handler(request):
    if request.url.path.endswith("/oauth/token"):
        return httpx.Response(200, json={"access_token": "t", "expires_in": 900, "refresh_token": "r"})
    return httpx.Response(200, json={"success": True, "message_id": "m-1", "status": "queued", "price": "0", "currency": "UZS"})

set_client(NotifyClient(client_id="c", api_key="k", private_key=TEST_PEM,
                        base_url=NotifyClient.SANDBOX_URL, transport=httpx.MockTransport(handler)))

pip install cloudme-notify-django

# settings.py
INSTALLED_APPS = [
    # ...
    "cloudme_notify_django",
]

NOTIFY = {
    "ENVIRONMENT": "sandbox",   # "production"
    "CLIENT_ID": os.environ["NOTIFY_CLIENT_ID"],
    "API_KEY": os.environ["NOTIFY_API_KEY"],
    "PRIVATE_KEY_PATH": BASE_DIR / "secrets" / "notify.pem",
    "WEBHOOK_SECRET": os.environ.get("NOTIFY_WEBHOOK_SECRET"),
    "LOCALE": "uz",
}

python manage.py notify_doctor

from cloudme_notify_django import notify

notify.sms.send(to="+998901234567", message="Buyurtmangiz tayyor")
notify.telegram.send(to=user.phone, template_id=42, variables={"name": user.first_name})

otp = notify.otp.send(to=request.POST["phone"])
request.session["otp_id"] = otp.otp_id

notify.scheduled_messages.create(
    channel="sms",
    starts_at=appointment.starts_at - timedelta(days=1),
    recipient=customer.phone,
    message="Eslatma: ertaga qabul",
)

# urls.py
from cloudme_notify_django.webhooks import webhook_view

urlpatterns = [path("webhooks/notify/", webhook_view)]

# yourapp/signals.py
from django.dispatch import receiver
from cloudme_notify_django.signals import webhook_received

@receiver(webhook_received)
def on_notify_event(sender, event, **kwargs):
    if event.event == "message.failed":
        Order.objects.filter(notify_message_id=event.message_id).update(sms_failed=True)

from cloudme_notify_django.webhooks import notify_webhook

@notify_webhook
def notify_events(request):
    event = request.notify_event
    return HttpResponse(status=204)

import httpx
from cloudme_notify import NotifyClient
from cloudme_notify_django import set_client

def handler(request):
    if request.url.path.endswith("/oauth/token"):
        return httpx.Response(200, json={"access_token": "t", "expires_in": 900, "refresh_token": "r"})
    return httpx.Response(200, json={"success": True, "message_id": "m-1", "status": "queued", "price": "0", "currency": "UZS"})

set_client(NotifyClient(client_id="c", api_key="k", private_key=TEST_PEM,
                        base_url=NotifyClient.SANDBOX_URL, transport=httpx.MockTransport(handler)))