Viber

Go to partners.viber.com and sign in with your Viber account. Click 'Create Bot Account' and fill in your bot's name, icon, description, and category. Once the account is created, navigate to 'Info & API' in the left sidebar. You will see your **Auth Token** — a long alphanumeric string specific to your Public Account. Copy this token and store it somewhere safe (a password manager or a notes file — you will paste it into your Cloud Function environment, never into FlutterFlow). Also take note of the bot's **URI** (the unique identifier used in deep links). On the same page, make sure your bot's status is 'Active' — inactive bots cannot receive or send messages. If you plan to use Viber Business Messages for verified brand accounts, you'll need to apply through the partner portal separately, but for testing and most app use cases the standard Public Account/Bot tier is sufficient. At this stage you do not have a webhook URL yet — that comes from the Cloud Function you'll deploy in the next step. Do not attempt to call `/set_webhook` until you have the Cloud Function URL in hand.

Your Cloud Function serves two purposes: it registers as the Viber webhook (so Viber can deliver events to it) and it proxies send requests from your FlutterFlow app to Viber. In the Firebase Console, open your project and navigate to Functions → Get started (or the Functions dashboard if already enabled). Make sure your project is on the Blaze plan — the free Spark plan blocks outbound network calls, which are required to reach `chatapi.viber.com`. In your local Firebase project folder (or the inline editor for small functions), create the Cloud Function below. It exposes two routes: `POST /webhook` for receiving Viber events (subscribe, message, etc.) and `POST /send` for FlutterFlow to call when it wants to send a Viber message. Set the `VIBER_AUTH_TOKEN` as a Firebase environment config variable (`firebase functions:config:set viber.token="YOUR_TOKEN_HERE"`) so it is never hard-coded. After deploying the function with `firebase deploy --only functions`, copy the HTTPS trigger URL (e.g. `https://us-central1-yourproject.cloudfunctions.net/viberBot`). You'll use both the `/webhook` and `/send` sub-paths from this base URL in the following steps.

1// functions/index.js
2const functions = require('firebase-functions');
3const admin = require('firebase-admin');
4const axios = require('axios');
5
6admin.initializeApp();
7const db = admin.firestore();
8
9const VIBER_TOKEN = functions.config().viber.token;
10const VIBER_BASE = 'https://chatapi.viber.com/pa';
11const headers = { 'X-Viber-Auth-Token': VIBER_TOKEN };
12
13// Webhook: receives Viber events (subscribe, conversation_started, message)
14exports.viberWebhook = functions.https.onRequest(async (req, res) => {
15  const event = req.body;
16  const type = event.event;
17
18  if (type === 'subscribed' || type === 'conversation_started') {
19    const sender = event.sender || event.user;
20    if (sender && sender.id) {
21      await db.collection('viber_subscribers').doc(sender.id).set({
22        id: sender.id,
23        name: sender.name || '',
24        subscribedAt: admin.firestore.FieldValue.serverTimestamp()
25      }, { merge: true });
26    }
27  }
28
29  res.status(200).send('ok');
30});
31
32// Send: FlutterFlow calls this to send a Viber message
33exports.viberSend = functions.https.onRequest(async (req, res) => {
34  const { receiver, text, senderName } = req.body;
35  if (!receiver || !text) {
36    return res.status(400).json({ error: 'receiver and text required' });
37  }
38  try {
39    const payload = {
40      receiver,
41      type: 'text',
42      text,
43      sender: { name: senderName || 'YourBot' }
44    };
45    const response = await axios.post(`${VIBER_BASE}/send_message`, payload, { headers });
46    return res.status(200).json(response.data);
47  } catch (err) {
48    return res.status(500).json({ error: err.message });
49  }
50});

Viber requires you to call `POST https://chatapi.viber.com/pa/set_webhook` before it will allow your bot to send any messages. This registration tells Viber where to deliver inbound events (subscriptions, messages, delivery receipts) and validates that your server is reachable. Without this step, Viber returns a status code indicating the webhook is not configured and will refuse message sends. You only need to call `/set_webhook` once (or again if your function URL changes). The easiest way to do this is through a one-time HTTP request. Open a browser-based REST client (such as Hoppscotch at hoppscotch.io) or use the Firebase Functions logs to trigger it. Send a `POST` request to `https://chatapi.viber.com/pa/set_webhook` with the header `X-Viber-Auth-Token: YOUR_TOKEN` and the JSON body shown below, replacing the URL with your actual Cloud Function webhook URL. A successful response looks like `{"status":0,"status_message":"ok","event_types":[...]}`. If you see status 1 or 3, double-check that your auth token is correct and your function URL is publicly reachable over HTTPS. The `event_types` array tells Viber which events to forward — include `subscribed`, `conversation_started`, `message`, and `delivered` at minimum so your function can capture subscriber IDs.

