White-label chatbot platform for agencies
A white-label SaaS your agency owns — your name, your mark, your address — and every client signed in to their own bot and no other.
White-label chatbots, in a panel with your name on it
The wizard builds an app your agency owns outright, wired to your Chatfuel account. One deploy can run your whole book of clients, or you can run the same app again and give a client an address of their own.
Your name in the tab, your mark in the top bar
The wizard asks what the app is called and takes a logo file — sixty characters, and any image a browser can draw under a megabyte. The tab title and icon are written into the page itself, because the head is parsed before a build setting can be read.
An address you pick, in one command
One command from inside the app puts it up, and the project name you type is the address it answers on. No repository, no dashboard, no button to click.
Every client bot in the same panel
The top bar moves between the workspaces your Chatfuel account owns and the bots inside them, asked live rather than baked into the build. A bot created after the app went up is there without a rebuild.
A client reaches their own bot and no other
With the accounts module in, every request is checked on your server against the bots that session may open, before it leaves for Chatfuel. A client who somehow learns another client’s bot id is still refused it.
An operator panel your clients cannot find
Bots, access and health, reached by typing /admin and never listed in the nav rail — the rail is where your clients go. It creates, renames and deletes client bots, and opens any of them in the app.
Every line of it in your repository
MIT, with the component library, the API client and the proxy copied into the app rather than installed from us. Nothing you hand a client depends on this project still existing.
Any feature, any design — it is your codebase
A screen a client asks for that exists nowhere else is a directory you add and a line in the menu table, and making the whole thing look like your studio rather than ours is an edit in your own repository. Nothing here is a plugin slot with a ceiling on it.
Deploy again as often as you like
A second run reuses the project it already linked, overwrites the variables it pushes and deletes nothing it did not put there. The values go to production alone — five of them write-only — and the preview environment is left empty.
Vercel is the default, not the requirement
A Dockerfile ships in the app, and one command runs a plain node server over the built files and the same proxy. A client’s panel can live wherever you already host things.
A push can be the release
The wizard will create the repository and push it, through the GitHub CLI or a token you paste, then connect it to the Vercel project. After that, git push is how a client’s panel changes.
From the command to the client’s first sign-in
Four things happen once, in this order. Everything after them is a bot and a person.
- 01
Run the wizard
It asks which modules the panel should carry, takes your Chatfuel token, then asks what the app is called and where its logo file is. Both are judged before anything is written, so a mistyped path is answered by the command line rather than two minutes into a scaffold.
- 02
Give it an address
The deploy command ships inside the app, so it keeps working long after the wizard is gone: it checks for the Vercel CLI, signs you in, links the project, pushes the environment to production, deploys, works out which of the deployment’s addresses is the public one, and then asks the deployment itself whether its configuration arrived. The project name you type is the address.
- 03
Add the client
In the operator panel, create the bot in the workspace whose plan pays for it and attach it to that client’s account. The record is reserved before Chatfuel is asked and dropped again if Chatfuel refuses, so a bot never exists on one side and not the other. Rename it, grant a colleague access to it, or delete it from the same table.
- 04
The client signs in
They open your address and find your name and mark above the form, then the bots they were granted and nothing else. They do not see the operator panel, another client’s bot, or the token all of it runs on.
What the client sees
Your name and your mark on every screen, your address in the bar, and the menu you chose for them — and where each of them comes from. One name and one image, asked once; the tab is the only place written into a file rather than read from a setting, because the head is parsed before any build value exists.
| Name | Where it comes from |
|---|---|
| Browser tab | The title tag in index.html, rewritten on disk while the app is being made. |
| Tab icon | The icon link in the same file, pointed at your image through the app’s base path so a sub-path mount still finds it. |
| Top bar | Your mark beside your name on every screen inside the app. Below a phone’s width the name drops and the mark carries the bar alone. |
| Sign-in screens | The same mark and name above every signed-out form. With no mark configured, a shield stands in. |
| The image itself | Copied byte for byte into the app’s public folder as logo plus its own extension. The mark the template ships is removed when yours is not an SVG. |
| The address | The Vercel project name, asked at deploy time — it becomes the host the panel answers on. |
| The menu | The modules you picked when you ran the wizard, in the app’s own five groups — AI, Live Chat, CRM, Growth and Settings. The operator panel is never among them. |
| Changing them later | The name and the logo are environment values pushed to production with the rest, so the top bar and the sign-in screens follow a change without a code edit; the tab title and icon are edited in index.html. |
What a client costs you
No fee per client and no second subscription. A client bot is created in the workspace whose plan pays for it, and what it costs you is that plan and what the bot spends from the shared balance: the AI and the conversions are the two meters, and everything else a client opens is part of the plan.
| Name | What it is | Price |
|---|---|---|
| The meters | What a client’s usage takes from the balance. | |
| AI input | What the agent reads. | $2.75 per 1M tokens |
| AI cached input | The same input when the model has seen it before. | $0.275 per 1M tokens |
| AI output | What it writes back. | $16.50 per 1M tokens |
| Conversion event reported to Meta | Each event your app reports to Meta. | $0.02 per event |
| Part of the plan | On every plan, at no charge per client. | |
| Inbox, contacts, deals, bookings, flows, publishing | Every module and every channel. | Free |
| A client’s sign-in | The accounts module: their own email and password, a workspace of their own, and the bots they were granted. | Free |
| The SDK and the app | MIT, copied into your repository as source. | Free |
| The workspace | Bought once for every client bot in it. The credits reset with the period, and every bot spends from the same balance. | |
| Business | One bot. $20 of credits a month. | $20 a month |
| Agency S | Up to 3 bots. $100 of credits a month, shared by every bot in it. | $100 a month |
| Agency M | No bot limit. $250 of credits a month. | $225 a month |
| Agency L to Agency XXL | No bot limit. $500 to $2,500 of credits a month. | $440 to $2,050 a month |
FAQs
Software sold under your name that somebody else built and runs. This is half of that: the app carries your name and mark from the install, and with the accounts module every client signs up to you and gets a workspace of their own, with as many bots as your plan allows. The other half is different — the source is MIT and copied into your repository, so what you sell is an application you own, on a Chatfuel workspace you pay for.
Your own SaaS