VeroSMS Docs
Installation Guide

Get VeroSMS running

Build your own copy of the Android app, put the panel on your hosting, pair a phone, and watch it send a real text. Follow the parts in order and nothing here assumes you have done any of it before.

Version 4.0.2 Laravel 12 PHP 8.2+ MySQL 5.7+ Android 7+
Start here

Introduction

Three things to know before you start.

1. Android only. The gateway app is an Android application. No iOS version is included, and an iPhone cannot be used as a sending device. The admin panel is a website and opens in any browser, on any device, including an iPhone — but the phones that actually send the SMS must be Android 7.0 or newer.

2. Firebase Cloud Messaging (FCM) is a hard requirement, and Firebase is Google's, not ours. Without it your phones are never woken and no message is ever sent — it is not an optional extra. VeroSMS uses Firebase Cloud Messaging to wake your phones the moment there is work. You create and own that project with a free Google account. Cloud Messaging — the only Firebase service this product uses — is currently offered by Google at no cost, but Google sets those terms and can change them, and a project on a paid plan, or one where you switch other Firebase services on, can be billed to you by Google. Any such cost is between you and Google. See Google's Firebase pricing page.

3. AI assistance was used in building this product. See How this product was built at the end of this guide for exactly what that means.

VeroSMS is a self-hosted SMS gateway. Instead of buying messages from a bulk SMS provider, you pair your own Android phones with your own copy of the panel and send through the SIM cards already in them — one message, thousands of messages, or a personalised campaign, from the panel or from your own software over the API.

You install it once, on your own hosting, and you are the only person who uses it. There is one panel and one account. You can create extra staff logins with roles for the people who work with you, and that is as far as it goes.

This guide covers installation and first-run setup only. For day-to-day use of the panel — every screen and what it does — see the User Manual included in the same download.

You do not need to be a developer. Part 1 walks through Android Studio click by click, and Part 2 is a five-minute wizard in your browser. If you can upload a file and create a MySQL database in cPanel, you can finish this guide.

Do the Android app first, before you touch the server. The app has to exist before a phone can be paired, and the Firebase project you create in step 1 is also what the server needs later. Working in the other order means going back and redoing things.

Firebase is not optional. Without it the panel installs perfectly, accepts messages perfectly, and never delivers one. Messages sit at queued and no error appears anywhere — not on the screen, not in the logs. Both Firebase steps in this guide have to be done.

Start here

How VeroSMS works

Five minutes here saves an hour later, because almost every problem people hit is a break in one specific link of this chain.

The path of one message
Panel or API  →  your server  →  Firebase  →  the phone  →  the SIM  →  recipient
                     ↑                                          │
                     └─────────  what happened  ────────────────┘
  • The panel or the API accepts your send and writes each message into a queue, addressed to one specific phone and one specific SIM slot.
  • Your server then sends a Firebase push to that phone. This is the only thing that can wake a sleeping Android handset — nothing else is allowed to.
  • The phone wakes up, calls back for its own queued messages, and puts them on the network through the SIM you chose.
  • The phone reports back what happened — sent, delivered, failed — and the panel shows it against the message.
  • Replies that arrive on that SIM are caught by the app and appear in the panel's Inbox.

Nothing is lost when a link breaks. A phone that is switched off, out of coverage or not yet paired leaves its messages waiting in the queue, and they go out when it comes back. That is why a half-finished installation looks like silence rather than an error.

Start here

What is in the download

The file you downloaded from CodeCanyon unzips to this:

Download contents
VeroSMS Project Files V-4.0.2/
├── Admin Panel Source Code/
│   └── verosms-admin-panel-v4.0.2.zip    The web application. This is the
│                                         only thing that goes on your server.
├── Android App Source Code/
│   └── verosms-android-app-v4.0.2.zip    The Android Studio project. You build
│                                         your own app from this, in Part 1.
├── demo/
│   ├── verosms-demo-v4.0.2.apk           A ready-built app, for looking at
│   │                                     before you build your own.
│   └── demo site url.txt                 The live demo address and its login.
├── documentation/
│   └── index.html                        This guide.
├── user-manual/
│   └── index.html                        How to use the panel, screen by screen.
├── CHANGELOG.txt                         What changed in each version.
└── readme.txt                            A one-page map of the above.

Two zips matter and the rest is reading. Android App Source Code/verosms-android-app-v4.0.2.zip is Part 1 of this guide. Admin Panel Source Code/verosms-admin-panel-v4.0.2.zip is Part 2.

The demo APK is not the app you will ship. It is built against our Firebase project and our demo server, so it can show you what the app looks like and nothing else. Your own app has to be built from the source in Part 1, with your own Firebase file — a phone cannot be woken by a project it does not belong to.

Do not upload the whole download to your server. Only the contents of verosms-admin-panel-v4.0.2.zip go online. Putting the documentation, the user manual, the demo APK and the Android project on a public web server publishes files that serve no purpose there.

Start here

What you need

Gather these before you start. Almost every shared host sold in the last few years meets the server side, and the installer checks all of it for you and says exactly what is missing.

On your computer, for Part 1

  • A Google account — any Gmail address works. This is what you sign into Firebase with.
  • Android Studio — free, from Google. Step 4 tells you where to get it.
  • About 10 GB of free disk space and a reasonable connection. The first time Android Studio opens a project it downloads a lot.

Server

RequirementMinimumNotes
PHP8.28.3 or 8.4 recommended
MySQL5.7MariaDB 10.3+ also works
Web serverApache / Nginx / LiteSpeedmod_rewrite enabled on Apache
HTTPSRequired in productionThe phone’s credential and your messages travel over this connection. Plain http is only for testing on your own local network
Outbound HTTPSMust be allowedYour server calls Firebase; a host that blocks it stops delivery
Firebase Cloud MessagingRequired — hard dependencyWakes your phones when a message is waiting. A free Google project you create in Part 1; without it nothing is delivered
CronOnce per minuteStep 5 of Part 2
Disk~250 MBPlus room for logs and uploads
PHP limits64 MB uploads, 256 MB memoryDefaults on most hosts; see Server configuration if yours are lower

Getting the HTTPS certificate. Production needs a valid SSL certificate — over the internet, the phone’s credential and your messages must never travel over plain http. (The app accepts an http address only so that you can test on your own local network.) You almost never have to buy one. On cPanel or Plesk hosting, open SSL/TLS Status (or Let’s Encrypt) and let AutoSSL issue and renew a free certificate for your domain in a couple of clicks. On hPanel (Hostinger) it is Security › SSL. If your host has no such button, a free Let’s Encrypt certificate from your host’s support, or a certificate from your domain registrar, works just as well. Install it before you pair any phone — pairing itself happens over HTTPS.

PHP extensions

All of these are required. Most are switched on by default, and the installer tells you if one is not:

ExtensionExtensionExtensionExtension
BCMathCtypecURLDOM
FileinfoJSONMbstringOpenSSL
PDOPDO MySQLSessionTokenizer
XMLGDZip—

Writable folders

These three must be writable by the web server. On cPanel set them to 755; if the installer still reports them as unwritable, use 775.

Must be writable
storage/
bootstrap/cache/
public/uploads/

Phones

RequirementMinimumNotes
Android7.0 (API 24)Android 9 or newer recommended
Google Play servicesRequiredFirebase push does not work without it
SIM1 or 2 slotsDual-SIM handsets work, each slot separately
An SMS allowanceYesEvery message is a real SMS, charged by your carrier
Part 1 — step 1

Create a Firebase project

Firebase is a free Google service. VeroSMS uses one small part of it: the ability to wake a phone that is asleep. A phone cannot be reached over the internet on demand — it sleeps, its address changes, and Android will not let an app sit awake waiting. A Firebase push is the knock on the door.

Everything else in Part 1 depends on this project existing, so it comes first.

1

Open the Firebase console

In your browser, go to the address below and sign in with your Google account.

Open in your browser
https://console.firebase.google.com
2

Click Create a project

It is the big card with a plus sign on it. On an account that already has projects, the same button reads Add project.

3

Give it a name

Anything you like — your company name, or just VeroSMS. Nobody but you sees it. Google adds a few random characters to make the internal id unique; that is normal and you can ignore it. Click Continue.

4

Switch Google Analytics off

The next screen offers Google Analytics. VeroSMS does not use it. Turn the toggle off and click Create project. Leaving it on does no harm, but it adds two more screens you do not need.

5

Wait for it, then click Continue

A spinner runs for twenty or thirty seconds and then says Your new project is ready. Click Continue and you land on the project overview page, with your project name at the top left.

Leave this tab open. The next step starts from this page.

What this costs. Firebase is a Google service and is not part of VeroSMS. You create the project, you own it, and the account is yours. Cloud Messaging — the only Firebase service VeroSMS uses — is currently offered by Google at no cost on the free Spark plan, whatever your message volume, and VeroSMS sends no message text through it, only a short "there is work waiting" signal.

Google sets those prices and limits and can change them at any time, and a project moved to a paid plan, or one where you switch other Firebase services on, can be billed to you by Google. Check Google's Firebase pricing page before you deploy, and again if your volume grows. Google may offer you an upgrade while you create the project; you do not need it.

The Firebase console with the Create a project button
Firebase console — creating the project
Part 1 — step 2

Register the Android app

Your Firebase project now exists, but it does not know about any app yet. Telling it about yours is what produces the file the app needs — and it is where you choose your package name.

First: what a package name is

A package name is the permanent, worldwide-unique id of an Android app. It is not the name people see on the phone; that is the app name, which you set separately in step 5. The package name is what Android, Google Play and Firebase use behind the scenes to tell your app apart from every other app in the world.

It is written in reverse-domain form — your domain backwards, then a word for the app:

The shape of a package name
com.yourcompany.yourapp

So if your website is acmetrading.com and you want to call the app Acme SMS, a good package name is com.acmetrading.acmesms. You do not have to own the domain, and nothing checks — it is a naming habit that keeps ids from colliding.

The rules

  • Lower case letters, digits and dots. Nothing else.
  • No spaces and no hyphens. com.acme-trading.sms is not valid; com.acmetrading.sms is.
  • At least two parts separated by a dot. Three is normal.
  • No part may start with a digit. com.4acme.sms is not valid.
  • Do not use com.example or anything with "example" in it. Google Play rejects it, and it marks the app as a leftover template.

Decide this now, and write it down. Firebase and Android Studio must be given exactly the same package name, character for character, and you are about to type it into Firebase. If they disagree, the app builds and installs quite happily and then never receives a single push — no error, no warning, just silence.

It also cannot be changed after an app is published: to Android, a different package name is a different app, not a new version of the same one. Pick something you will still be happy with in three years.

1

Click the Android icon

On the project overview page, in the middle, is a line reading Get started by adding Firebase to your app with a row of round icons under it. Click the Android one — the green robot head.

2

Type your package name

The first box is labelled Android package name and it is the only one that matters. Type the package name you decided on above. Check it twice.

3

Leave the other two boxes alone

App nickname is optional and only ever shown to you inside Firebase. Debug signing certificate SHA-1 is optional and not needed — it is for Google sign-in and similar features that VeroSMS does not use. Leave it empty.

4

Click Register app

After a few seconds the page moves on to a step called Download config file, with a download button on it. That is the next section of this guide — do not close the tab.

Keep your package name somewhere you can copy it from. A note on your desktop is fine. You will type it again in step 6, and it has to match this one exactly.

Registering an Android app in Firebase, with the package name field filled in
Firebase — registering the Android app, with your own package name
Part 1 — step 3

Download google-services.json

This small text file is how the app knows which Firebase project it belongs to. Without it in the right place, the app cannot be woken, and everything downstream of that fails quietly.

1

Click Download google-services.json

You are on the Download config file step from a moment ago. The button is in the middle of the screen. The file lands in your Downloads folder.

2

Move it somewhere you will find it again

Your desktop is ideal. You need it in step 7, possibly an hour from now, and hunting through Downloads for a file called google-services.json next to forty other things is a bad five minutes.

Do not rename it. Android Studio looks for that exact filename.

3

Click Next until you reach the console

Firebase now shows two screens of setup instructions about adding SDKs to your Gradle files. Skip them. The VeroSMS project already has every one of those lines in it. Click Next, then Next, then Continue to console.

If you lose the file, you can get it again. In the Firebase console, click the gear beside Project Overview, choose Project settings, scroll to Your apps, and there is a download button next to your Android app. It is the same file.

This is not the file your server needs. There are two different Firebase files in this guide and they are not interchangeable. This one belongs to the app. The other one — the service account key — is downloaded in Part 2, step 6 and belongs to the server. Do not swap them.

The Download google-services.json button in Firebase
Firebase — downloading google-services.json
Part 1 — step 4

Open it in Android Studio

Android Studio is the free program Google makes for building Android apps. You will use perhaps five of its menus. It is large and it is slow the first time, and then it is fine.

1

Download and install Android Studio

Go to the address below, click the big download button, accept the terms, and install it the way you install anything else on your computer. It is free, and there are versions for Windows, macOS and Linux.

Open in your browser
https://developer.android.com/studio

The first time you run it, a setup wizard appears. Choose Standard and accept the licences. It then downloads the Android SDK, which is another large download. Let it finish.

2

Unzip the Android project from your download

From the CodeCanyon download, open Android App Source Code/ and extract verosms-android-app-v4.0.2.zip somewhere sensible on your computer — your Documents folder is fine.

Keep the path short and free of spaces and accented characters. Some Gradle versions still trip over them.

3

File › Open

