Skype

This step covers the zero-backend deep-link path. If your only requirement is a 'contact us on Skype' button, this is the entire integration — you can skip all the Bot Framework steps. In FlutterFlow, click Custom Code in the left navigation panel. Click the + Add button and select Action. Name the action something descriptive like OpenSkypeChat. In the Dependencies field that appears at the top of the code editor, type url_launcher and add it — FlutterFlow will resolve the latest compatible version from pub.dev automatically. Paste the following Dart code into the editor. The action accepts a skypeUsername string argument, constructs the deep link URL, and calls launchUrl. The skype: scheme opens the installed Skype app on both iOS and Android: ```dart import 'package:url_launcher/url_launcher.dart'; Future openSkypeChat(String skypeUsername) async { final uri = Uri.parse('skype:$skypeUsername?chat'); if (await canLaunchUrl(uri)) { await launchUrl(uri); } } ``` For a voice call instead of chat, change ?chat to ?call. Click Save. In the Action Flow Editor for your button widget, click + Add Action, choose Custom Actions, and select OpenSkypeChat. Map the skypeUsername argument to a page variable, widget state, or a hard-coded Skype ID depending on your design. Note: canLaunchUrl requires that the skype URL scheme is declared in your iOS Info.plist and Android AndroidManifest under LSApplicationQueriesSchemes (iOS) and <queries> (Android). In FlutterFlow, go to Settings & Integrations → App Settings → Permissions to declare custom URL schemes if prompted.

1import 'package:url_launcher/url_launcher.dart';
2
3Future openSkypeChat(String skypeUsername) async {
4  final uri = Uri.parse('skype:$skypeUsername?chat');
5  if (await canLaunchUrl(uri)) {
6    await launchUrl(uri);
7  }
8}
9
10Future openSkypeCall(String skypeUsername) async {
11  final uri = Uri.parse('skype:$skypeUsername?call');
12  if (await canLaunchUrl(uri)) {
13    await launchUrl(uri);
14  }
15}

If your use-case requires sending automated or proactive Skype messages from your app — not just launching the Skype app — you need the Microsoft Bot Framework path. This begins in the Azure portal at portal.azure.com. In Azure, search for Azure Bot and click Create. Choose Create new Microsoft App ID, give the bot a name, select your subscription and resource group, and set the Messaging Endpoint to a placeholder for now (you will update it after deploying your Cloud Function). After the bot resource is created, go to the bot's Configuration blade and copy the Microsoft App ID. Then open App Passwords (or the linked App Registration in Azure Active Directory) and generate a new client secret — copy it immediately, Azure does not show it again. Next, in the bot's Channels blade, find Skype in the list of channels and click Add to enable it. Accept the terms and save. The bot is now registered. At this stage you have an Azure App ID and a client secret — these are the credentials that authenticate your bot to the Bot Framework Connector API. Both are confidential: the client secret belongs in your Firebase Cloud Function, never in a FlutterFlow API Call header, because FlutterFlow compiles to client-side Dart and anything in the app bundle is extractable. Note: as of 2025, Microsoft has been retiring consumer Skype. Verify that the Skype channel is still available in your Azure region and that the channel option appears in your bot's Channels blade before proceeding.

The Bot Framework Connector API requires a Bearer token obtained from Azure Active Directory. The token endpoint is https://login.microsoftonline.com/botframework.com/oauth2/v2.0/token with scope https://api.botframework.com/.default and grant_type client_credentials. Tokens expire after 3600 seconds and must be refreshed, which is why this logic belongs in a Firebase Cloud Function — not in FlutterFlow. In your Firebase project (which must be on the Blaze plan for Cloud Functions with outbound HTTP), create a Cloud Function. A minimal Node.js index.js file is shown below. The function: 1. Reads the Azure App ID and secret from Firebase environment config (never hard-coded). 2. Calls the AAD token endpoint to obtain a Bearer token (caches it in memory for up to 3500 seconds to avoid re-fetching on every call). 3. Accepts a POST request from FlutterFlow containing { serviceUrl, conversationId, text }. 4. Calls POST {serviceUrl}/v3/conversations/{conversationId}/activities on the Bot Framework Connector with the Bearer token. 5. Returns the response to FlutterFlow. Deploy the function and copy its HTTPS trigger URL — you will use this as the endpoint in the next step's FlutterFlow API Call. Set your Firebase environment config variables before deploying: firebase functions:config:set botframework.app_id="YOUR_APP_ID" botframework.app_secret="YOUR_SECRET"

