How can I capture API responses in a custom Laravel notification channel?

When using on-demand notifications (via AnonymousNotifiable), Laravel is designed to “fire and forget” without returning any value from notify(). This means that even if your custom channel makes an API call and gets a response, that response isn’t propagated back through the notify() method (or through setting a property on the notification) because the framework isn’t built to capture and return that result in a synchronous way.

Below are some approaches you might consider:

---

1. Call Your API Directly

Since you need the API response immediately (for example, to inform the user whether the OTP was sent successfully), one option is to bypass the notification system entirely for this use case. Instead, wrap your API call logic into a service class that calls your external service directly and returns its response:

PHPCopied
class OtpService
{
    public function sendOtp(string $email, string $mobile, array $data): array
    {
        // Make your API calls to email and SMS providers here.
        // For example, using Guzzle:
        $emailResponse = $this->sendEmailOtp($email, $data);
        $smsResponse = $this->sendSmsOtp($mobile, $data);

        return [
            'email' => $emailResponse,
            'sms' => $smsResponse,
        ];
    }

    protected function sendEmailOtp(string $email, array $data): array
    {
        // API call logic...
    }

    protected function sendSmsOtp(string $mobile, array $data): array
    {
        // API call logic...
    }
}

Then, in your controller:

PHPCopied
$otpService = new OtpService();
$responses = $otpService->sendOtp($emailAddress, $phoneNumber, ['otp' => $otp]);

if ($responses['email']['success'] && $responses['sms']['success']) {
    // Inform the user that the OTP was sent successfully.
} else {
    // Handle failures accordingly.
}

---

2. Use a Custom API Caller Inside Your Custom Channel

If you really want to keep your notification logic (perhaps because you need to use the built-in channels and routing), you could modify your custom channel to immediately return the API response. However, this would mean you’re no longer using the standard notification system workflow. Instead, you’d call your custom channel directly:

PHPCopied
class VoiceChannel
{
    /**
     * Send the given notification.
     */
    public function send(object $notifiable, Notification $notification)
    {
        $message = $notification->toVoice($notifiable);

        // Instead of just sending the notification, call the API and return its response.
        $response = $this->sendToApi($message);
        
        return $response;
    }

    protected function sendToApi($message)
    {
        // Implement the API call and return the response.
    }
}

Then, rather than using notify() via the Notification facade, you directly instantiate and call your custom channel:

PHPCopied
$channel = new VoiceChannel();
$notification = new SendVerificationCode(['otp' => $otp]);
$response = $channel->send($user, $notification);

// Use $response to inform the user.

Keep in mind that when you deviate from the built-in notification system, you lose some of its advantages (such as consistent channel handling, broadcasting events, etc.).

---

3. Dispatch a Synchronous Notification and Handle Events

Even though you mentioned that notification events create a separate flow, you can dispatch notifications synchronously (using a service like notifyNow()) and then hook into the events to capture responses. However, it still won’t return a value directly from notifyNow(). You would need to collect results via event listeners, which can complicate your flow.

---

Conclusion

On-demand notifications through Laravel’s Notification facade (using AnonymousNotifiable) are not designed to capture and return API responses. For a flow like OTP verification where you need instant feedback, it’s advisable to either bypass the notification system for that purpose or refactor your custom channel’s API call into a synchronous service. This way, you can immediately capture the response and relay it back to the user.

Choose the approach that best fits your application’s architecture and your need for immediate feedback on the status of your API calls.