In Android Studio, use the File menu and choose Open. On the welcome screen that appears when no project is open, the same thing is the Open button.

Navigate to the app folder and select the folder itself — not a file inside it, and not the folder above it. The right folder is the one that directly contains a folder called app and a file called settings.gradle. Android Studio marks it with a small green robot icon. Click OK.

If you are asked whether you trust the project, click Trust Project.

4

Wait for Gradle to finish

Gradle is the tool that assembles the app. On first open it downloads itself, plus the libraries the project uses. This takes ten to thirty minutes on a normal connection, and it only happens once.

While it runs, the bottom of the window shows a progress bar and text like Gradle: resolving dependencies. The editor may show red underlines everywhere. Ignore all of it and do not start clicking around.

You are done when the status bar at the bottom reads Gradle sync finished (some versions say Sync successful, or show a green tick in the Build panel). The red underlines disappear at that moment, and the left-hand Project panel fills with folders.

5

Say no to every upgrade it offers

Android Studio will pop up suggestions along the lines of Android Gradle Plugin upgrade recommended, Gradle update available or Plugin update available. Dismiss them. Click Don't remind me again for this project, or just close the notification.

The project is built and tested against the versions it ships with. Accepting an upgrade rewrites your build files and is the single most common way people turn a working project into a page of errors they cannot read.

If the sync fails, the Build panel at the bottom shows a red message. Nine times out of ten it is one of two things: no internet connection reaching Google's servers, or a company or school network blocking them. Check the connection, click Try Again, and see Troubleshooting if it persists.

Two panels are worth knowing. The Project panel down the left side is the file tree; everything this guide asks you to open is found there. The Build panel along the bottom is where Android Studio says whether the last thing worked.

The VeroSMS project open in Android Studio after Gradle has finished
Android Studio — the project open, Gradle finished
Part 1 — step 5

Change the app name

This is the name that appears under the icon on the phone and in Android's app list. It is ordinary text: spaces, capitals and accents are all fine. It has nothing to do with the package name.

1

Open the file that holds it

In the Project panel on the left, open the folders one at a time until you reach this file, then double-click it:

File to open
app/src/main/res/values/strings.xml

A quicker route, once you trust it: press Shift twice, type strings.xml, and press Enter.

2

Find the app_name line

Near the top of the file is a line that looks like this. The text between the two tags is the name on the phone:

In strings.xml
<string name="app_name">VeroSMS</string>
3

Replace the text in the middle

Change only the words between > and <. Leave name="app_name" exactly as it is — that is the label Android looks the name up by, not the name itself.

After your edit
<string name="app_name">Acme SMS</string>
4

Save

Ctrl+S, or ⌘S on a Mac. Android Studio also saves on its own, but get into the habit.

Keep it short. Android gives you room for roughly twelve characters under an icon before it starts cutting the name off with a dash.

Do not touch the other lines in this file. They are text the app shows on its own screens. Changing one at random produces an app with an empty button on it, and the mistake is not obvious later.

strings.xml open in Android Studio with the app_name value selected
Android Studio — app_name in strings.xml
Part 1 — step 6

Your icon, splash and colours

The app already carries your name. Three more changes and it carries your brand: the icon under it, the screen it opens on, and the colour everything else uses. None of them needs you to write code, and all three are quicker than the Firebase steps were.

Any visual change means rebuilding the app, not updating a setting. The icon, splash and colours live inside the Android app, not in the panel — so after you change any of them you must rebuild the APK (step 9) and reinstall it on every paired phone. The phones keep working on their old build until you do; nothing updates over the air. This is why it is worth settling your branding here, before step 9, rather than after you have installed on a fleet of handsets.

1

The app icon

Android Studio generates every size for you from one square image. Have a PNG ready before you start: square, at least 512 × 512, ideally on a transparent background.

First delete the icons that ship with the project. In the project tree open app/src/main/res/mipmap. In Android Studio's default Android view you will see three entries there, each with a number beside it:

  • ic_launcher
  • ic_launcher_foreground
  • ic_launcher_round

Click the first, hold Shift, click the last so all three are highlighted, then right-click and choose Delete. Android Studio warns that they are used in the manifest — go ahead anyway. The next step puts them all back with your icon in them.

The three mipmap entries selected in the Android Studio project tree
All three selected together, ready to delete

If you have switched to the Project view rather than the Android view, the same icons appear as six folders instead of three entries — mipmap-anydpi-v26, mipmap-hdpi, mipmap-mdpi, mipmap-xhdpi, mipmap-xxhdpi and mipmap-xxxhdpi. Delete all six. It is the same files either way; the Android view simply groups them by name.

Now right-click the mipmap folder and choose New › Image Asset. (Right-clicking res works too — the dialog is the same.) In the dialog that opens:

  • Icon Type — Launcher Icons (Adaptive and Legacy).
  • Name — leave it as ic_launcher. Changing it means editing the manifest, and there is no reason to.
  • Foreground Layer › Asset Type › Image, then Path › your PNG. Drag the Resize slider until the logo sits comfortably inside the circle in the preview on the right — around 60–70% is usually right. Anything touching the edge gets cropped on round launchers.
  • Background Layer › Asset Type › Color, and pick your brand colour.

Click Next, then Finish. The icons reappear, generated at every density, with round and adaptive versions included. Build the APK in step 9 and the phone shows your icon under your app name.

The Image Asset dialog in Android Studio with a logo chosen
New › Image Asset — your PNG as the foreground, your colour behind it
2

The screen the app opens on

Two files, both plain XML, both in the project you already have open.

The background is app/src/main/res/drawable/bg_brand_gradient.xml — a three-stop gradient. Put your own colours in, or set all three the same for a flat fill:

bg_brand_gradient.xml
<gradient
    android:angle="135"
    android:startColor="#4F46E5"
    android:centerColor="#6D28D9"
    android:endColor="#7C3AED"
    android:type="linear" />

The mark in the middle is in app/src/main/res/layout/activity_splash.xml. It is an ImageView pointing at @drawable/ic_send. Drop your own drawable into res/drawable and point android:src at it instead. Remove the app:tint line if your mark has colours of its own, or it is painted flat white.

activity_splash.xml open in Android Studio beside the drawable folder
The two files behind the opening screen
3

The colour the rest of the app uses

Buttons, highlights, switches and the status bar all read three values from app/src/main/res/values/colors.xml:

colors.xml
<color name="brand">#4F46E5</color>
<color name="brand_dark">#4338CA</color>
<color name="brand_light">#818CF8</color>

Change those three and the whole app follows. Keep brand_dark a shade darker than brand and brand_light a shade lighter, or pressed and disabled states stop being distinguishable from the normal one.

4

The small icon in the status bar

While the gateway runs, Android shows a small icon in the status bar and on the gateway notification. That icon is not your launcher icon from step 1, and changing the launcher icon does not change it. It lives in two files:

The notification icons
app/src/main/res/drawable/ic_send.xml   the gateway notification (always on)
app/src/main/res/drawable/ic_warn.xml   the "needs attention" notification

They are set in services/GatewayService.java with setSmallIcon(R.drawable.ic_send) and setSmallIcon(R.drawable.ic_warn).

Android draws this icon as a silhouette. It uses only the shape (the transparent and non-transparent parts) and paints it in the system colour. A full-colour logo, a photo or a square image therefore shows up as a plain grey or white square. If you replace these files, use a flat, single-colour icon on a transparent background — white on transparent is the convention. The easiest way: right-click res › New › Image Asset, choose Icon type: Notification Icons, point it at a simple one-colour version of your logo, and name it ic_send. The icons that ship are already in this format, so leaving them as they are is perfectly fine.

The admin panel is branded separately, from inside the panel itself — no files to edit. That is covered in Make it yours, after the server is installed.

Part 1 — step 7

Change the package name

This is the step where the app is told the id you registered in Firebase back in step 2. Get this exactly right and the rest of Part 1 is mechanical. Get it wrong by one character and the app installs and never receives anything.

There are two halves to it: two lines in a build file, which is the half that actually matters, and the folder names, which are cosmetic. Do them in that order.

1

Open the module build file

In the Project panel, open this file:

File to open
app/build.gradle

There are two files called build.gradle in the project. You want the one inside the app folder. In the Android view of the Project panel they are grouped under Gradle Scripts and the right one is labelled (Module :app). The other one, labelled (Project), is not it.

2

Find namespace and applicationId

Near the top, inside the android { } block, are two lines that both contain the package the app currently ships with:

In app/build.gradle
android {
    namespace = 'com.softnix.verosms'

    defaultConfig {
        applicationId "com.softnix.verosms"
        minSdk 24
        targetSdk 37
        ...
    }
}

The exact text in your copy may differ. Whatever is there, those two lines are the ones to change.

3

Put your own package name in both

Replace the text inside the quotes on both lines with the package name you registered in Firebase. Keep the quotes. Keep everything else on the line.

After your edit
android {
    namespace = 'com.acmetrading.acmesms'

    defaultConfig {
        applicationId "com.acmetrading.acmesms"
        minSdk 24
        targetSdk 37
        ...
    }
}

Do not change minSdk or targetSdk. minSdk 24 is what lets the app run on Android 7 and newer.

4

Click Sync Now

Saving the file makes a yellow bar appear across the top of the editor reading Gradle files have changed since last project sync. Click Sync Now on the right of that bar and wait for Gradle sync finished at the bottom.

applicationId is the one that must match Firebase, exactly. It is the id the built app carries, and it is the id Firebase checks a push against. com.acme.sms and com.acme.SMS are two different apps as far as Android is concerned.

Compare it against Firebase now, on screen, rather than from memory: Firebase console › gear icon › Project settings › Your apps. The package name is printed there. If the two differ, fix this file — not Firebase, because a registered package name cannot be edited afterwards.

The folders, if you want them to match

Your Java code still lives in folders named after the old package. Android does not care — the app builds and runs perfectly either way, because applicationId is what gets shipped. If tidy folders matter to you, Android Studio can rename them safely:

1

Show the parts separately

In the Project panel, open app › java. You see the old package as one long line, like com.softnix.verosms. Click the gear icon at the top of the Project panel and untick Compact Middle Packages. The single line becomes three nested folders: com, then softnix, then verosms.

2

Rename one folder at a time

Right-click a folder, choose Refactor › Rename. If a dialog asks, choose Rename package. Type the new name for that one part only — acmetrading, not the whole dotted string — and click Refactor.

Repeat for each part you are changing. Android Studio rewrites every reference in the code as it goes; that is exactly why you use this menu instead of renaming folders by hand.

3

Sync and rebuild

Click Sync Now if the yellow bar reappears, then Build › Clean Project, then Build › Rebuild Project. Watch the Build panel for BUILD SUCCESSFUL.

If the rename goes wrong, undo it and move on. Press Ctrl+Z / ⌘Z until the folders are back, or close the project without saving and reopen it. The folder names are decoration. As long as namespace and applicationId hold your package name and the project builds, your app is correct and nobody will ever see those folders.

The applicationId line in app/build.gradle
Android Studio — applicationId in app/build.gradle
Part 1 — step 8

Add your google-services.json

The project ships with a placeholder copy of this file so that it builds out of the box. It points at a Firebase project that is not yours. Replacing it is what ties the app to your project.

1

Find the file that is already there

The file sits directly inside the app folder:

Where it goes
app/google-services.json

The Project panel hides it in the default Android view. Click the dropdown at the top of that panel — it says Android — and change it to Project. You now see the real folders on disk, and google-services.json is inside app, next to build.gradle.

2

Delete it

Right-click the existing google-services.json and choose Delete. Confirm.

3

Drop yours in its place

Drag your downloaded google-services.json from your desktop onto the app folder in the Project panel. Android Studio asks where to put it and offers the path; accept it. Alternatively copy the file into the app folder in your computer's own file browser — it is the same thing.

Check the name has no (1) or -2 in it. A file called google-services (1).json is invisible to the build, and the app silently keeps using nothing.

4

Sync once more

Use File › Sync Project with Gradle Files. If the package name in your file does not match the applicationId you set in step 6, the build fails here with a clear message naming both. That is a useful failure, not a disaster: fix the applicationId to match and sync again.

Switch the Project panel back to Android when you are done if you prefer that view. Nothing depends on it; it only changes what you see.

google-services.json sitting in the app folder of the project
Android Studio — your google-services.json in the app folder
Part 1 — step 9

Build the APK

An APK is the single file that installs an Android app. This step turns the project into one.

1

Build › Build Bundle(s) / APK(s) › Build APK(s)

Open the Build menu at the top, hover Build Bundle(s) / APK(s), and click Build APK(s). Do not pick Build Bundle(s) — a bundle is a Play Store upload format and cannot be installed on a phone.

2

Wait for it

The first build takes a few minutes; later ones take seconds. The Build panel at the bottom ends with BUILD SUCCESSFUL.

3

Click locate in the notification

A small notification appears in the bottom right: APK(s) generated successfully, with a locate link. Click it and your computer's file browser opens on the folder containing the file.

If the notification has already faded, the file is here, under your project folder:

Where the APK lands
app/build/outputs/apk/debug/app-debug.apk
4

Copy it somewhere sensible

Rename it to something you will recognise — acme-sms.apk — and keep it with your other project files. That one file is your app. Anyone you hand it to can install it.

A debug build is a real, fully working app. It sends real SMS, it receives pushes, it does everything. "Debug" only describes how it is signed. For your own phones it is all you ever need.

If you want a release build

