How to use sockets in Laravel

How to use sockets in Laravel

In this article, you'll learn how to use sockets in Laravel App by making a chatbox.

In this article, you'll learn how to use sockets in Laravel App by making a chatbox.

Nowadays sockets are very popular in web development. Sockets allow real-time communication between the browser of a client and the server. There are a lot of use cases for sockets. For example, sockets could be used for notifications or a chat application. In this article I will show you how to use sockets in your Laravel application by making a chatbox. I will be using Pusher to broadcast my events, but you could also use Redis or * **for broadcasting. In the first part of this article we will make the *backend part of the application and in the second part we will be focusing on the frontend.



Since we are going to broadcast our events over Pusher we should install it via Composer.

composer require pusher/pusher-php-server "~3.0"


To use Pusher you will need an account. You can create a free account at *[]( "*")

Once you have created your Pusher account, you have to create an app in Pusher. After you have created the app you should add the app id, app key, app secret and cluster to your .env *file. Use the <em>PUSHER_APP_ID</em>, <em>PUSHER_APP_KEY</em>, <em>PUSHER_APP_SECRET</em> and <em>PUSHER_APP_CLUSTER</em> for this. Furthermore, change the <em>BROADCAST_DRIVER</em> to *pusher.

The credentials will be displayed in the Pusher dashboard, once you have selected your app

Time to start making the chatbox

Now that we have installed the dependencies and setup our Pusher app, it is time to start making the chatbox. Let’s have a quick overview of what we are about to do. We will create a *Vue component *for the chatbox which will send a request to an API controller with the message that is send by the user. This will be implemented in the second part of this article. For the backend we will create an API controller that will broadcast an event to inform all other clients about the message that was send to the chatbox.


namespace App\Http\Controllers;

use App\Events\MessageSend;
use Illuminate\Http\Request;

