Sinch

Log in to your Sinch account at dashboard.sinch.com. In the left sidebar, navigate to **Settings** → **Access Keys**. Click **New Key** to create an access key pair — you'll receive a **Key ID** (which you can view later) and a **Key Secret** (shown only once — copy it immediately into a secure location like a password manager). Next, note your **Project ID** — it's visible at the top of the Customer Dashboard under your account name. You'll need this for all Conversation API calls. Navigate to **Conversation API** → **Apps** in the left sidebar and create a Conversation API app. Give it a name and enable the channels you plan to use (SMS, RCS, WhatsApp). For SMS, go to **Numbers** → **Get a Number** to provision a sender number. For WhatsApp, you'll need to go through Meta's Business Manager integration. For RCS, carrier registration is required per target market — Sinch's team can assist. Keep the Key ID, Key Secret, Project ID, and your Sinch App ID handy — all four will be used in the Cloud Function environment configuration. Never paste these into FlutterFlow.

Create a Firebase Cloud Function that handles two responsibilities: acquiring a fresh Sinch OAuth access token and forwarding your FlutterFlow app's send requests to the Sinch Conversation API. Open the Firebase Console for your project, confirm you're on the Blaze plan (free Spark blocks outbound HTTP), and navigate to Functions. In your `functions/index.js`, configure the four Sinch credentials as Firebase environment variables using the Firebase CLI: ``` firebase functions:config:set sinch.key_id="YOUR_KEY_ID" sinch.key_secret="YOUR_KEY_SECRET" sinch.project_id="YOUR_PROJECT_ID" sinch.app_id="YOUR_APP_ID" ``` Then deploy the function shown below. The function first fetches a short-lived OAuth token from Sinch's auth endpoint, then posts to the Conversation API's send endpoint using that token. Token refresh is fully automatic — no client-side timer needed. The `channel_priority_order` array in the request body is the Sinch Conversation API's key differentiator: list channels in priority order and Sinch will try each in sequence until one succeeds. An order of `["RCS","SMS"]` means every capable Android gets an RCS message; everyone else gets SMS — zero additional code required on your side. After deploying, copy the HTTPS trigger URL from the Firebase Console (Functions dashboard → your function name → Trigger URL). This is what FlutterFlow will call.

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 KEY_ID = functions.config().sinch.key_id;
10const KEY_SECRET = functions.config().sinch.key_secret;
11const PROJECT_ID = functions.config().sinch.project_id;
12const APP_ID = functions.config().sinch.app_id;
13const SINCH_AUTH_URL = 'https://auth.sinch.com/oauth2/token';
14const SINCH_SEND_URL = `https://us.conversation.api.sinch.com/v1/projects/${PROJECT_ID}/messages:send`;
15
16async function getSinchToken() {
17  const credentials = Buffer.from(`${KEY_ID}:${KEY_SECRET}`).toString('base64');
18  const response = await axios.post(SINCH_AUTH_URL,
19    'grant_type=client_credentials',
20    {
21      headers: {
22        Authorization: `Basic ${credentials}`,
23        'Content-Type': 'application/x-www-form-urlencoded'
24      }
25    }
26  );
27  return response.data.access_token;
28}
29
30exports.sinchSend = functions.https.onRequest(async (req, res) => {
31  if (req.method !== 'POST') return res.status(405).send('Method Not Allowed');
32
33  const { to, text, channelPriority } = req.body;
34  if (!to || !text) {
35    return res.status(400).json({ error: 'to and text are required' });
36  }
37
38  try {
39    const token = await getSinchToken();
40    const payload = {
41      app_id: APP_ID,
42      recipient: { identified_by: { channel_identities: [{ channel: 'SMS', identity: to }] } },
43      message: { text_message: { text } },
44      channel_priority_order: channelPriority || ['RCS', 'SMS']
45    };
46    const response = await axios.post(SINCH_SEND_URL, payload, {
47      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' }
48    });
49    // Log message_id to Firestore
50    await db.collection('sinch_messages').add({
51      to,
52      text,
53      messageId: response.data.message_id,
54      sentAt: admin.firestore.FieldValue.serverTimestamp()
55    });
56    return res.status(200).json({ message_id: response.data.message_id });
57  } catch (err) {
58    const status = err.response ? err.response.status : 500;
59    return res.status(status).json({ error: err.message });
60  }
61});