A release build is signed with a key that is yours, which is required to publish on Google Play and sensible if you are distributing the app more widely. It lands in app/build/outputs/apk/release/ instead.

  • Use Build › Generate Signed Bundle / APK, choose APK, and click Next.
  • Click Create new… to make a keystore. Choose a path, set two passwords, fill in the name fields, and click OK.
  • Choose the release build variant and click Create.
  • Back up the keystore file and both passwords. They cannot be recovered or regenerated, and without them you can never publish an update to the same app on Google Play. Keep a copy somewhere that is not this computer.

Thinking of publishing the app on Google Play? Read this first. Google restricts the SMS permissions this app needs (SEND_SMS and RECEIVE_SMS) to apps that are a phone’s default SMS app or qualify for one of its listed exceptions, and reviews every app that asks for them. A gateway like VeroSMS is normally installed directly on your own phones from the APK you built, not published on the Play Store. If you do intend to publish it, check Google’s SMS and Call Log permissions policy before you start.

Build, Build Bundles and APKs, Build APKs in the Android Studio menu
Android Studio — Build › Build APK(s)
The notification offering to locate the finished APK file
Android Studio — the finished APK, and where to find it
Part 1 — step 10

Install it on a phone

Any handset on Android 7 or newer, with Google Play services and a SIM in it.

Read this before you start: Google Play Protect may warn about this install.

It is not a fault in the app and it does not mean anything is wrong with your build. Google treats the permission to send SMS as highly sensitive, so Play Protect often shows a warning — Unsafe app blocked or App scan — for any app that asks for it and did not come from the Play Store, including a build of your own.

Leave Play Protect switched on. When the warning appears, tap More details and then Install anyway. You are installing an app you built yourself, from source code you can read.

If your phone offers no “Install anyway”, install it from Android Studio instead. On the phone, open Settings › About phone and tap Build number seven times, then turn on Developer options › USB debugging. Connect the phone with a USB cable, accept the prompt on its screen, choose the phone in Android Studio's device list at the top, and press Run (the green ▶). The app is installed directly onto the phone.

1

Get the APK onto the phone

Email it to yourself and open it on the phone, put it in Google Drive or Dropbox and download it there, or plug the phone into the computer with a USB cable and copy it to the Downloads folder. Any of these is fine.

2

Tap the file and allow installs from that app

Open the phone's Files app, find the APK in Downloads, and tap it. Android says the app you are using is not allowed to install unknown apps. Tap Settings, switch Allow from this source on, and press Back. Tap the file again, then Install.

You are granting this to the app you opened the file with — Files, Chrome, Gmail. It is a one-off and only affects that app.

If Play Protect shows a warning now, tap More details › Install anyway, as described in the note above. Leave Play Protect switched on.

3

Open the app and grant its permissions

The app asks for several permissions as it starts. Grant all of them. It cannot work without them, and Android will not ask twice — a refusal has to be undone by hand in Settings.

PermissionWhy the app needs it
Send SMSThe entire point. Without it nothing sends.
Receive SMSReplies are captured and appear in the panel's Inbox.
Phone stateTells the app which SIM sits in which slot, so you can pick one. It does not read your phone number, contacts or call history.
CameraOnly to scan the pairing QR code. Optional — you can type the pairing code instead.
NotificationsAndroid requires a visible notification for a service that keeps running in the background. That small permanent notification is how the app stays alive.
4

Turn battery optimisation off for the app

In Android's Settings › Apps › your app › Battery, choose Unrestricted.

Skip this and Android puts the app to sleep after a while. Messages then arrive in bursts, hours late, usually the moment somebody unlocks the phone — which looks like a fault in the server and is not.

On Xiaomi, Oppo, Vivo, Realme and Huawei handsets there is a second setting of the manufacturer's own, usually called Autostart, App launch or Protected apps. It is not where Android puts its own setting, and it overrides it. Turn it on too.

The app has nothing to configure. No server address to type, no login. It stays on the pairing screen until Part 2 gives it a code. That is expected — leave it there and go and install the server.

The Android install screen for the VeroSMS APK
On the phone — installing the APK you built
The permissions screen in the VeroSMS app
On the phone — granting the permissions the gateway needs
Part 2 — step 1

Upload the files

Open the Admin Panel Source Code/ folder from your download. Inside it is one file, verosms-admin-panel-v4.0.2.zip. That single file is the whole web application, and it is the only thing that goes on your server.

1

Open the File Manager

Every hosting panel has one. In hPanel it is Files › File Manager; in cPanel it is in the Files group as well.

Open the folder your web address already points at — on most accounts that is public_html. If you are installing on a subdomain, create the subdomain in your panel first and open the folder it made for you.

2

Upload the zip

Click Upload and choose verosms-admin-panel-v4.0.2.zip. It is about 6 MB, so it finishes in a few seconds.

Uploading the VeroSMS zip in the hosting panel File Manager
Uploading verosms-admin-panel-v4.0.2.zip into your site folder
3

Extract it

Select the uploaded file and click Extract, into the same folder.

Extract it on the server. Do not unzip it on your computer and upload the loose files instead: that is thousands of small files over FTP, it is slow, it quietly drops a few on the way, and one missing file produces errors that look nothing like the real cause.

The uploaded zip selected in the File Manager with the Extract action
Extracting it on the server, in the same folder
4

Check it landed flat, then delete the zip

You should now see app/, public/, config/, artisan and the rest sitting directly in that folder — not inside a second folder. If everything went one level too deep, move the contents up one level. A nested copy is the commonest cause of a blank page at this stage.

Then delete the zip from the server. It has done its job, and leaving a downloadable copy of your whole application online is not something you want.

That is the upload finished. Open your web address in a browser and the application takes over from there — the next step is only needed because the installer will ask you for a database.

One check before you go on. Open https://yourdomain.com/.env in a browser. You should get a 403 or a 404. If a file downloads instead, your server is ignoring the .htaccess that ships with the application — stop here and ask your host to enable AllowOverride, because that file is about to hold your database password.

If your panel lets you change a domain's document root, there is a tidier arrangement: upload into a folder outside public_html and point the document root at <that folder>/public. Then nothing private sits in a web-served folder even for a moment. It is optional — the .htaccess in the zip does the same job on hosts that fix the document root, which is most shared plans.

There is no .env to rename or edit. Older versions of this product shipped one; this one does not, and that is deliberate. A shipped .env would carry the same encryption key in every copy of the download. The application writes its own the first time you open the site, with a key that has never existed anywhere else.

Part 2 — step 2

Create a database

VeroSMS needs one empty MySQL database and a user with full access to it. Create it now and keep the details to hand — the installer asks for them on its database screen, and that is the only place they are ever typed.

1

Open the databases page in your panel

In hPanel: Databases › Management. In cPanel: MySQL® Databases.

2

Create the database and its user

Type a database name, a username and a password, and create it. hPanel makes all three in one form and gives the user full access automatically, which is all VeroSMS needs.

On cPanel it is three smaller steps on the same page: create the database, create the user, then add the user to the database and tick ALL PRIVILEGES. Do not skip that last tick — the installer reports a missing privilege as a connection failure, because from the outside the two look identical.

Use the password generator if your panel offers one, and copy the password into a note before you save. No panel will show it to you a second time.

Write these four down exactly as the panel shows them. The installer asks for all four in step 3:

  • Database name — including the account prefix your panel adds, for example u123456789_verosms, not the short name you typed.
  • Database user — with its prefix too.
  • Password — the one you just copied.
  • Host — almost always localhost. A few hosts give a separate database server address instead; if yours did, use that.
A created MySQL database and user listed in the hosting panel
hPanel — the database, its user and its password in one form. The greyed box on the left of each field is the prefix your panel adds; the installer needs the whole name, prefix included
Part 2 — step 3

Install the libraries

Open your domain in a browser. The first thing you will see is not the setup wizard — it is a short page called Install the libraries, with one button on it.

Why this page exists. VeroSMS is sold as source code, and the marketplace requires a PHP item to ship only its own source — not a copy of the open-source libraries it is built on. So the download does not contain the vendor folder, and this page fetches it for your server. It happens once, and you never see this screen again.

1

Read the server check

The page lists what it needs and ticks off what your server already has. Almost everything on a normal shared host is green the first time.

A red row has to be fixed before the button will work, and every one of them is something your hosting control panel can change — usually under Select PHP version. An amber row is a note, not a blocker.

The library installer checking the server, with every requirement green
Step 3 — the server check, before anything is installed
2

Press “Install the libraries”

It takes a minute or two and prints what it is doing as it goes. Leave the tab open.

When it finishes you get a Continue to the installer button. That is the end of this step.

The libraries installed, with a button to continue to the setup wizard
Step 3 — finished, with the way on to the wizard

If the button cannot finish. A very small number of hosts have neither Composer installed nor outbound internet. The page then prints one command, which does exactly the same job:

Terminal
cd <your-installation-path> && composer install --no-dev --optimize-autoloader

Replace <your-installation-path> with your own folder. Run it from SSH or from your control panel's Terminal — the page shows the correct folder for your own account, already filled in, so copy it from there — then reload the page. If your host has no terminal at all, their support will run that one line for you; it is a standard request.

There is no .env file to rename. VeroSMS writes its own, with an encryption key unique to your installation, the first time it runs. Nothing in the download is a password or a key.

Part 2 — step 4

Run the installer

As soon as step 3 finishes, press Continue to the installer and the wizard opens. If you have closed the tab since, just open your domain again — VeroSMS notices it has not been installed yet and sends you to the wizard on its own. If it does not, go straight to the address below.

Open in your browser
https://yourdomain.com/install
1

Welcome — /install

Says what the wizard is about to do. Click through.

2

Server requirements — /install/requirements

Every PHP version, extension and folder permission is checked and shown with a tick or a cross. You can only continue when everything passes.

If something fails, fix it and reload this page — you do not have to start the wizard again. Permission failures are the most common; see Troubleshooting.

3

Database details — /install/database

Enter the four things you wrote down in step 2. The installer tests the connection before writing anything, so a typo here costs you nothing but a retry.

4

Creating the tables — /install/database/migrate

This screen builds the database. On a shared host it takes anywhere from a few seconds to a minute. Do not close the tab or press Back while it runs.

5

Administrator account — /install/account

This is your own login for the panel. Use a real email address you can receive mail at: password resets go there.

6

Finished — /install/finish

Done. The installer locks itself so it cannot be run a second time, which also means nobody can reach that URL later and reinstall over your data.

You can sign in now at https://yourdomain.com/admin/login. Read First login before you do — on a seeded install there is a shipped password you must change.

Three things still stand between you and a delivered message: the scheduler, the Firebase service account key, and a paired phone. The next four sections are not optional. Skip any of them and the panel accepts messages and never sends one, without raising a single error.

The VeroSMS setup wizard welcome screen
Step 4 — the wizard opens on its own
The requirements screen with every row green
Step 4 — the server check
The database details form, asking for host, port, name, user and password
Step 4 — the database details you wrote down in step 2
The build-the-tables confirmation screen
Step 4 — building the tables
The administrator account form, asking for a site name, your name, email and password
Step 4 — your own administrator account. This password is the one you will sign in with
The finished screen with two follow-up tasks and a sign-in button
Step 4 — finished, with the two things worth doing next
Part 2 — step 5

Set up the scheduler

Background work runs on a timer: releasing scheduled campaigns when their time comes, retrying messages a phone never collected, marking phones offline when they stop reporting in, and clearing out expired pairing codes. All of it runs from one cron entry.

1

Open the cron jobs page in your panel

In hPanel: Advanced › Cron Jobs. In cPanel: Advanced › Cron Jobs.

Set it to run every minute. Most panels have a dropdown of common intervals — pick the once-a-minute one and it fills the five time boxes for you. If yours only shows the boxes, type * in all five.

2

Paste the command

Into the Command box, replacing the path with the folder your installation is actually in:

Cron command
cd <your-installation-path> && php artisan schedule:run >> /dev/null 2>&1

Replace <your-installation-path> with your own folder, angle brackets and all — the line will not work as written. It is the folder you uploaded into in step 1, and your File Manager shows it at the top of the window while you are inside that folder. On hPanel it usually looks like /home/youraccount/domains/yourdomain.com/public_html; on cPanel like /home/youraccount/public_html.

If your panel asks for the whole line including the timing, use this instead:

Full cron line
* * * * * cd <your-installation-path> && php artisan schedule:run >> /dev/null 2>&1

hPanel puts the php part in for you, and that catches people out. Hostinger's cron page offers PHP or Custom. If you pick PHP, the greyed box on the left already reads /usr/bin/php /home/youraccount/ and whatever you type is appended to it. So do not type the full command there. Type only the path to artisan, relative to your home folder, followed by the task:

hPanel, PHP mode — type only this
<your-path-from-home>/artisan schedule:run

<your-path-from-home> is your installation folder written relative to your home folder, so for the example above it is domains/yourdomain.com/public_html. No cd, no second php, no &&, no >> /dev/null — the panel assembles the rest.

Typing the full cd … && php artisan … line into PHP mode produces /usr/bin/php /home/youraccount/<your folder> && php artisan schedule:run, which asks PHP to run a directory. That fails instantly, and because of the && the part that matters never runs at all. The cron entry looks perfectly fine in the list, and nothing is ever sent.

If you would rather paste the whole line, choose Custom instead of PHP — then the command box is the whole command and the line above this note is the one to use.

3

Save it and check the panel

Save the entry. Then, in the VeroSMS panel:

Setup › Settings › Scheduler

That screen shows when the scheduler last ran. Within a minute or two it should show a recent time. If it still says it has never run after five minutes, your cron entry is not firing.