class ChatController extends Controller
    public function index(Request $request)
        $message = $request->input('message', '');

        if (strlen($message)) {
            event(new MessageSend($message));

We will also need to create a route in the routes/api.php file.


| API Routes
| Here is where you can register API routes for your application. These
| routes are loaded by the RouteServiceProvider within a group which
| is assigned the "api" middleware group. Enjoy building your API!

Route::post('/message', '[email protected]');


As we saw in the ChatController an event, called MessageSend, get’s fired. This event should be broadcasted to the other clients, to let them know that a message was send to the chatbox. First things first, let’s create the event:

php artisan make:event MessageSend

The MessageSend class will broadcast on the chatbox channel, which is a public channel. This is defined in the broadcastOn method.

This is what the implementation looks like:


namespace App\Events;

use Illuminate\Broadcasting\Channel;
use Illuminate\Queue\SerializesModels;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;

class MessageSend implements ShouldBroadcast
    use Dispatchable, InteractsWithSockets, SerializesModels;

    public $message;

    public function __construct($message)
        $this->message = $message;

    public function broadcastOn()
        return new Channel('chatbox');


The MessageSend class implements the ShouldBroadcast interface.


Before we can starting broadcasting our events the App\Providers\BroadcastServiceProvider should be registered. This can be done by uncommenting this provider in the providers array in the config/app.php file.

Uncomment the BroadcastServiceProvider

Since we have made some changes in our configuration we have to run the following command to fix our configuration cache file:

php artisan config:cache


Receiving broadcasts

To receive broadcasts we are going to use a Javascript Library, called Laravel Echo. This library makes it very easy to listen to broadcasts and subscribe to channels. We will also install *pusher-js *since we are using Pusher for broadcasting.

npm install --save laravel-echo pusher-js

Once we have installed Laravel Echo and Pusher, we have to create an instance of Laravel Echo in the application. On the bottom of the resources/js/bootstrap.js file is some code which creates the Laravel Echo instance for you. Uncomment this part of the code.

Uncomment the Laravel Echo code


As mentioned previously, we are going to create a Vue component that sends a request to our API whenever a message is send. We are going to create that Vue component right now.

Create a ChatboxComponent.vue in the resources/js/components folder. This component contains a very simple form that sends a request to the /api/message *endpoint. Futhermore, this component listens to the *MessageSend event on the chatbox channel. Whenever it receives a message, it will add it to the chatbox.

Creating the controller

Let’s start by creating a controller, which will handle incoming requests:

php artisan make:controller ChatController

The implementation of the controller will be very simple. If the request contains a message we will fire an event, else we do nothing. This event will broadcast the message to all clients.

    <div class="chatbox p-3">
        <div class="messages" v-if="messages.length">
            <div class="message" v-for="message in messages">
                <span class="d-inline-block">{{ message }}</span>

        <div class="row mt-5">
            <div class="col-3">
                <input type="text" class="form-control" v-model="textMessage"></input>

        <div class="row mt-2">
            <div class="col">
                <button class="btn btn-primary" @click="sendMessage()">Send</button>

    export default {
        data() {
            return {
                textMessage: '',
                messages: [],
        created() {
            this.addMessage('You joined the chatbox.');

                .listen('MessageSend', (e) => {
        methods: {
            addMessage(message) {
                let date= new Date();
                let timestamp = date.getHours() + ':' + date.getMinutes() + ':' + date.getSeconds();

                this.messages.push(timestamp + ' ' + message);
            sendMessage() {
      '/api/message', {message: this.textMessage});
                this.textMessage = '';

Now that we have created the ChatboxComponent let’s change the welcome.blade.php so that it actually uses the component.

<!doctype html>
<html lang="{{ str_replace('_', '-', app()->getLocale()) }}">
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <meta name="csrf-token" content="{{ csrf_token() }}">

        <script src="{{ asset('js/app.js') }}" defer></script>
        <script src="{{ asset('js/bootstrap.min.js') }}"></script>
        <link href="{{ asset('css/app.css') }}" rel="stylesheet">
        <div id="app">

To make sure that our newly created component gets registered we have to uncomment the following to lines in the resources/js/app.js file.

These two lines of code will automatically register your Vue components. Do not forget to run npm run watch .

Chitty chat

We can now start a conversation in the chatbox. To test the application open up two tabs in your browser, one of them in incognito mode, and just start typing!

The chatbox in action in two tabs!


If you are running into any issues there is a way to debug your sockets. Pusher has a great debug console which will log any activity happening in your sockets. Just go to the Pusher dashboard and select the Debug console tab. You can check if a client connects to Pusher and if events are being broadcasted.


Depending on the environment that you are developing on, you may receive a BroadcastException *when trying to broadcast the event. This can be fixed by adding the following lines of code to the *pusher.options array in the config/broadcasting.php file.

'curl_options' => [

Congratulations! The chatbox is finished. I hope this article helped you implementing sockets in Laravel. Make sure to check out my other posts aswell, a lot of my content is about Laravel. Please feel free to leave a comment if you have any feedback, questions or want me to write about another Laravel related topic.

laravel php web-development

Bootstrap 5 Complete Course with Examples

Bootstrap 5 Tutorial - Bootstrap 5 Crash Course for Beginners

Nest.JS Tutorial for Beginners

Hello Vue 3: A First Look at Vue 3 and the Composition API

Building a simple Applications with Vue 3

Deno Crash Course: Explore Deno and Create a full REST API with Deno

How to Build a Real-time Chat App with Deno and WebSockets

Convert HTML to Markdown Online

HTML entity encoder decoder Online

PHP Web Application Development Company

As a top **PHP Web Application Development Company in USA**[]( ""), we at Data EximIT have...

PHP Website Development

Skenix Infotech is a leading PHP Web Development Company that helps companies get results with industry best practices. Get affordable PHP Development Services.

Laravel Development Company

Skenix Infotech is a top Laravel Website Development Company with Expert Laravel Developers that provides robust Laravel Development Services at fair costs.

Hire Dedicated PHP Developer

Looking to hire affordable yet experienced PHP developers? **[Hire Dedicated PHP Developer]( "Hire Dedicated PHP Developer")**, who can convert your idea to reality, within the stipulated...

Hire PHP Developer

Looking to develop a PHP based website from scratch or revamp your existing website? **[]( "")** has always been an industry leader for companies and business owners looking to hire...