1// One-time registration request (run from Hoppscotch or Postman — not from FlutterFlow)
2// POST https://chatapi.viber.com/pa/set_webhook
3// Header: X-Viber-Auth-Token: YOUR_VIBER_AUTH_TOKEN
4{
5  "url": "https://us-central1-yourproject.cloudfunctions.net/viberWebhook",
6  "event_types": [
7    "subscribed",
8    "conversation_started",
9    "message",
10    "delivered",
11    "failed",
12    "seen"
13  ],
14  "send_name": true,
15  "send_photo": false
16}

Now that your Cloud Function is live and Viber is registered, configure FlutterFlow to call the send proxy. In the FlutterFlow editor, click **API Calls** in the left navigation panel. Click **+ Add** → **Create API Group**. Name the group `ViberProxy` and set the base URL to your Cloud Function's base URL (e.g. `https://us-central1-yourproject.cloudfunctions.net`). Inside the group, click **+ Add API Call**. Name it `SendViberMessage`. Set the method to `POST` and the endpoint to `/viberSend` (or whatever your function export is named — match exactly what Firebase assigned). Switch to the **Variables** tab and add three variables: `receiver` (String), `text` (String), and `senderName` (String, with a default value matching your bot's display name). These variables become `{{ receiver }}`, `{{ text }}`, and `{{ senderName }}` in the request body. In the **Body** section, select **JSON** as the content type and write the body: `{"receiver":"{{receiver}}","text":"{{text}}","senderName":"{{senderName}}"}`. Switch to **Response & Test** and paste a sample success response from Viber (`{"status":0,"status_message":"ok"}`). Click **Generate JSON Paths** — FlutterFlow will parse the response and let you reference `$.status` and `$.status_message` in your UI to confirm success. Finally, click **Test** with a real subscriber ID from your Firestore `viber_subscribers` collection to confirm the pipeline end-to-end.

1// FlutterFlow API Call configuration (JSON representation)
2{
3  "group_name": "ViberProxy",
4  "base_url": "https://us-central1-yourproject.cloudfunctions.net",
5  "calls": [
6    {
7      "name": "SendViberMessage",
8      "method": "POST",
9      "endpoint": "/viberSend",
10      "headers": {},
11      "body_type": "JSON",
12      "body": {
13        "receiver": "{{receiver}}",
14        "text": "{{text}}",
15        "senderName": "{{senderName}}"
16      },
17      "variables": [
18        { "name": "receiver", "type": "String" },
19        { "name": "text", "type": "String" },
20        { "name": "senderName", "type": "String", "default": "YourBot" }
21      ]
22    }
23  ]
24}

With the API Call configured, build a simple send screen in your FlutterFlow app. Add a **Screen** (or use an existing one) and place a `TextField` for the message text and a `Button` labeled 'Send Viber Message'. You'll also need a way to supply the receiver ID — typically by reading it from the logged-in user's Firestore document, where you stored it when they subscribed to your bot. Select the Button, open its **Actions** panel on the right, and click **+ Add Action**. Choose **Backend/API Call** → **ViberProxy → SendViberMessage**. In the variable bindings: - `receiver`: bind to the Firestore field holding the current user's Viber subscriber ID (e.g., from a Document Variable or App State). - `text`: bind to the `TextField`'s current value. - `senderName`: leave as the default constant (your bot name). Add a second chained action: **Show Snack Bar** with a conditional message — if the API call response `$.status` equals `0`, show 'Message sent!' otherwise show 'Send failed — try again.' This gives users clear feedback without exposing internal error details. For apps that need to send to multiple subscribers (broadcast), loop through the Firestore `viber_subscribers` collection and call `SendViberMessage` for each document. Keep in mind that Viber rate limits apply — if you're sending to many subscribers at once, implement a short delay between calls or fan out from the Cloud Function itself rather than from the app.