The exact command for your server is shown on the Scheduler screen, with your real path already filled in. Copy it from there rather than editing the line above by hand.

Some hosts use a different PHP for cron than for the web. If the schedule never runs, replace php in the command with the full path to the binary — commonly /usr/local/bin/php or /opt/alt/php83/usr/bin/php. Your host's support can tell you which in one message.

Scheduled sends depend on this entirely. A campaign set for 9am is released by the scheduler at 9am. With no cron it waits forever, still marked scheduled, and nothing tells you why.

The five cron timing boxes in the hosting panel, each set to every
The five time boxes, each set to every — that is what * * * * * looks like in a panel that uses dropdowns. Copy the command itself from the box above this figure, not from a picture
The Scheduler screen in the VeroSMS panel showing when it last ran
And how the panel confirms it: Setup › Settings › Scheduler
Part 2 — step 6

Upload the service account key

This is the most important step in Part 2. The server needs its own credential to ask Firebase to wake your phones. It is a different file from the one you put in the app, it is downloaded from a different place, and the two are not interchangeable.

google-services.jsonThe service account key
Belongs toThe Android appYour server
Where it goesapp/google-services.json in Android StudioUploaded in the panel
Downloaded fromProject settings › Your appsProject settings › Service accounts
WhenPart 1, step 3Right now

Both files must come from the same Firebase project. One project on the app side and a different one on the server side is a setup that looks entirely correct, passes every visual check, and delivers nothing at all. If you only made one Firebase project in Part 1, you are already fine — just do not create a second one now.

1

Open Project settings in Firebase

Back in the Firebase console, in the same project as Part 1, click the gear icon next to Project Overview at the top left, and choose Project settings.

2

Go to the Service accounts tab

Along the top of the settings page, after General, Cloud Messaging and Integrations.

3

Click Generate new private key

A dialog warns you to keep the key confidential. Click Generate key. A .json file downloads — its name is long and full of dashes. That is the one.

4

Upload it in the panel

Setup › System › Firebase push

Choose the file and save. VeroSMS reads the project id and the service account address out of it and shows both back to you, so you can confirm at a glance that it is the right project's key. The badge at the top of the screen changes from Not configured to Configured.

5

Press the test button. Do not skip this.

The screen has a test that asks Google to validate the credential, and shows Google's own answer word for word. It is the only way to find out whether this is right before a real message fails.

If it comes back SENDER_ID_MISMATCH, the key and the app were made in two different Firebase projects. Go back to Part 1, check the package name under Project settings › Your apps, and make sure you downloaded both files from that same project.

Treat this file like a password. Anyone who has it can send push notifications as your project. Do not email it, do not put it in a shared folder, and never place it anywhere under public/ where a browser could fetch it.

Replacing the key takes effect immediately. No cache to clear, no restart. Messages that were waiting go out on the next push.

Project settings, Service accounts, Generate new private key in Firebase
Firebase — Project settings › Service accounts › Generate new private key
The Firebase push screen in the VeroSMS panel, with the key uploaded and tested
And where it goes: Setup › System › Firebase push. Press Test afterwards
Part 2 — step 7

Pair a phone

Pairing is how a phone learns which installation it belongs to. You do it once per phone, from the panel.

1

Open the pairing screen

Devices › Pair a device

The screen shows a QR code and, under it, an eight-character code in plain text. Either one works — they are two ways of handing the phone the same thing.

2

Open the app on the phone

It is sitting on its pairing screen, where you left it at the end of Part 1.

3

Scan the QR code, or type the eight characters

Scanning is quicker: point the phone's camera at your monitor. If the camera will not focus, if the phone has no camera permission, or if you are working on the phone remotely, type the eight-character code into the app instead. Both routes do exactly the same thing.

4

Watch it appear in the panel

Within a second or two the phone shows up in the Devices list, with its SIM slots listed against it. That is pairing done.

A pairing code is single-use and expires after ten minutes. If it has been sitting on screen while you went to find the phone, reload the page for a fresh one. A used or expired code fails with a message saying so — it is not a fault, just get another.

If the app says it cannot reach the server, the phone cannot open your site at the address inside the code. Check that the site loads in the phone's own browser, over https://. A phone on mobile data cannot reach an address that only exists on your office network.

The pairing screen in the panel showing a QR code and an eight-character code
Step 7 — the pairing screen. Scan the QR, or type the short code
The pairing screen inside the VeroSMS Android app
And the same moment on the phone
The devices list showing two paired phones with battery and SIM labels
Once paired, the phone appears here with its SIM slots, battery and last check-in

Pair as many phones as you need — and put them all to work on one campaign. Repeat this step for each handset; every paired phone appears in the Devices list with its own SIM slots. A single phone sends in series through its carrier, so a very large campaign on one handset takes time.

To go faster, spread the work across phones. Every send — from the panel or from POST /api/v1/messages — goes out through one device you choose (the device_id). So a large list is split into parts and each part is sent to a different device: the phones then send in parallel, and your throughput is roughly the sum of what each handset’s carrier allows. A dual-SIM phone adds a second lane the same way — pick sim1 or sim2 per send. There is no central auto-split; you decide how the list is divided, which also lets you keep one number’s traffic on one SIM when a campaign needs it.

Part 2 — step 8

Send a test message

One message to your own phone proves the entire chain at once — panel, queue, Firebase, phone, SIM, and the report coming back.

1

Open the send screen

Messaging › Send
2

Pick the phone and the SIM slot

On a dual-SIM handset both slots are listed separately. Choose the one with credit on it.

3

Put your own number in, in full international form

Include the country code, like +8801711000021. A number typed in local form, like 01711000021, is refused until you have set a default dial code — the screen tells you so in as many words. See General settings for how to set one.

4

Type anything and send

The message should reach you within a few seconds. In the panel it moves from queued to sent, and then to delivered when the carrier confirms.

Now reply to it from your phone. The reply should appear in Messaging › Inbox within seconds. That proves the receiving half as well, and it is the half people forget to test until a real reply goes missing.

If the message stays at queued, Firebase is not reaching the phone. Go back to step 6 and press the test button, then check the phone is online on the Devices screen. That one pair of checks explains almost every case.

The send screen with a recipient, a SIM slot and a message body
Step 8 — the send screen. Pick the phone, pick the SIM, type a message
The message list showing delivery status per recipient
And what happened to it, per recipient
After installing

First login

There is one panel and one login screen:

Your panel
https://yourdomain.com/admin/login

Sign in with the address and password you typed at step 4 of the installer. There is no shipped password to look up and none to change — the account you chose is the only administrator on the installation.

Nothing in this download is a password. Earlier versions shipped a known login, admin@gmail.com with a password printed in this guide, which meant every installation whose owner never got round to changing it was open to anybody who owned the product. That is gone.

If the database is seeded before you reach step 4 — which happens if you run php artisan db:seed by hand, or stop the installer half way — a password is generated for your installation alone and written to storage/app/private/ADMIN-CREDENTIALS.txt. That folder is outside the web root and cannot be opened in a browser. It is also printed on the console by the seeder.

An account holding a generated password cannot use the panel until it chooses its own: signing in lands on a change-password screen and goes nowhere else. Once you have set yours, delete ADMIN-CREDENTIALS.txt.

Changing your password later

Open your own profile from the account menu at the top right of the panel. Use something long. This login can send messages that cost you money, and changing the password signs out every other browser your account is signed in on.

Add staff, if you have any

Setup › Team › Roles

Roles decide what a login may do — view messages, send them, manage contacts, pair devices, issue API keys, edit settings, and so on. Create the role first, then create the person:

Setup › Team › Staff

Give people the narrowest role that lets them do their job. Everything anyone does is recorded under Setup › Team › Activity log, which is worth knowing exists before you need it.

Two shortcuts worth learning on day one. Ctrl+K (⌘K on a Mac) jumps to the search box from anywhere in the panel, and pressing n starts a new message.

The VeroSMS admin sign-in screen
The panel sign-in, at /admin
The VeroSMS dashboard showing failures, queue, phones online and the month total
The dashboard — what is happening right now, and this month
After installing

General settings

Setup › Settings › General

Eight settings live here. Two of them change how messages behave, and the rest are about how the site looks and reads.

SettingWhat it does
Site nameUsed throughout the panel, in emails and across the public landing page.
Support emailThe address shown to anyone who needs to contact you.
Copyright textThe line in the footer of the public site.
TimezoneEvery timestamp and every scheduled send is calculated against this.
Date formatHow dates are printed on screen.
Default dial codeThe country code added to numbers typed without one. See below.
Require email verificationWhether a new login must confirm its email address before being used.
Maintenance modeTakes the public site offline while you work on it. The panel stays reachable.

Why the default dial code matters more than it looks

Every SMS needs a full international number. Your contacts almost certainly do not have one: real address books are full of numbers like 01711000021, written the way people write them locally.

The default dial code is what turns those into something sendable. Set it to your country — +880, +44, +1 — and a local number becomes a full one on the way out.

Without it, a local number simply cannot be sent. The send screen refuses it and says so, which is fine for one message you typed by hand and much less fine when you have imported four thousand contacts and every one of them is unusable. Set this before your first import.

Set the timezone before anyone schedules anything. Scheduled sends and every report are worked out against it. Changing it later does not move sends that were already scheduled.

The general settings screen with site name, logo, timezone and country code
Setup › Settings › General
After installing

Email delivery

Worth doing early. Without working email, a forgotten password locks you out of your own panel with no way back except editing the database by hand.

Setup › Settings › Email delivery

Enter your SMTP details

These come from whoever provides your email. A typical set:

FieldTypical valueNotes
Mailersmtp
Hostsmtp.yourprovider.comFrom your provider
Port587465 if using SSL
EncryptionTLSSSL for port 465
UsernameYour SMTP usernameOften the full email address
PasswordYour SMTP passwordSee the warning below
From addressnoreply@yourdomain.comMust be a domain you own
From nameYour site nameWhat recipients see

Send a test email

The screen has a test button. Use it before you move on. SMTP settings that are nearly right fail silently, and the first person to find out is usually you, locked out, at the worst possible moment.

Gmail and Outlook need an app password, not your normal one. Both refuse ordinary account passwords from outside applications. Generate an app-specific password in your account's security settings and use that.

Use a real mail service for anything that matters. Shared hosting mail servers are often on spam blocklists, which means your mail is accepted and then quietly thrown away on the way. Amazon SES, Mailgun, Postmark or Brevo cost little or nothing at low volume and make a large difference to whether your email arrives.

Review the mail templates

Setup › Settings › Mail templates

Every email the system sends is editable here — password resets, staff invitations, verification. The defaults are complete and sensible, so leave them alone at first. Worth a read when you have time, so you know what goes out with your name on it.

The email delivery settings screen with SMTP fields and a test button
Setup › Settings › Email delivery — fill it in, then press Test
After installing — optional

Landing page & SEO

Website › Landing page › All sections

VeroSMS ships with a public marketing page in front of the panel — hero, features, FAQ, contact details and more. Every section can be edited, reordered or switched off entirely.

If you are running this purely for yourself and nobody else should see a public page at all, you can switch the sections off, or put the whole site into maintenance mode from General settings.

What to change first

  • Contact — replace the shipped email address and phone number with your own
  • Hero — your own headline
  • Footer — your links and copyright line

SEO

Website › Landing page › SEO settings

Meta title and description, the image used when someone shares a link, and keywords. The title and description follow your site name automatically, so in practice this is mostly about the sharing image.

The landing page builder listing every section of the public site
Setup › Website › Sections — every block of the public site
The public VeroSMS landing page as a visitor sees it
And the result, as a visitor sees it
After installing — optional

Languages

Setup › Languages › Languages

English is installed and active. You can add more languages, and set which one the panel and the public site open in.

Setup › Languages › Translations

Every piece of text in the application can be translated here, in the browser. There is no file to edit and nothing to upload.

Right-to-left languages such as Arabic, Hebrew, Urdu and Farsi are supported — mark the language as RTL and the whole interface mirrors, panel and landing page together.

Skip this if you only need English. It affects nothing else and can be done at any time later.

The languages screen listing installed languages and translation progress
Setup › Settings › Languages
After installing

Make it yours

The app side is already done — its name, icon, opening screen and colours were set in Part 1, steps 5 and 6, before you built the APK. What is left is the panel and the public website, and neither needs a file edited.

1

Logo, favicon and site name

Setup › Settings › General

The logo appears in the sidebar, on the sign-in screen and at the top of every email the panel sends. The screen asks for 200 × 200 and takes PNG, SVG or JPEG — a square PNG with a transparent background is the safe choice, and SVG stays sharp at any size if you have one. The favicon beside it wants 32 × 32, as PNG, ICO or SVG.

Upload nothing and the panel falls back to the first letter of your site name, which is tidy but obviously not yours.

The site name on the same screen is used in page titles, in emails and anywhere the product refers to itself. Set it to your own and our name does not appear anywhere a customer can see.

The logo and favicon fields in the panel's general settings
Setup › Settings › General — your name, your logo, your favicon
2

The public website

Setup › Website › Sections

Every block of the landing page can be edited, reordered or switched off, and the Privacy Policy and Terms pages that ship with it are ready to publish under your own company name. Landing page & SEO covers it in full.

3

The language the panel speaks

Every string in the panel is translatable from the browser, including right-to-left languages, so the wording can be yours as well as the branding. See Languages.

Nothing in this product has to carry our name. Between the app steps in Part 1 and the three above, the icon, the app name, the opening screen, the colours, the panel logo, the site name, the public site and the emails are all yours. The only place our name remains is the licence and the source comments, which no customer sees.

