DEV Community: Ahmed Ben Bettaieb

How to Configure Laravel Reverb with Nginx in Production

Ahmed Ben Bettaieb — Mon, 13 Apr 2026 09:34:50 +0000

Real-time WebSocket communication in Laravel has never been easier thanks to Laravel Reverb — a first-party WebSocket server that integrates seamlessly with Laravel's broadcasting system. In this guide, I'll walk you through everything needed to get Reverb running behind Nginx in production, including the gotchas that cost me hours of debugging.

What We're Building

Browser (wss://yourdomain.com/app/...)
        ↓
    Nginx :443  ← handles SSL termination
        ↓
  Reverb :8080  ← internal only, managed by Supervisor

Nginx handles all public traffic (HTTP/HTTPS), and Reverb runs quietly on an internal port — never exposed directly to the internet.

Prerequisites

Laravel 10+ application already running on Nginx
PHP 8.2+
Node.js & npm
SSL certificate (Let's Encrypt recommended)
Supervisor installed (sudo apt-get install supervisor -y)

Step 1: Install Laravel Reverb
php artisan install:broadcasting

Answer yes to all prompts. This installs the Reverb PHP package along with Laravel Echo and pusher-js on the frontend.

Step 2: Configure Your .env
This is where most people get it wrong. Here's what matters:
For HTTPS (production with domain)

`BROADCAST_CONNECTION=reverb
QUEUE_CONNECTION=sync

REVERB_APP_ID=your-app-id
REVERB_APP_KEY=your-app-key
REVERB_APP_SECRET=your-app-secret
REVERB_HOST="yourdomain.com"
REVERB_PORT=443
REVERB_SCHEME=https

Internal server config (Reverb listens on this port)

REVERB_SERVER_HOST=127.0.0.1
REVERB_SERVER_PORT=8080

VITE_REVERB_APP_KEY="${REVERB_APP_KEY}"
VITE_REVERB_HOST="${REVERB_HOST}"
VITE_REVERB_PORT="${REVERB_PORT}"
VITE_REVERB_SCHEME="${REVERB_SCHEME}"`

For HTTP (development / IP-based server)
`BROADCAST_CONNECTION=reverb
QUEUE_CONNECTION=sync

REVERB_APP_ID=your-app-id
REVERB_APP_KEY=your-app-key
REVERB_APP_SECRET=your-app-secret
REVERB_HOST="your-server-ip"
REVERB_PORT=80
REVERB_SCHEME=http

REVERB_SERVER_HOST=127.0.0.1
REVERB_SERVER_PORT=8080

VITE_REVERB_APP_KEY="${REVERB_APP_KEY}"
VITE_REVERB_HOST="${REVERB_HOST}"
VITE_REVERB_PORT="${REVERB_PORT}"
VITE_REVERB_SCHEME="${REVERB_SCHEME}"`

⚠️ Common mistake: Don't forget QUEUE_CONNECTION=sync. Without it, broadcast events may never fire even though everything else looks correct.

Step 3: Configure Nginx
Add the WebSocket proxy blocks to your Nginx server block before location `server {
listen 443 ssl;
server_name yourdomain.com;
root /var/www/your-app/public;

ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;

# WebSocket proxy for Reverb
location /app {
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "Upgrade";
    proxy_set_header Host $host;
    proxy_cache_bypass $http_upgrade;
    proxy_pass http://127.0.0.1:8080;
}

location /apps {
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "Upgrade";
    proxy_set_header Host $host;
    proxy_cache_bypass $http_upgrade;
    proxy_pass http://127.0.0.1:8080;
}

location / {
    try_files $uri $uri/ /index.php?$query_string;
}

location ~ \.php$ {
    include fastcgi_params;
    fastcgi_pass unix:/run/php/php8.3-fpm.sock;
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
}

location ~ /\.ht {
    deny all;
}

}

Redirect HTTP to HTTPS

server {
listen 80;
server_name yourdomain.com;
return 301 https://$host$request_uri;
}`

Test and reload:

sudo nginx -t
sudo systemctl reload nginx
# OR for Bitnami:
sudo /opt/bitnami/nginx/sbin/nginx -t
sudo /opt/bitnami/ctlscript.sh restart nginx

Step 4: Keep Reverb Running with Supervisor
Without Supervisor, Reverb dies the moment your SSH session closes.
sudo nano /etc/supervisor/conf.d/reverb.conf

[program:reverb] process_name=%(program_name)s command=php /var/www/your-app/artisan reverb:start --host=127.0.0.1 --port=8080 --no-interaction autostart=true autorestart=true user=www-data redirect_stderr=true stdout_logfile=/var/www/your-app/storage/logs/reverb.log stopwaitsecs=3600

Activate:

sudo supervisorctl reread
sudo supervisorctl update
sudo supervisorctl start reverb
sudo supervisorctl status

You should see:

reverb    RUNNING   pid 12345, uptime 0:00:05

Step 5: Clear Cache & Rebuild Frontend

cd /var/www/your-app

php artisan config:clear
php artisan cache:clear

npm run build

Step 6: Verify Everything Works
Check Reverb is listening internally:

sudo ss -tlnp | grep 8080
# Should show: LISTEN 0 ... 127.0.0.1:8080

Test the WebSocket connection using piehost.com/websocket-tester:

URL: wss://yourdomain.com/app/your-app-key
Click Connect → should say Connection established

Subscribe to a channel:

{
    "event": "pusher:subscribe",
    "data": {
        "channel": "my-channel"
    }
}

Fire a test broadcast from tinker:

php artisan make:event TestBroadcast

php artisan make:event TestBroadcast

Edit app/Events/TestBroadcast.php:

<?php
namespace App\Events;

use Illuminate\Broadcasting\Channel;
use Illuminate\Contracts\Broadcasting\ShouldBroadcast;

class TestBroadcast implements ShouldBroadcast
{
    public function broadcastOn() {
        return new Channel('my-channel');
    }

    public function broadcastAs() {
        return 'test.event';
    }

    public function broadcastWith() {
        return ['message' => 'Hello from Reverb!'];
    }
}


php artisan tinker
>>> event(new \App\Events\TestBroadcast());

You should see the message arrive in the WebSocket tester instantly. ✅

Summary
The key things that make Reverb work behind Nginx:

Nginx proxies /app and /apps paths to Reverb's internal port
REVERB_HOST = your public domain (what the browser uses)
REVERB_SERVER_PORT = internal port Reverb listens on (8080)
QUEUE_CONNECTION=sync = ensures broadcasts fire immediately
Supervisor = keeps Reverb alive permanently

Happy broadcasting! 🚀

Create custom connect and transfer money stripe for non registered countries

Ahmed Ben Bettaieb — Thu, 15 Jun 2023 14:19:26 +0000

Hello,
Through this post I will show how to create a stripe account and make a connect , and transfer money to the connect using node js (express with typescript) .
Assuming that your node js project is setup.
first of all you need to create a stripe account (in estonia) :
https://www.youtube.com/watch?v=vEbD8SQg5So&ab_channel=DistroTechnologies
follow this video .
after creating the stripe account you will get your publishable key and secret key , copy them and put them in .env file .
then run this command :
npm install stripe @types/stripe

then make a user model (mongoose) :

`import { Schema, Document, model } from 'mongoose';

// Define the User interface
interface IUser extends Document {
  name: string;
  email: string;
  birthDate: Date;
  accountId: string;
  password: string;
}

// Define the User schema
const UserSchema = new Schema<IUser>({
  name: { type: String, required: true },
  email: { type: String, required: true },
  birthDate: { type: Date, required: true },
  accountId: { type: String, required: true },
  password: { type: String, required: true },
});

// Create and export the User model
const User = model<IUser>('User', UserSchema);
export default User;`

and make sure to make an authMiddleware to verify that the user is authenticated:

`import { Request, Response, NextFunction } from "express";
import jwt from "jsonwebtoken";
import dotenv from "dotenv";
dotenv.config();

const authMiddleware = (
  req: Request,
  res: Response,
  next: NextFunction
) => {
  try {
    const token = req.headers["authorization"]?.split(" ")[1];

    if (!token && !process.env.JWT_SECRET) {
      // Token does not exist or JWT_SECRET is not set in the environment variables
      console.log("Token does not exist");
      return res.status(401).send({
        message: "Authentication failed!",
        success: false,
      });
    } else {
      jwt.verify(
        token as string,
        process.env.JWT_SECRET as string,
        (err, decoded: any) => {
          // Verifying the token
          console.log("Verifying token");
          if (err) {
            // Error occurred during token verification
            console.log(err);
            return res.status(401).send({
              message: "JWT verification failed!",
              success: false,
            });
          } else {
            // Token is valid, extracting the user ID from the decoded token and attaching it to the request body
            (req.body as any).userId = (decoded as any)._id;
            next();
          }
        }
      );
    }
  } catch (error: any) {
    // Catching any other errors that might occur
    console.log(error.message);
    return res.status(401).send({
      message: "Authentication failed",
      success: false,
    });
  }
};

export default authMiddleware;`

then create a folder named routes and under this folder we will create a file named paymentRoute.ts, first of all :

`
//we import the stripe secret key and the public key from .env

const secret: string | undefined = process.env.STRIPE_SECRETKEY;
const publicKey: string | undefined = process.env.STRIPE_PUBLISHABLEKEY;

if (!secret) {
  throw new Error("Stripe secret key not found in environment variables.");
}

// Creating a new instance of the Stripe API using the secret key
const stripe = new Stripe(secret, {
  apiVersion: "2022-11-15",
});

after creating a new instance of stripe ,we pass to creating the connect ,
first we create the custom connect (assuming that the user is already defined ):

router.post(
  "/create-stripe-account",
  authMiddleware,
  async (req: Request, res: Response) => {
    try {
      const user = await User.findOne({ _id: req.body.userId });

      if (user) {
        if (!user.accountId) {
          // Creating a custom Stripe account for the user
          const accountParams: Stripe.AccountCreateParams = {
            country: "EE",
            type: "custom",
            business_type: "individual",
            email: user.email,
            capabilities: {
              card_payments: {
                requested: true,
              },
              transfers: {
                requested: true,
              },
            },
          };

          const account = await stripe.accounts.create(accountParams);

          // Saving the account ID to the user document
          user.accountId = account.id;
          await user.save();

          res.status(200).json({ data: account, success: true });
        } else {
          res
            .status(200)
            .json({ message: "You already have an account", success: false });
        }
      } else {
        res.status(404).json({ message: "User not found" });
      }
    } catch (error) {
      res.status(200).json("Something went wrong");
    }
  }
);

if you access to your stripe account ,you will find a new connect but it is restricted .
so , we must update the account using this route :

router.put(
  "/update-stripe-account",
  authMiddleware,
  async (req: Request, res: Response) => {
    try {
      const user = await User.findOne({ _id: req.body.userId });
      if (user) {
        const { firstName, lastName, email, accountId } = user;
        const birthDateString = user.birthDate; // Assuming `user.birthDate` is defined

        if (birthDateString) {
          const dateObj = new Date(birthDateString);

          const day = dateObj.getDate();
          const month = dateObj.getMonth() + 1; // Month is zero-based, so we add 1 to get the correct month
          const year = dateObj.getFullYear();



          const { city, line, postalCode, state, ipAddress, phone ,url,} = req.body;
          const date = Math.floor(Date.now() / 1000);

          const stripeAccount = await stripe.accounts.update(accountId, {
            business_type: "individual",
            settings: {
              payouts: {
                schedule: {
                  interval: "manual" as any,
                },
              },
            },
            email,

            individual: {
              first_name: firstName,
              last_name: lastName,
              email: email,
              maiden_name: firstName + " " + lastName,
              phone: phone,
              address: {
                city,
                line1: line,
                line2: line,
                postal_code: postalCode,
                state,
              },
              dob: {
                day,
                month,
                year,
              },
            },

            business_profile: {
              mcc: "7372",

              url: url,
              product_description:
                "Description of the business's products or services",
            },
            tos_acceptance: {
              date: date,
              ip: ipAddress,
            },
          });
          res.status(200).send({
            success: true,
            data: stripeAccount,
            message: "account updated successfully",
          });
        } else {
          res.status(404).send({
            message:
              "You should update your profile and add the missing information",
            success: false,
          });
        }
      }
    } catch (error) {
      console.log(error);
      res.status(500).json({ message: "something went wrong" });
    }
  }
);

MCC stands for Merchant Category Code. It is a four-digit code used to categorize businesses based on the products or services they provide. you can find mored details in this doc https://stripe.com/docs/connect/setting-mcc

now we should add a payout method , this is the route for adding payout method :

router.post(
  "/add-payout-method",
  authMiddleware,
  async (req: Request, res: Response) => {
    try {
      const user = await User.findOne({ _id: req.body.userId });
      if (user) {
        const accountId = user.accountId;
        const { accountType, accountDetails } = req.body;
        const account_holder_name = `${user.firstName} ${user.lastName}`;

        // Create a bank account or debit card token
        let externalAccountToken;
        if (accountType === "bank") {
          externalAccountToken = await stripe.tokens.create({
            bank_account: {
              country: "EE",
              currency: "eur",
              account_holder_name: account_holder_name,
              account_holder_type: "individual",
              account_number: accountDetails.accountNumber,
            },
          });
        } else if (accountType === "card") {
          externalAccountToken = await stripe.tokens.create({
            card: {
              number: accountDetails.cardNumber,
              exp_month: accountDetails.expMonth,
              exp_year: accountDetails.expYear,
              cvc: accountDetails.cvc,
              currency: "eur",
            },
          });

          const externalAccount = await stripe.accounts.createExternalAccount(
            accountId,
            {
              external_account: externalAccountToken.id,
            }
          );

          await stripe.accounts.update(accountId, {
            capabilities: {
              transfers: { requested: true },
            },
          });
        } else {
          return res.status(400).json({ message: "Invalid account type" });
        }

        // Associate the bank account or debit card with the Stripe account
        await stripe.accounts.createExternalAccount(accountId, {
          external_account: externalAccountToken.id,
        });

        res
          .status(200)
          .json({ success: true, message: "Payout method added successfully" });
      } else {
        res.status(404).json({ message: "User not found" });
      }
    } catch (error) {
      res.status(500).json({ error });
    }
  }
);

test this route with this json file :

{
  "accountType": "bank",
  "accountDetails": {
    "accountNumber": "EE382200221020145685"
  }
}

after adding payout method now the custom connect is ready to receive money , this is the route for making transfer:

router.post("/transaction/:contractId", authMiddleware, async (req, res) => {
  try {
    const user = await User.findOne({ _id: req.body.userId });

    const contract = await Contract.findOne({
      _id: req.params.contractId,
    });
    if (user && contract) {
      const paymentIntent = await stripe.paymentIntents.create(
        {
          amount: contract.price,
          currency: "eur",
          automatic_payment_methods: {
            enabled: true,
          },
        },
        {
          stripeAccount: user.accountId,
        }
      );

      console.log("user and contract found");
      const freelancerTransfer = await stripe.transfers.create({
        amount: contract.price*99,
        currency: "eur",
        destination: user.accountId,
      });


      user.unSeenNotifications.push(
        "your transaction is  created successfully"
      );
      user.save();

      res.status(200).json({
        message: "Transfer created successfully",

      });
    } else {
      res.status(404).json({ message: "User or contract not found" });
    }
  } catch (error) {
    res.status(500).json({ error });
  }
});

for my project , the amount was taken from the contract price .
after making the the last route and test it with postman ,and we can access to our stripe dashboard :

we see that the connect has received his money and he is ready to payout.

Note:I'm speaking for test mode

That's it , I wish it was helpful !
I'm waiting for your feedbacks

TypeError: this.userRepository.signUp is not a function

Ahmed Ben Bettaieb — Mon, 24 Oct 2022 22:47:04 +0000

I'm new on nest js and I encountered this error while developping login service ``import { Injectable } from '@nestjs/common';
import { UserRepository } from './user.repository';
import { InjectRepository } from '@nestjs/typeorm';
import { AuthSignUpDto } from './dto/auth-signup.dto';

@Injectable()
export class AuthService {
constructor(
@InjectRepository(UserRepository)
private userRepository: UserRepository,
) {}
async signUp(authSignUpDto: AuthSignUpDto): Promise {
return this.userRepository.signUp(authSignUpDto)
}
}

Route is not working

Ahmed Ben Bettaieb — Sun, 01 May 2022 14:07:01 +0000

I'am working on a full stach web site using spring and angular but the routes are not working
this is the spring boot application code to search category by ID

and here is the routes

and this is the product service class and the his urls

and this is the product list component