In the FlutterFlow editor, click **API Calls** in the left navigation panel. Click **+ Add** → **Create API Group**. Name it `SinchProxy` and set the Base URL to your Firebase Cloud Function URL (the base, e.g. `https://us-central1-yourproject.cloudfunctions.net`). Inside the group, click **+ Add API Call** and name it `SendMessage`. Set the method to `POST` and the endpoint to `/sinchSend`. In the **Variables** tab, add three variables: - `to` (String) — the recipient's phone number in E.164 format (e.g., `+14155551234`) - `text` (String) — the message body - `channelPriority` (String, optional) — comma-separated channels in priority order In the **Body** section, choose **JSON** and enter: ```json {"to":"{{to}}","text":"{{text}}","channelPriority":["RCS","SMS"]} ``` Switch to **Response & Test** and paste a sample response: `{"message_id":"01ABC123"}`. Click **Generate JSON Paths** — FlutterFlow will create a path `$.message_id` that you can use in action chains to confirm and log the send. Click **Test API Call**, fill in a real phone number for `to` (in E.164 format) and a test message for `text`, then click **Test**. If your Cloud Function is deployed correctly and Sinch credentials are valid, you'll see `{"message_id":"..."}` in the response — and receive the SMS on your phone within seconds. If you see a 401, the token fetch failed (check Key ID/Secret). If you see a 400, check the phone number format. Do not add any `Authorization` header in FlutterFlow's API Call — authentication is entirely handled inside the Cloud Function.

1// FlutterFlow API Call configuration
2{
3  "group_name": "SinchProxy",
4  "base_url": "https://us-central1-yourproject.cloudfunctions.net",
5  "calls": [
6    {
7      "name": "SendMessage",
8      "method": "POST",
9      "endpoint": "/sinchSend",
10      "headers": {},
11      "body_type": "JSON",
12      "body": {
13        "to": "{{to}}",
14        "text": "{{text}}",
15        "channelPriority": ["RCS", "SMS"]
16      },
17      "variables": [
18        { "name": "to", "type": "String" },
19        { "name": "text", "type": "String" }
20      ]
21    }
22  ]
23}

Sinch messaging credits are consumed on send and cannot be recovered — a misfire (typo in the number, test spam, or accidental double-tap) costs real money. Before wiring the send directly to a button, add a confirmation step. In your FlutterFlow screen, add a `TextField` for the recipient's phone number, a `TextField` for the message body, and a `Button` labeled 'Send Message'. Select the Button, open the **Actions** panel, and click **+ Add Action**. Choose **Alert Dialog** → **Confirm Dialog** with the message 'Are you sure you want to send this message? Messaging credits will be consumed.' Set the confirm label to 'Send' and the cancel label to 'Cancel'. As the 'On Confirm' chained action, add **Backend/API Call** → **SinchProxy → SendMessage**. Bind: - `to`: the phone number `TextField`'s current value (or a Firestore field for the selected recipient) - `text`: the message `TextField`'s current value As a second chained action after the API call, add **Show Snack Bar**: if `$.message_id` is non-empty, show 'Message sent!' — otherwise show 'Send failed. Check the phone number and try again.' For apps that also need to display sent message history, add a **Firestore Query** on the `sinch_messages` collection (ordered by `sentAt` descending) to a `ListView` below the form, so users can see their recent sends without leaving the app.

Sinch can push delivery receipts (delivered, failed, queued) and inbound replies back to a webhook — useful for showing delivery status in your app or handling two-way conversations. Since your FlutterFlow app can't receive HTTP requests, this webhook must be your Firebase Cloud Function. In the Sinch Customer Dashboard, navigate to **Conversation API** → **Apps** → your app → **Webhooks**. Click **Add Webhook** and enter the URL of your Cloud Function's webhook handler (you'll add a second export to `index.js` for this). Select the event triggers: `MESSAGE_DELIVERY` for delivery receipts and `INBOUND_MESSAGE` for replies. Update your Cloud Function to handle these events: on `MESSAGE_DELIVERY`, update the corresponding Firestore document's status field; on `INBOUND_MESSAGE`, write a new document to a `sinch_inbound` collection. Your FlutterFlow app can then subscribe to `sinch_inbound` with a real-time Firestore query to display replies in an inbox screen. If you'd rather skip the Cloud Function and webhook setup entirely, RapidDev's team handles FlutterFlow integrations like this every week — book a free scoping call at rapidevelopers.com/contact.

1// Add to functions/index.js — webhook handler for delivery receipts and inbound messages
2exports.sinchWebhook = functions.https.onRequest(async (req, res) => {
3  const event = req.body;
4  const type = event.type;
5
6  if (type === 'MESSAGE_DELIVERY') {
7    const { message_id, status } = event.message_delivery_report || {};
8    if (message_id) {
9      const snap = await db.collection('sinch_messages')
10        .where('messageId', '==', message_id).limit(1).get();
11      if (!snap.empty) {
12        await snap.docs[0].ref.update({ deliveryStatus: status });
13      }
14    }
15  } else if (type === 'INBOUND_MESSAGE') {
16    const msg = event.message;
17    await db.collection('sinch_inbound').add({
18      from: event.contact_id,
19      text: msg && msg.text_message ? msg.text_message.text : '',
20      receivedAt: admin.firestore.FieldValue.serverTimestamp()
21    });
22  }
23
24  res.status(200).send('ok');
25});