After installing

Go-live checklist

Before you start using this for real work, walk this list once:

  • The Scheduler screen shows a recent run time — cron is firing
  • Setup › System › Firebase push reads Configured and the test button passes
  • A phone is paired and has actually delivered a real SMS to a real handset
  • A reply to that SMS arrived in Messaging › Inbox
  • That same phone still delivers after being left locked and idle for an hour — the battery-optimisation test, and the one people skip
  • Play Protect is still switched on on every phone — installing the app never needs it turned off
  • APP_DEBUG=false in .env, and SESSION_SECURE_COOKIE=true once the site is on HTTPS — see Environment settings
  • Staff accounts have only the roles they need, and API keys only the scopes they need — restricted to your own server’s IP address where possible
  • A test email arrived
  • The default dial code is set to your country
  • The timezone is set and will not need changing
  • storage/app/private/ADMIN-CREDENTIALS.txt is deleted from the server, if the seeder ever wrote one
  • The landing page contact details are yours, not the shipped ones
  • HTTPS is active and the site loads over https://
  • Your Android project folder, your keystore and your google-services.json are backed up somewhere off this computer
  • You have taken one backup from Setup › System › Backup & restore and confirmed it downloads

Test the restore, not just the backup. A backup nobody has ever restored is an assumption, not a safety net. Do it now, while there is nothing to lose.

Reference

Using the API

Everything the panel does, your own software can do over HTTP. The complete reference — every endpoint, every field, every error code — is generated from the code and lives inside the panel:

Developers › API documentation

This page is the short version: enough to make a real call in the next five minutes.

1

Create a key

Developers › API keys › New key

Tick only the scopes that caller needs. A script that reports on delivery should be given messages.read and nothing else — then a leaked key cannot send anything.

The key is shown once. It is stored hashed, so nobody, including you, can read it back out afterwards. Copy it when it appears.

2

Check the key works

One call, no side effects. Replace <your-domain> and <your-api-key>:

Request
curl https://<your-domain>/api/v1/ping \
  -H "Authorization: Bearer <your-api-key>" \
  -H "Accept: application/json"
Response — 200
{
  "ok": true,
  "site": "Your Company SMS",
  "key": { "name": "Billing system", "scopes": ["messages.send"] },
  "time": "2026-01-04T09:12:44+00:00"
}

If that returns your site name and your key's scopes, authentication is working and everything else is just a different URL.

3

Send a message

The one call most integrations ever make. device_id is the number shown on the device in Devices; sim is sim1 or sim2.

Request
curl -X POST https://<your-domain>/api/v1/messages \
  -H "Authorization: Bearer <your-api-key>" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Idempotency-Key: order-10482-confirmation" \
  -d '{
        "device_id": 1,
        "sim": "sim1",
        "to": "+8801700000000",
        "body": "Your order #10482 has shipped."
      }'
Response — 200
{
  "batch_id": 318,
  "status": "queued",
  "accepted": 1,
  "truncated": false,
  "messages": [
    {
      "id": 1042,
      "batch_id": 318,
      "device_id": 1,
      "sim": "sim1",
      "to": "+8801700000000",
      "body": "Your order #10482 has shipped.",
      "status": "queued",
      "attempts": 0,
      "scheduled_at": null,
      "sent_at": null,
      "delivered_at": null,
      "created_at": "2026-01-04T09:13:02+00:00"
    }
  ]
}

The response comes back the moment the send is accepted, not when the SMS arrives. Poll GET /api/v1/messages/1042 for the outcome, or — better — subscribe a webhook and be told.

4

Send to many, personalised

Swap to for recipients. Each entry may carry its own merge values, and body is the template they fill:

Body
{
  "device_id": 1,
  "sim": "sim1",
  "name": "January reminders",
  "body": "Hello {name}, your appointment is on {date}.",
  "recipients": [
    { "number": "+8801700000000", "merge": { "name": "Rahim", "date": "7 Jan" } },
    { "number": "+8801800000000", "merge": { "name": "Karim", "date": "8 Jan" } }
  ]
}

A recipient may also carry its own body, which overrides the template for that one number. Add "scheduled_at": "2026-01-07T09:00:00+06:00" to hold the whole batch until then.

5

When something is wrong

Every refusal is JSON in the same shape, with a code your software can branch on rather than an English sentence it has to match:

Response — 422
{
  "message": "The given data was invalid.",
  "code": "validation_failed",
  "errors": {
    "sim": ["The selected sim is invalid."]
  }
}

401 means the key is missing, wrong or revoked. 403 means the key is valid but lacks the scope for that endpoint. 429 means you are over the rate limit — the Retry-After header says how many seconds to wait, and X-RateLimit-Remaining comes back on every successful call so you can pace yourself before you get there.

The rate limit, in numbers. Each API key may make 60 requests per minute by default. The limit is counted per key, not per IP, so one key cannot spend another key's allowance. There is no separate daily cap — the per-minute ceiling is the only one. The bulk endpoint POST /api/v1/contacts/import is held tighter at 20 requests per minute, because one call can write up to a thousand rows. You can raise or lower the limit on a single key when you create it in Developers › API keys, or change the default for every key in your settings. Every successful response carries X-RateLimit-Limit and X-RateLimit-Remaining, and a 429 carries Retry-After (seconds), so a well-behaved client never has to guess.

Send the Idempotency-Key header on anything that sends. Give it a value that identifies the event in your own system — an order id, an invoice number — not a random string. A request that times out and is retried with the same key returns the original batch instead of sending the messages a second time. This is the difference between a network hiccup and a customer getting the same SMS four times.

Every call is logged. Developers › Request log shows the method, the URL, the status and how long it took, per key. When an integration behaves oddly, that page usually answers it faster than adding logging on your own side.

6

Be told when it is delivered — webhooks

Instead of polling, give VeroSMS a URL and it will POST there the moment something happens. Create one at Developers › Webhooks, choose the events you care about (message.sent, message.delivered, message.failed, message.received, batch.completed, device.online, device.offline), and copy the signing secret it shows once.

Every delivery arrives with these headers, so your receiver can tell what it is and prove it is genuine:

Request headers
Content-Type:        application/json
X-VeroSMS-Event:     message.delivered
X-VeroSMS-Timestamp: 1767517724
X-VeroSMS-Signature: sha256=9f2b7c1e…

The body is always the same shape — an event, the time it was sent, and a data object whose fields depend on the event. A message.delivered call looks like this:

Body — message.delivered
{
  "event": "message.delivered",
  "delivered_at": "2026-01-04T09:13:44+00:00",
  "data": {
    "message_id": 1042,
    "batch_id": 318,
    "to": "+8801700000000",
    "status": "delivered",
    "error_code": null,
    "device_id": 1
  }
}

message.sent and message.failed carry the same data fields, with status set to sent or failed and, on a failure, a short error_code. An inbound message.received instead carries id, device_id, sim, from, body and received_at; a batch.completed carries batch_id, name, status and a counts object of recipients, sent and failed. No webhook ever carries the text of an outbound message — only ids and statuses.

Verify the signature before you trust a call. Compute HMAC‑SHA256 of the literal string timestamp + "." + rawRequestBody using your endpoint secret, and compare it to the hex in X-VeroSMS-Signature (after the sha256=). The timestamp is signed with the body, so a captured call cannot be replayed with a fresh one. Reject anything that does not match, and ignore the redirect — VeroSMS never follows one on a webhook.

Verifying the signature in your own receiver

Three checks, in this order, before you act on anything in a delivery: the timestamp is within five minutes of your own clock, the signature matches, and only then the JSON. Always sign-check the raw request body — the exact bytes that arrived — never a copy you decoded and encoded again, or the signature will not match. Both receivers below were tested against the exact signing code VeroSMS uses; the only thing to change is the secret.

PHP — verosms-webhook.php
<?php
// verosms-webhook.php — a complete receiver. Point the webhook's URL here.

$secret = getenv('VEROSMS_WEBHOOK_SECRET');   // the whsec_… value shown when you created the webhook

$body      = file_get_contents('php://input');   // the RAW body, exactly as it arrived
$timestamp = $_SERVER['HTTP_X_VEROSMS_TIMESTAMP'] ?? '';
$signature = $_SERVER['HTTP_X_VEROSMS_SIGNATURE'] ?? '';

// 1. Refuse anything more than five minutes from your clock. This is what
//    stops a captured delivery from being replayed later.
if (! ctype_digit($timestamp) || abs(time() - (int) $timestamp) > 300) {
    http_response_code(400);
    exit('stale timestamp');
}

// 2. Recompute the signature over "timestamp.body" and compare in constant time.
$expected = 'sha256=' . hash_hmac('sha256', $timestamp . '.' . $body, $secret);

if (! hash_equals($expected, $signature)) {
    http_response_code(401);
    exit('bad signature');
}

// 3. Only now is the body trustworthy.
$payload = json_decode($body, true);

switch ($payload['event']) {
    case 'message.delivered':
        // $payload['data']['message_id'], $payload['data']['status'], …
        break;
    case 'message.failed':
        // $payload['data']['error_code'], …
        break;
}

http_response_code(200);   // any 2xx; anything else is retried
Python (Flask) — verosms_webhook.py
# verosms_webhook.py — the same receiver in Python (Flask).
import hashlib, hmac, os, time
from flask import Flask, abort, request

SECRET = os.environ["VEROSMS_WEBHOOK_SECRET"].encode()   # the whsec_… value
app = Flask(__name__)

@app.post("/verosms/webhook")
def verosms_webhook():
    body      = request.get_data()   # raw bytes, not request.json, which re-serialises
    timestamp = request.headers.get("X-VeroSMS-Timestamp", "")
    signature = request.headers.get("X-VeroSMS-Signature", "")

    # 1. The five-minute window against replays.
    if not timestamp.isdigit() or abs(time.time() - int(timestamp)) > 300:
        abort(400)

    # 2. HMAC-SHA256 over "timestamp.body", compared in constant time.
    expected = "sha256=" + hmac.new(
        SECRET, timestamp.encode() + b"." + body, hashlib.sha256
    ).hexdigest()
    if not hmac.compare_digest(expected, signature):
        abort(401)

    # 3. Trusted from here.
    event = request.get_json()
    if event["event"] == "message.delivered":
        pass   # event["data"]["message_id"], event["data"]["status"], …

    return "", 200

In a Laravel receiver, read the body with $request->getContent() and the headers with $request->header('X-VeroSMS-Signature'), and register the route in routes/api.php so CSRF protection does not refuse the POST.

Answer with any 2xx to acknowledge a delivery. Anything else — an error status, a timeout, or a redirect, which VeroSMS never follows — counts as a failed attempt.

Retry schedule

Each event is tried four times in all. Every attempt waits up to 10 seconds for your receiver to answer.

AttemptWhen
1Within about a minute of the event — at the next run of the scheduler
210 seconds after attempt 1 failed
360 seconds after attempt 2 failed
4 (last)5 minutes after attempt 3 failed

From the first attempt to the last is therefore about six to seven minutes. The delays are minimums: background work is processed by the once-a-minute scheduler, so a retry happens at the first scheduler run after its delay has passed. After the fourth failure the delivery is recorded as failed under Developers › Webhooks and in Failed jobs, where it can be retried by hand. If five events in a row fail completely, the webhook is switched off automatically and the screen says why — turn it back on once your receiver is fixed.

Telling a slow receiver from a dead one: answer quickly with a 2xx and do your own processing afterwards. A receiver that takes longer than 10 seconds is treated as failed even if it later finishes, and will be sent the same event again — so make your receiver safe to receive the same event twice (check the message_id or batch_id you have already handled). To try a receiver without waiting for real traffic, press Send test on Developers › Webhooks: it delivers a signed webhook.test event.

Reference

For developers: how it fits together

You own the source, so this is a map of where things live and where your own code belongs — written so you can judge the product before you start, not after.

The path a message takes

Nothing pushes an SMS to a phone. The server only ever says "there is work waiting", and the phone comes and gets it.

  • A send — from the panel or from POST /api/v1/messages — becomes a batch and one message row per recipient, status queued.
  • App\Jobs\NotifyDevice sends a data-only Firebase message to that handset. It carries no message text, only the wake-up.
  • The phone wakes and calls POST /api/v1/device/queue with its own credential. It receives only its own work.
  • The phone sends through the SIM and reports back to POST /api/v1/device/receipts; the row moves to sent, then delivered or failed.
  • An inbound SMS goes the same way in reverse, through POST /api/v1/device/inbox and App\Services\Messaging\InboxService.

The sending logic itself is App\Services\Messaging\SendService. Cancellation, pairing, imports, usage counting and the Firebase client are siblings of it in the same namespace. Controllers are thin on purpose: if you are changing behaviour, you are almost always in app/Services/Messaging, not in a controller.

Adding a scheduled task

All background work hangs off the single cron entry from Part 2, step 5. The schedule is declared in routes/console.php, next to the ones that ship:

routes/console.php
Schedule::command('your:command')->hourly()->withoutOverlapping();

Write the command itself in app/Console/Commands; PruneMessages is a short one to copy the shape from. Nothing else needs changing — the existing cron entry picks it up on its next run, and Setup › Settings › Scheduler will show it.

Being told when something happens

Webhooks are the supported extension point, and they are first class rather than an afterthought: HMAC-signed, retried, and logged. The events are declared as constants on App\Models\Webhook:

  • message.sent, message.delivered, message.failed
  • message.received — an inbound SMS
  • batch.completed
  • device.online, device.offline