1const functions = require('firebase-functions');
2const axios = require('axios');
3
4let cachedToken = null;
5let tokenExpiry = 0;
6
7async function getAADToken(appId, appSecret) {
8  if (cachedToken && Date.now() < tokenExpiry) return cachedToken;
9  const params = new URLSearchParams({
10    grant_type: 'client_credentials',
11    client_id: appId,
12    client_secret: appSecret,
13    scope: 'https://api.botframework.com/.default'
14  });
15  const res = await axios.post(
16    'https://login.microsoftonline.com/botframework.com/oauth2/v2.0/token',
17    params.toString(),
18    { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
19  );
20  cachedToken = res.data.access_token;
21  tokenExpiry = Date.now() + (res.data.expires_in - 60) * 1000;
22  return cachedToken;
23}
24
25exports.sendSkypeMessage = functions.https.onRequest(async (req, res) => {
26  const { serviceUrl, conversationId, text } = req.body;
27  const appId = functions.config().botframework.app_id;
28  const appSecret = functions.config().botframework.app_secret;
29  try {
30    const token = await getAADToken(appId, appSecret);
31    const activity = { type: 'message', from: { id: appId }, text };
32    const url = `${serviceUrl}v3/conversations/${conversationId}/activities`;
33    const result = await axios.post(url, activity, {
34      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' }
35    });
36    res.json({ ok: true, id: result.data.id });
37  } catch (err) {
38    const status = err.response ? err.response.status : 500;
39    res.status(status).json({ ok: false, error: err.message });
40  }
41});

Now that the Cloud Function is handling all the Azure credentials and Bot Framework calls, FlutterFlow only needs to call your own function endpoint — no Skype API keys ever enter the app. In FlutterFlow, click API Calls in the left navigation panel. Click + Add and choose Create API Group. Name it SkypeBot and set the Base URL to your Firebase Cloud Function's HTTPS trigger URL (e.g. https://us-central1-your-project.cloudfunctions.net). Inside the SkypeBot group, click Add API Call and name it SendMessage. Set the Method to POST and the Endpoint to /sendSkypeMessage (or whatever your function path is). Under the Headers tab, you do not need an Authorization header here — your function handles its own token; you may optionally add a shared API key header if you've added Firebase App Check or a simple secret header to your function for an extra layer of caller authentication. Under the Variables tab, add three variables: serviceUrl (String), conversationId (String), and text (String). In the Body tab, select JSON and construct the body: ```json { "serviceUrl": "<serviceUrl>", "conversationId": "<conversationId>", "text": "<text>" } ``` Replace each <variable> with the FlutterFlow variable syntax {{ serviceUrl }}, {{ conversationId }}, and {{ text }}. Click the Response & Test tab. Paste a sample success response body ({ "ok": true, "id": "abc123" }) and click Generate JSON Paths. This creates JSON Path bindings you can use to show success or error UI to the user. Save the API Call. In the Action Flow Editor on the button or trigger that should send the Skype message, click + Add Action → Backend/API Calls → SkypeBot → SendMessage, and map your page variables to the three API Call variables.

1{
2  "method": "POST",
3  "endpoint": "/sendSkypeMessage",
4  "headers": {},
5  "body": {
6    "serviceUrl": "{{ serviceUrl }}",
7    "conversationId": "{{ conversationId }}",
8    "text": "{{ text }}"
9  }
10}

Incoming Skype messages hit your Azure Bot's Messaging Endpoint — a public HTTPS URL that Azure sends a Bot Framework Activity JSON payload to. FlutterFlow has no public webhook endpoint, so you must register your Firebase Cloud Function URL as the bot's Messaging Endpoint in Azure. Go back to the Azure portal, open your bot resource, and navigate to Configuration → Messaging Endpoint. Paste your Cloud Function HTTPS trigger URL (the same one you used for outbound messages, or a separate function dedicated to receiving). Click Apply. In your Cloud Function, handle POST requests that arrive from Azure. The request body will be a Bot Framework Activity object containing fields like type (message, conversationUpdate, etc.), from.id, conversation.id, serviceUrl, and text. After verifying the request (optionally using the Bot Framework SDK for Node.js to validate the JWT in the Authorization header), write the relevant fields to Firestore so FlutterFlow can read them. In FlutterFlow, set up a Backend Query on any screen that should display incoming Skype messages — query the Firestore collection where you're writing them, with real-time updates enabled. This way, when a Skype user messages your bot, the Cloud Function writes to Firestore and the FlutterFlow app updates its UI in near-real time. This inbound path is optional if you only need outbound (proactive) messages. If RapidDev's team builds FlutterFlow integrations like this for you regularly, they can handle the Cloud Function wiring and Firestore schema — free scoping call at rapidevelopers.com/contact.