To add one of your own, see Adding your own webhook event below — it is two short steps, with the code.

Adding your own API endpoint

Three small pieces: a scope, a route and a controller. Written this way your endpoint gets the same authentication, scope check, per-key rate limit, X-RateLimit headers, JSON error format and request log as every endpoint that ships — none of which you write yourself. The example adds GET /api/v1/reports/daily, which counts the day's messages by status.

1. The scope — app/Models/ApiKey.php
// app/Models/ApiKey.php — a scope, so the endpoint can be granted to a key on its own.

public const SCOPE_REPORTS_READ = 'reports:read';

public static function scopes(): array
{
    return [
        // … the scopes that ship stay exactly as they are …
        self::SCOPE_REPORTS_READ => 'Read the daily report',   // the label on the key form
    ];
}
2. The route — routes/api-custom.php (new file)
<?php
// routes/api-custom.php — a NEW file, so an update never overwrites your routes.

use App\Http\Controllers\Api\V1\Custom\DailyReportController;
use App\Models\ApiKey;
use Illuminate\Support\Facades\Route;

// Same prefix and names as the shipped API: this answers GET /api/v1/reports/daily.
Route::prefix('v1')->name('api.v1.')->group(function () {

    // 'apikey:<scope>' authenticates the key, answers 403 "scope_missing" to a key
    // without this scope, and applies the key's per-minute rate limit together
    // with the X-RateLimit headers. 'api.log' records the call on
    // Developers › Request log, the same as every shipped endpoint.
    Route::middleware(['api.log', 'apikey:'.ApiKey::SCOPE_REPORTS_READ])->group(function () {
        Route::get('reports/daily', DailyReportController::class)->name('reports.daily');
    });
});

Then add one line at the very end of routes/api.php so your file is loaded:

routes/api.php — last line
require __DIR__.'/api-custom.php';
3. The controller — app/Http/Controllers/Api/V1/Custom/DailyReportController.php
<?php
// app/Http/Controllers/Api/V1/Custom/DailyReportController.php

namespace App\Http\Controllers\Api\V1\Custom;

use App\Http\Controllers\Controller;
use App\Models\ApiKey;
use App\Models\Message;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;

class DailyReportController extends Controller
{
    public function __invoke(Request $request): JsonResponse
    {
        // The key that made this call. The middleware has already authenticated
        // it and checked its scope, so there is nothing left to check here.
        /** @var ApiKey $key */
        $key = $request->attributes->get('api_key');

        // Validate everything that comes from outside. A failure is answered for
        // you: 422 with {"message", "code": "validation_failed", "errors"}.
        $data = $request->validate([
            'date' => ['nullable', 'date_format:Y-m-d'],
        ]);

        $day = $data['date'] ?? now()->toDateString();

        // Anything larger than one query belongs in a class under app/Services,
        // the way the shipped endpoints hand their work to SendService.
        $counts = Message::query()
            ->whereDate('created_at', $day)
            ->selectRaw('status, count(*) as total')
            ->groupBy('status')
            ->pluck('total', 'status');

        return response()->json([
            'date'   => $day,
            'key'    => $key->name,
            'counts' => $counts,
        ]);
    }
}

Tick the new Read the daily report scope on a key under Developers › API keys, then call it:

Try it
curl https://yourdomain.com/api/v1/reports/daily?date=2026-01-31 \
  -H "Authorization: Bearer <your-api-key>" \
  -H "Accept: application/json"

After an update, check that last line of routes/api.php. An update replaces that file, so the require line is the one edit to a shipped file you may need to put back. Your own route file, your controller and anything else you created are new files and are never touched. The scope you added to ApiKey.php is the same: keep a note of it, or keep the project in git so the next update is a merge.

Adding your own webhook event

Two steps. Signing, the X-VeroSMS-* headers, queueing, the four delivery attempts, the delivery log and the auto-disable after repeated failures are already done by App\Jobs\DeliverWebhook for every event, including yours. The example adds contact.opted_out.

1. Register it — app/Models/Webhook.php
// app/Models/Webhook.php — name the event, and describe it.

public const EVENT_CONTACT_OPTED_OUT = 'contact.opted_out';

public static function events(): array
{
    return [
        // … the events that ship stay exactly as they are …
        self::EVENT_CONTACT_OPTED_OUT => 'A contact opted out of messages',
    ];
}

That one entry is the whole registration. It puts the event as a checkbox on the webhook form, and makes the API accept it when a webhook is created through POST /api/v1/webhooks.

2. Fire it — where the thing happens
// Wherever it happens in your code — after the change is saved — fire it.

use App\Models\Webhook;
use App\Support\WebhookDispatcher;

$contact->save();

WebhookDispatcher::fire(Webhook::EVENT_CONTACT_OPTED_OUT, [
    // Ids, statuses and times. A webhook goes to an address somebody typed into
    // a form, so keep message text and personal details you do not need out of it.
    'contact_id'   => $contact->id,
    'opted_out_at' => now()->toIso8601String(),
]);

Every active webhook subscribed to contact.opted_out now receives the same envelope as the shipped events — {"event": "contact.opted_out", "delivered_at": "…", "data": {"contact_id": 15, "opted_out_at": "…"}} — signed exactly as described in Using the API, so the receivers above verify it unchanged.

Where custom code goes

  • New endpoints — your own routes/api-custom.php, inside the apikey middleware with a scope from App\Models\ApiKey. The full skeleton is under Adding your own API endpoint above.
  • New admin screens — routes/admin.php plus a permission in the roles table, so the screen obeys the same role system as everything else.
  • Changing how a send behaves — App\Services\Messaging\SendService.
  • Queued work — app/Jobs. The queue is the database driver and is drained by the same cron entry, so a new job needs no extra process.
  • Views — Blade in resources/views, Tailwind compiled with npm run build:css.

Keep your changes out of the files an update replaces. An update overwrites the application files wholesale. Custom work survives best as new files — your own command, your own job, your own routes file included from routes/admin.php — rather than as edits scattered through files that ship with the product. Keeping the project in git makes the next update a merge instead of a memory test.

Reference

Updating

You update this panel from inside this panel: every release installs from the Updates screen as a single signed file. The only time you install by hand is a move from the old 2.x line, which is a fresh install alongside your existing site — covered at the end of this section.

Setup › System › Updates

Where update packages come from: only from you. This screen never downloads anything. There is no update server, no update URL and no "check for updates" call anywhere in VeroSMS — so there is no source address to configure, and nothing on your server contacts us. The only package the screen will ever open is a file you put there yourself: uploaded from your own computer on this screen, or placed in storage/app/updates/drop with your file manager.

New versions are published on your marketplace Downloads page, beside the product you bought. You download the update file there, the same way you downloaded VeroSMS, and bring it here. Before anything is written, its signature is checked against the public key in config/updates.php — the only key the screen trusts.

Updates are optional, and nothing depends on us. Your installation does not need any server, account or key of ours to keep working — not today, and not if we stop releasing updates, are unavailable, or discontinue the product. There is no update server, no licence check and no "phone home"; the panel never contacts us. If no further update is ever released, the version you have keeps running exactly as it does now.

The signing key. Update packages are signed with the author's private key, and your installation checks them against the matching public key in config/updates.php. That only decides which update files this screen will accept. If you would rather depend on no one, you can take the key over yourself: run php artisan update:keygen on your own computer, put the public key it prints into config/updates.php, and build your own signed packages with php artisan update:build — both commands ship with the product. After that, the screen accepts your packages and no longer ours.

Without the Updates screen at all, a newer version can always be installed the ordinary way: back up, copy the new version's files over your installation (leaving .env, storage/ and public/uploads/ alone), and run php artisan migrate --force.

Every outbound connection VeroSMS makes

For full transparency, this is the complete list of addresses the product itself ever connects to. There is nothing else in the code: no licence check, no usage reporting, no update check, and no address belonging to the author.

DestinationWhenWhy
oauth2.googleapis.com
fcm.googleapis.com
When a phone needs wakingFirebase Cloud Messaging, in the Firebase project you created
Your webhook URLsWhen an event you subscribed to happensOnly the addresses you add under Developers › Webhooks
Your mail serverWhen the panel sends an emailThe mail settings you enter under Email delivery
api.pwnedpasswords.comOnly if you turn on CHECK_PWNED_PASSWORDS, when an administrator password is changedChecks the password against known data breaches; only the first five characters of its SHA-1 hash are sent. Off by default
getcomposer.org, and Composer's own package sourcesOnce, during installation — and only if your host has no Composer of its ownInstalls the PHP libraries, exactly as running composer install yourself would. The Composer download is checked against its published SHA-256 checksum before it is run

Installing an update

A release gives you a single file named like verosms-update-x.y.z.zip. It is not the whole marketplace download and it is not the admin panel zip you installed from — it is a small package built for exactly this screen.

1

Upload it

On the Updates screen, choose the file and press Check this package. Nothing is written yet. The screen verifies the package and then tells you what it is: which version it installs, how many files it carries, and the release note.

If your host caps uploads below the size of the package, put it in the folder the screen names — storage/app/updates/drop — with your control panel's file manager, and it appears on the page ready to check.

2

Press Install

That is the whole job. In order, the panel: takes a snapshot of your database, copies every file it is about to replace, goes into maintenance mode, writes the new files, removes code the release deleted, runs the migrations, clears the caches, and comes back up.

If any of that fails, it puts both halves back and your site comes up on the version it was already running. You are told what went wrong and nothing is left half-applied.

What an update may and may not touch. It replaces the application's own code — app, config, routes, resources, public, database and the few files beside them. It can never write your .env, your storage/ folder or public/uploads/: those are not in a package at all, and the installer refuses one that names them. Your contacts, messages, campaigns, devices, API keys and settings are in the database and are not part of a file update.

Files you added yourself are never deleted. When a new version drops one of its own files, the update removes that file — but only files that were part of the version you had installed. A controller, route file or migration of your own was never part of a release, so no update removes it.

Every package is signed, and that is the point. An update is new code running on your server, so the question is not only "did this arrive intact" but "is this ours at all". Each package carries a manifest signed with the author's private key, and your installation holds only the matching public key — which can check a signature and can never create one. A package that was not signed with that key is refused before a byte of it is written.

What that buys you: somebody who gets hold of your administrator password still cannot put code on your server. Without the signature, an update screen is "an administrator uploads a zip and we run it", and a stolen password stops being a data problem and becomes a code-execution one.

For the same reason the screen is super-admin only. A colleague you have given system permissions can look at the system screens; they cannot install software.

If a release changes the PHP libraries, the screen says so when it finishes and shows you the one command to run — the same composer install step your very first install used. Most releases do not, and the changelog says which do.

If you are already running VeroSMS 2.6 or earlier, read this before you upload anything.

4.0.2 cannot be installed over your existing site. It is not a newer release of the same application — the backend was rebuilt from nothing. Version 2.6 is Laravel 9 on PHP 8.0 and sets its database up from a shipped .sql file. 4.0.2 is Laravel 12 on PHP 8.2+ and builds its database from migrations. The tables are different tables, not the old ones with columns added.

Extracting 4.0.2 over a 2.6 installation gives you a broken site and a database that neither version can read. Install it alongside, in a new folder and a new database, check it works, and move your traffic over when you are ready. Your 2.6 site keeps running the whole time.

Coming from version 2.6 or earlier

Allow half an hour, and do it in this order. Nothing here is risky as long as you leave the old installation alone until the new one is working.

1

Take your data out of the old site

While 2.6 is still running: export your contacts, and take a full database backup you can keep — your host's phpMyAdmin will do both. Do this first, before anything else, and keep the file somewhere other than the server.

2

Install 4.0.2 in a new folder and a NEW database

Not the 2.6 folder, and not the 2.6 database. Create an empty database for it and follow Part 2 from the beginning. A subdomain such as new.yourdomain.com is the easiest way to run both at once.

The installer writes its own .env with a fresh application key. Do not copy your 2.6 .env across. 2.6 shipped one with the product; 4.0.2 does not ship one at all, and the old key does not match the new installation.

3

Bring the contacts in

Contacts › Import

A CSV file, straight into groups, with a per-row report of anything it could not read. From Excel, use File › Save As › CSV UTF-8 first.

One thing to know: in 2.6 a contact was a number and a group, with no name field. 4.0.2 contacts have a name, can belong to several groups at once, and carry their own opt-out state. Your imported numbers arrive with the name column blank — which is no worse than before, and you can fill it in later or re-import with names from your own records.

4

Build the new app and pair every phone again

This part is not optional and it is the one people are surprised by. In 2.6 every handset authenticated with the same shared token. In 4.x each phone holds its own credential and collects only its own queue, so a 2.6 app cannot sign in at all — there is nothing to migrate, it simply has to be replaced.

Build the APK from the included 4.0.2 source (Part 1), install it over the old one on each phone, and pair from Part 2, step 7.

5

Switch over, and keep the old one for a while

Once messages are sending from the new site, point your domain at it. Leave the 2.6 folder and its database in place for a few weeks rather than deleting them the same day — they are the only copy of your message history.

What does not come across, and why. Message history, delivery reports and SMS templates stay in the 2.6 database. 2.6 stored a send as one flat row — device, sim, number, text, status, date. 4.0.2 stores a batch, a message per recipient, delivery receipts, failure reasons, campaign status and a usage counter, and there is no honest way to manufacture the missing half. Rather than import something incomplete and have your reports quietly lie to you, the old data stays where it is, readable in your backup. Contacts and groups are the part that transfers cleanly, and those are the part you actually need going forward.

Check your PHP version before you start. 2.6 ran on PHP 8.0. 4.0.2 needs 8.2 or newer. Most hosts let you switch PHP version per folder or per domain from the control panel, so the two can run side by side — but if yours is fixed on 8.0 for the whole account, sort that out with your host first, or the installer will stop at the requirements screen.

Moving between 4.0.x releases

Use the Updates screen at the top of this section: download the single update file your release gives you, upload it and press Install. The panel backs up, replaces its own files, migrates, clears its caches and comes back up by itself. Pairings survive, settings survive, and the app only needs rebuilding when the changelog says the Android project changed.

Updating the app is a separate job. Phones that are already paired keep working across a server update. When a release includes a new version of the Android project, open the new project folder in Android Studio and repeat steps 5 to 9 of Part 1 — same app name, same package name, same google-services.json. Install the new APK over the old one on each phone; because the package name is the same, Android treats it as an update and the pairing survives.

Reference

Environment settings (.env)

Every server-side setting VeroSMS reads from its environment file, in one place. The file is .env in the folder you installed into. You do not create it: on the first visit it is made from .env.example with a unique application key, and the setup wizard writes your database details and address into it. Edit it with your hosting panel's file manager.

After changing .env, delete every file inside bootstrap/cache/ except .gitignore, so the new values are read. Never change APP_KEY on a working site: it encrypts sessions and stored secrets such as your SMTP password, and a new key makes those unreadable.

Moving to a new server or a new domain

  • New domain — change APP_URL to the new address, including https:// and without a trailing slash. Then pair each phone again: a phone remembers the address it was paired with.
  • New server — copy the whole folder including .env, import your database backup, and update the DB_* values below. Keep APP_KEY exactly as it was.
  • Set up the cron entry again on the new server (Part 2, step 5), and upload the Firebase service account key again if storage/ was not copied.

In the tables, Fresh install is the value a new installation starts with; If missing is what the application falls back to when the line is absent from .env.

Application

VariableWhat it doesAccepted valuesFresh installIf missing
APP_NAMEInternal application name, used in logs and as the default mail sender name. The name visitors see comes from General settings.Any textVeroSMSLaravel
APP_ENVEnvironment mode.production, localproductionproduction
APP_KEYEncryption key. Generated once on the first visit — never change it on a working site.base64:… (generated)generated for youthe site will not start
APP_DEBUGShows full error details in the browser. Must be false on a live site.true, falsefalsefalse
APP_URLThe panel's public address. Used for links, emails, the sitemap and pairing codes.https://your-domainwritten by the setup wizardhttp://localhost
APP_LOCALEDefault language code before a visitor chooses one.a language code, e.g. enenen
APP_FALLBACK_LOCALELanguage used for any text missing from a translation.a language codeenen
APP_INSTALLEDSet by the setup wizard when it finishes. While false, every page redirects to the installer.true, falsefalse, then truefalse
DEMO_MODERead-only demonstration mode: blocks changes that would break a public demo. Leave off on your own site.true, falsefalsefalse
APP_MAINTENANCE_DRIVERHow maintenance mode (used during updates) is stored.file, cachefilefile

Database

VariableWhat it doesAccepted valuesFresh installIf missing
DB_CONNECTIONDatabase type. MariaDB also uses mysql.mysqlmysqlsqlite (not supported for a live site)
DB_HOSTDatabase server address. Almost always localhost or 127.0.0.1 on shared hosting.host name or IPfrom the setup wizard127.0.0.1
DB_PORTDatabase port.a numberfrom the setup wizard3306
DB_DATABASEDatabase name.textfrom the setup wizardlaravel
DB_USERNAMEDatabase user.textfrom the setup wizardroot
DB_PASSWORDDatabase user's password.textfrom the setup wizardempty

Sessions, cache, queue and files

VariableWhat it doesAccepted valuesFresh installIf missing
SESSION_DRIVERWhere login sessions are kept.file, databasefiledatabase
SESSION_LIFETIMEMinutes of inactivity before a login expires.a number120120
SESSION_ENCRYPTEncrypts session data at rest.true, falsetruefalse
SESSION_PATHCookie path. Change only if the panel lives in a sub-folder and shares a domain with another app.a path//
SESSION_DOMAINCookie domain. Leave as null unless you know you need it.null or a domainnullnone
SESSION_SECURE_COOKIESends the login cookie over HTTPS only. Recommended once your site is on HTTPS.true, falsenot setnot enforced
CACHE_STOREWhere cached values are kept.file, databasefiledatabase
QUEUE_CONNECTIONWhere background work waits. Keep database: the cron entry is what processes it.databasedatabasedatabase
FILESYSTEM_DISKDefault storage disk for files the application writes.locallocallocal

Logging

VariableWhat it doesAccepted valuesFresh installIf missing
LOG_CHANNELLogging channel.stackstackstack
LOG_STACKHow log files are written. daily starts a new file each day in storage/logs/.daily, singledailysingle
LOG_LEVELLeast serious message that is written.debug, info, warning, error, criticalwarningdebug
LOG_DAILY_DAYSDays of daily log files kept.a numbernot set14

Email (fallback only)

Email is normally set up on the Email delivery screen, which stores its settings in the database and takes priority. These values are used only until that screen has been saved.

VariableWhat it doesAccepted valuesFresh installIf missing
MAIL_MAILERHow mail is sent. log writes it to the log instead of sending.smtp, sendmail, logloglog
MAIL_HOST / MAIL_PORTSMTP server and port.host name / number127.0.0.1 / 2525same
MAIL_USERNAME / MAIL_PASSWORDSMTP login.textnullnone
MAIL_SCHEMEEncryption for the SMTP connection.null, smtp, smtpsnullautomatic
MAIL_FROM_ADDRESS / MAIL_FROM_NAMESender shown on outgoing email.an address / texthello@example.com / ${APP_NAME}same

Security and command-line install

VariableWhat it doesAccepted valuesFresh installIf missing
BCRYPT_ROUNDSCost of password hashing. Higher is slower and stronger.a number, 10–141212
CHECK_PWNED_PASSWORDSWhen on, a new administrator password is checked against a list of passwords from known data breaches. Needs outbound HTTPS to api.pwnedpasswords.com; only the first five characters of the password's SHA-1 hash are sent.true, falsenot setfalse
ADMIN_EMAIL / ADMIN_PASSWORDThe account created when the database is seeded from the command line. With no password set, one is generated and must be changed at first login. When you install with the setup wizard instead, the account you type there replaces this placeholder, so neither value matters.an address / textadmin@gmail.com / not setempty

Everything else in config/ — Redis, Memcached, Amazon S3 and SQS, Postmark, Resend, Slack and Papertrail settings — belongs to Laravel drivers VeroSMS does not use. Their variables are optional, have working defaults, and should stay unset unless you deliberately switch to one of those services.

Reference

Server configuration

On ordinary shared hosting (cPanel, hPanel, Plesk with Apache or LiteSpeed) there is nothing to configure: the .htaccess files in the download do it for you. This section is for a VPS or your own server, and for hosts whose PHP limits are set very low.

PHP settings

SettingRecommendedWhy
upload_max_filesize64MContact imports (up to 10 MB), database restores (up to 50 MB) and update packages are uploads
post_max_size64M or moreMust be at least upload_max_filesize, or large uploads arrive empty
memory_limit256MInstalling the libraries, large imports and exports
max_execution_time120Installing the libraries on the first visit can take a minute or two on a slow host

Most hosting panels have these under PHP configuration, PHP options or MultiPHP INI editor. The required PHP extensions are listed under What you need.

Nginx

Nginx ignores .htaccess files. On Nginx the document root must point at the public/ folder. Pointing it at the installation folder itself would make files such as .env downloadable.

/etc/nginx/sites-available/verosms
server {
    listen 80;
    server_name sms.example.com;
    root /var/www/verosms/public;
    index index.php;

    client_max_body_size 64m;

    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 $realpath_root$fastcgi_script_name;
    }

    # Never serve dotfiles, and never run anything that was uploaded.
    location ~ /\.(?!well-known) { deny all; }
    location ~* ^/uploads/.*\.(php|phtml|phar)$ { deny all; }
}

Change server_name, the root path and the PHP-FPM socket to match your server, then add HTTPS with your usual tool (for example certbot --nginx). The folder must be owned by, or writable for, the user PHP-FPM runs as — the setup wizard's requirements screen checks the folders that matter.

Apache on your own server

Enable mod_rewrite and allow .htaccess files (AllowOverride All) for the installation folder. Pointing the virtual host's DocumentRoot at public/ is tidier but not required: the root .htaccess forwards requests there and refuses .env, logs and other private files either way.

Reference

Limits and what to expect

Things that are set by phones, operators and Android rather than by VeroSMS — worth knowing before you plan a large campaign.

Message length

One SMS holds 160 characters, or 70 if the text contains any character outside the basic GSM alphabet (most accented letters, every non-Latin script, emoji). A longer text is sent as several parts — 153 or 67 characters each — that the receiving phone joins back together, and your operator charges for each part. The send screen shows the part count live as you type. The longest message VeroSMS accepts is 1,600 characters.

Sending speed

  • Each SIM sends at the pace its operator allows. Many operators cap how many messages one SIM may send per minute, hour or day, and some treat a sudden burst as spam. Your operator's terms are the real limit, not VeroSMS.
  • Android may ask for permission once you send a lot. On many phones, after an app sends a large number of messages in a short time (on stock Android, roughly 30 in 30 minutes), Android shows a dialog saying the app is sending a large number of SMS. Tap Allow, and tick the option to remember your choice where your phone offers one. Until it is answered, Android holds that message back.
  • For volume, add phones. Pair several handsets and send each part of a large list from a different one, so they send in parallel — see Pair a phone.

Delivery reports and replies

  • “Delivered” comes from the operator. Some operators and some destination countries never send delivery reports, so a message can stay at sent even though it arrived.
  • Only SMS. MMS (picture messages), RCS chat, WhatsApp and iMessage are not supported, in either direction.
  • Replies are captured when they arrive on a paired phone while the app is installed. Messages already on the phone from before are not imported.

How long history is kept

The scheduler tidies up old records automatically, so the database does not grow for ever:

RecordKept forSetting
Message history (sent messages and their status)90 daysmessage_retention_days
Activity log365 daysactivity_retention_days
API request log14 daysfixed
Webhook delivery records14 daysfixed

Contacts, groups, templates and settings are never removed automatically. To keep message history or the activity log for a different period, change the value of that setting in the settings table with phpMyAdmin (a number of days; 0 keeps everything for ever), then open Setup › Settings › General and press Save once so the panel picks up the new value. Export anything you want to keep longer with Reports › CSV export first.

Reference

Removing VeroSMS

If you ever take an installation down for good, this removes every part of it.

1

Keep what you need

Take a backup at Setup › System › Backup & restore, and export your contacts and any reports you want to keep.

2

Release the phones

In Devices, open each phone and press Revoke, then uninstall the app from each handset.

3

Remove the cron entry

Delete the scheduler line you added in Part 2, step 5 from your hosting panel's Cron Jobs page.

4

Delete the database and the files

Delete the database and its user from your hosting panel, then delete the installation folder with the file manager.

5

Tidy up Firebase, if you no longer need it

In the Firebase console, open Project settings › Service accounts and delete the key you generated, or delete the whole project if nothing else uses it.

VeroSMS keeps nothing anywhere else: there is no account with us to close and nothing on our side to remove.

Reference

Troubleshooting

The things that come up most often, and what actually causes them.

Where to look first. Most problems announce themselves in one of these places:

  • Setup › System › System info — anything wrong with the server, in red at the top.
  • Setup › Settings › Scheduler — whether the cron entry is running.
  • Setup › System › Failed jobs — background work (an email, a webhook, a phone wake-up) that failed, with its error, and a retry button.
  • Developers › Request log — every API call, its status and how long it took.
  • Setup › Team › Activity log — who changed what, and when.
  • storage/logs/ on the server — the application log, one file per day (laravel-YYYY-MM-DD.log). Include the last few lines of it when you write to support.
Messages stay "queued" and the phone never sends anything

This is the Firebase question, and it is the most common one by a wide margin. Work down the list in order and stop when something fails:

  • Is a key installed? Setup › System › Firebase push must read Configured, and the test button must pass.
  • Do the app and the key share a project? A key from one project cannot wake an app built with another project's google-services.json. The test reports this as SENDER_ID_MISMATCH.
  • Does the package name match? Compare applicationId in app/build.gradle against the package name in Firebase under Project settings › Your apps. One different character is enough to break it.
  • Does the phone have Google Play services? Firebase does not work without it, which rules out most Huawei handsets sold after 2019.
  • Can your server reach the internet? Some shared hosts block outbound HTTPS. If the Firebase test times out rather than failing, that is the cause.
  • Is the phone online? The Devices screen shows when it last reported in.
Gradle sync fails when I open the project

Read the red text in the Build panel at the bottom. The usual causes:

  • No connection to Google's servers. Gradle downloads libraries on first sync. Office and school networks often block it. Try another network.
  • It stopped half way. Click Try Again in the yellow bar, or File › Sync Project with Gradle Files. A partly downloaded cache fixes itself on the second attempt more often than you would think.
  • You accepted an upgrade prompt. If it worked before you clicked something about updating Gradle or the Android Gradle Plugin, undo it with Ctrl+Z, or extract a fresh copy of the project from your download and start again from step 4.
  • Spaces or accents in the folder path. Move the project to a short, plain path and open it again.
The build fails and mentions google-services.json

The message usually names both package names it compared. It means the package name inside your google-services.json is not the applicationId in app/build.gradle.

Fix the applicationId to match the file, not the other way round — a package name registered in Firebase cannot be edited afterwards. If you genuinely typed the wrong thing into Firebase, add a second Android app to the same Firebase project with the right package name, download the new google-services.json, and use that.

Also check the file is actually at app/google-services.json and is not called google-services (1).json.

The phone refuses to install the APK

Almost always Play Protect. Google treats the SMS permission as highly sensitive and warns about apps that ask for it when they come from outside the Play Store. Tap More details › Install anyway; if your phone offers no such option, install from Android Studio over USB. Both are in Part 1, step 10. Do not switch Play Protect off.

If the message is about unknown sources instead, grant Allow from this source to the app you are opening the file with.

If it says App not installed and you already have an older build on the phone, uninstall the old one first. Two builds with the same package name but different signing keys cannot replace each other.

Messages arrive in bursts, hours late

Battery optimisation. Android is putting the app to sleep and letting it run only when the phone is next unlocked or charging.

Set the app to Unrestricted in Android's battery settings. On Xiaomi, Oppo, Vivo, Realme and Huawei handsets there is a second, manufacturer-specific setting — Autostart, App launch or Protected apps — that has to be turned on as well. It is not in the same place and it overrides Android's own.

Leaving the phone on a charger helps too, because Android relaxes its restrictions while charging.

The QR code will not scan, or pairing fails

A pairing code is single-use and expires after ten minutes. If it has been on screen a while, reload the page for a fresh one, or use the eight-character code underneath instead of the camera.

If it scans and then fails, the phone cannot reach your server at the address in the code. Open your site in the phone's own browser to check. On a test installation on your own computer, a phone cannot resolve a name only that computer knows — use the machine's network IP address, with both devices on the same network.

The app sends but every message fails

Check the failure reason shown against the message — the app reports Android's own error, not a generic one.

  • Permission denied — the SMS permission was refused when the app first ran. Grant it in Android's app settings; it will not ask again on its own.
  • No service / radio off — no signal, or flight mode.
  • Failures on one SIM only — that SIM has no credit, or the carrier has barred it for bulk sending.

Send one SMS by hand from the phone's own messaging app. If that fails too, the problem is the SIM or the carrier, not VeroSMS.

The send screen refuses my recipient's number

The number has no country code and no default dial code is set. Either type the number in full international form, like +8801711000021, or set Default dial code under Setup › Settings › General so local numbers are completed for you.

The installer says a folder is not writable

Set the folder to 755 in cPanel File Manager with Recurse into subdirectories ticked. If it still fails, try 775. The three that matter are storage/, bootstrap/cache/ and public/uploads/.

Some hosts run PHP as a different user than the one owning your files, and no permission setting fixes that from your side. Your host's support can correct the ownership in seconds.

"500 Server Error" straight after installing

Nearly always one of three things:

  • Wrong document root. The domain must point at public/, not the folder above it.
  • storage/ is not writable. Laravel cannot write its own cache and fails before it can tell you why.
  • PHP version too low. Check the version for this domain, not the server default — cPanel sets it per domain.

The real error is in storage/logs/laravel.log. The last entry names the actual problem.

Emails are not being delivered

Use the test button on Setup › Settings › Email delivery first — it reports the specific failure.

  • Authentication failed — Gmail and Outlook need an app password, not your account password.
  • Connection timed out — your host blocks outbound SMTP. Ask them to open port 587, or use a provider with an API.
  • Sends but never arrives — check spam, then your SPF and DKIM records. Shared hosting mail is frequently blocklisted.
The Scheduler screen says it has never run

Your cron entry is not firing. Check the path in the command against the real path of your installation, which cPanel File Manager shows at the top of the window.

If the path is right, replace the bare php in the command with the full path to the PHP binary — often /usr/local/bin/php or /opt/alt/php83/usr/bin/php. Many hosts use a different PHP for cron than for the web.

An API call is refused with 403

Read the code in the response.

  • scope_missing — the key was created without the scope this call needs. Keys do not gain scopes later; create a new one with the right scopes ticked.
  • ip_not_allowed — the key has an IP allowlist and the call came from somewhere else.

Remember that an API key is shown once, at the moment you create it, and never again. If you did not copy it, create another and delete the old one. Developers › Documentation in the panel carries the full API reference, generated from the code, with your real values in the examples.

I forgot my panel password

Use Forgot password on the login page — which needs working email, and is why Email delivery is worth setting up early.

If email is not working yet, reset the password directly in the database with phpMyAdmin. The password column stores a bcrypt hash, so paste a hash rather than plain text; any bcrypt generator produces one.

The page looks unstyled or broken

Usually a stale cache after moving domains or changing the address. Clear the caches with php artisan optimize:clear.

If it only happens on some pages, check that APP_URL in .env matches the address you are actually visiting, including https://.

Can I move the installation to another domain?

Yes. Copy the files and the database, update APP_URL and the database details in .env, then clear the caches.

Paired phones hold the old address, so pair them again from the new one. Webhook URLs you have given to other systems point at the old domain until you change them there too.

How do I take a backup?

The panel has backup and restore under Setup › System › Backup & restore. You can also do it by hand: export the database from phpMyAdmin and download public/uploads/. Both parts are needed.

Back up your Android project folder and your signing keystore as well. They are not on the server and nothing else has a copy.

Reference

Changelog

Version 4.0.2

The 4.x release of VeroSMS. The backend, the REST API, the admin panel and the Android application were rebuilt from the ground up, and this is the version of that rebuild that shipped.

What the product is

  • Self-hosted SMS gateway — send through your own Android phones and your own SIM cards, with no per-message fee to anyone
  • Laravel 12 backend on PHP 8.2+, and a new admin panel with dark mode
  • Android app shipped as a complete Android Studio project, built on SDK 37 with a minimum of Android 7.0 — your name, your icon, your package name, your Firebase project
  • Pairing by QR code or by an eight-character typed code, for handsets whose camera will not focus
  • Dual-SIM support, delivery reports, and offline queueing — a phone that is out of coverage keeps its work and sends when it returns
  • Push-based delivery: phones are woken the moment there is work, rather than polling on a timer
  • Per-device credentials and per-device queues, so one handset can never read another's work
  • Single, bulk and personalised sending with merge fields, and scheduling
  • Campaigns with per-recipient delivery status and failure reasons
  • Two-way threaded Inbox: replies are captured from the SIM that received them and can be answered from the panel
  • Contacts, groups, bulk import and export, and opt-out tracking that survives a future import
  • Versioned REST API at /api/v1 with scoped keys, idempotent sending, a consistent error format, signed webhooks with automatic retries, and a request log
  • A complete API reference inside the panel, generated from the code
  • Reports with CSV export
  • Roles and permissions with 19 granular permissions, staff logins and an activity log
  • Multi-language support with a browser-based translation editor, including right-to-left languages
  • Landing page builder with SEO settings, and ready-to-publish Privacy Policy and Terms pages
  • Backup and restore, system information, failed-job management and resettable sample data

Update the panel from inside the panel

  • New: update the panel from inside the panel. Setup › System › Updates installs a signed update package — upload it, read what it is, press install. No FTP and nothing to overwrite by hand. See Updating.
  • Every package is signed with the author's private key and verified before a file is written. A package that is not ours is refused, so an administrator password on its own cannot put code on your server.
  • A database snapshot and a copy of every file about to change are taken first. If any step fails, everything is put back and the site comes up on the version it was already running.
  • Your .env, your uploads and your message history are never part of a package and are never overwritten.
  • Update history is kept on the screen, including rollbacks, with the log that produced them.
  • Updates are super-admin only.
  • Two author-side commands ship with the source: update:keygen and update:build, so anyone who forks this product can publish their own signed updates.

Security and correctness work in this release

  • Nothing in the download is a credential. The package contains no .env file, no application key and no administrator password; the application writes its own .env, with an encryption key unique to your installation, the first time you open the site. If a database is seeded before the installer's account step, a password is generated for that installation alone, written to storage/app/private/ADMIN-CREDENTIALS.txt (outside the web root) and printed on the console.
  • An account holding a generated password must change it before the panel opens. Signing in lands on a change-password screen and goes nowhere else. Accounts created by a person — yours at installer step 4, and everyone you add afterwards — are unaffected.
  • The expiry sweep measures how long a message has been waiting for a phone, not how long ago the send was accepted, so a campaign scheduled further ahead than the expiry window is delivered on the day it was booked for.
  • The Custom HTML landing section is sanitised when it is saved. Scripts, forms, event handlers, javascript: links and non-https embeds never reach the database. Layout markup, inline styles and https video and map embeds are unaffected, and the section remains restricted to super admins — two independent controls rather than one.
  • Webhook destinations are resolved and refused if they point at a private, loopback, link-local or reserved address, on the API exactly as in the panel — and re-checked immediately before every delivery, so a hostname that changes where it points after being saved cannot be used to reach inside your network. Redirects are not followed.
  • Collecting the device queue is a POST rather than a GET. It hands messages to a phone and marks them dispatched, which is a change of state and must not be repeatable by a proxy, a prefetch or a retrying HTTP client.
  • A webhook is disabled after five separate events fail, not after five retries of one event, so a short outage no longer switches a working endpoint off.
  • Building the database during installation is a form submission rather than a link, so it cannot be triggered by anything that follows links on its own.
  • Shipped log settings suit a server: daily rotation at warning level, rather than one debug file that nothing rotates and nothing prunes.
  • Concurrency: cancelling a send while a phone is collecting it, receipts arriving across a month boundary, and the same pairing code being used by two handsets are each resolved under a lock rather than by timing.
  • Keyboard and screen-reader work across the panel: the confirmation dialog traps and restores focus, toasts announce themselves, every dialog carries a name, and the public landing page renders correctly with JavaScript disabled.
  • The Android app requests no permission it does not use. READ_PHONE_NUMBERS was removed together with the code that used it.
Reference

How this product was built

AI tools were used in building VeroSMS — in writing and reviewing its code, in writing this documentation and the user manual, and in parts of its interface artwork. We are stating that plainly because the marketplace asks authors to, and because you are entitled to know what you are buying.

Here is what that does and does not mean.

What was AI-assisted

  • Drafting and reviewing code across the Laravel backend and the Android app.
  • Security review — a second pair of eyes over authentication, permissions, the API surface and the places user input reaches the database.
  • This documentation, the user manual and the in-panel API reference.
  • Some interface artwork and icons.

What a person did

  • Every decision. What the product does, how a send works, what the database holds, how pairing is secured, what belongs in the panel and what does not — all specified by the author before a line was written.
  • Review of everything shipped. Nothing reaches a release because it looked plausible. Code is read before it is kept.
  • Testing on real hardware. Before each release the whole chain is installed from the downloadable package onto real shared hosting, paired with real Android handsets and real SIM cards, and messages are sent and received. An SMS gateway cannot be proved any other way.
  • Support. Your ticket is answered by the author, not by a bot.

Why we are comfortable saying so. How a tool was held matters less than whether the result works, is readable, and is safe. The package ships complete, commented source for both halves of the product — you can read every line before you deploy it, which is more than can be said for most of what any of us run. The product is also covered by an automated test suite that runs before every release, and the installation is proved end to end on a real server rather than assumed.

If you have a question about any part of the implementation, ask — the author knows the codebase and will answer it properly.

Reference

Credits and licences

VeroSMS is built on open-source software. Everything below is used under its own licence, and every licence is permissive — no GPL or other copyleft code is included. Icons, illustrations and interface artwork were made for this product.

Shipped with the admin panel

ComponentUsed forLicence
JoditThe rich-text editor for mail templatesMIT
qrcode-generatorThe pairing QR codeMIT
Alpine.jsInterface behaviourMIT
SortableJSDrag-and-drop orderingMIT
Inter (typeface)The interface fontSIL Open Font License 1.1

Their licence files are in public/libs/, public/js/ and public/fonts/, listed in public/libs/NOTICE.md.

Installed by Composer on your server

The Laravel framework (MIT), Laravel Sanctum (MIT), Laravel Tinker (MIT), Intervention Image (MIT) and the packages they depend on. They are not part of the download; Composer installs them during installation, each with its own licence file inside vendor/.

Used by the Android app

AndroidX libraries and Material Components for Android (Apache 2.0), Firebase Cloud Messaging SDK (Apache 2.0), OkHttp (Apache 2.0), ZXing and ZXing Android Embedded (Apache 2.0). Gradle downloads them when the project is built.

Reference

Support

If this guide has not solved your problem, get in touch. Support is available to verified buyers.

Have your Envato purchase code ready. Support is provided to verified buyers, and we may ask for it before we can help.

It is on your CodeCanyon Downloads page — click the download button beside this item and choose Licence certificate & purchase code.

What to include

Support is far faster when the first message contains enough to work with:

  • Your VeroSMS version
  • PHP and MySQL versions
  • Your hosting type — shared, VPS, cPanel, Plesk
  • Which step of this guide you are on
  • The phone model and Android version, if the problem involves sending
  • What the Firebase test button says, word for word
  • What you did and what happened instead
  • The last entries from storage/logs/laravel.log
  • A screenshot of the error, if there is one on screen
  • Your Envato purchase code

Support covers the product — bugs, installation problems and questions about how features work. It does not cover server administration or customisation, though we will point you in the right direction where we can.

Thank you for choosing VeroSMS. If it has been useful, a rating on your CodeCanyon downloads page genuinely helps.