Agorapulse

Before writing any code, confirm that your Agorapulse account tier includes API access. Log into Agorapulse and look for a developer or API section in account settings. If you do not see one, contact your Agorapulse account manager directly and ask whether your plan includes API access. Lower-tier plans (Free, Pro) typically do not have API access — you will receive 401 or 403 errors on correctly implemented code simply because the account is not authorized for API calls. Confirming this upfront saves significant debugging time. Once API access is confirmed, ask Agorapulse for your OAuth client credentials — a client ID and a client secret. These credentials identify your application to Agorapulse's OAuth server. The client ID is semi-public (it identifies the app but does not grant access on its own), but the client secret is sensitive and must be stored exclusively on the server side. Store the client secret in Firebase Functions environment config (using `firebase functions:secrets:set AGORAPULSE_CLIENT_SECRET`) or Supabase Edge Function secrets (`supabase secrets set AGORAPULSE_CLIENT_SECRET=...`). Do not place it in FlutterFlow App Values, Custom Actions, or API Call headers. Verify the base URL and token endpoint by checking the current Agorapulse API documentation — use `https://app.agorapulse.com/api` as the base and `https://app.agorapulse.com/api/oauth/token` for token exchange.

Deploy a server-side function that handles the OAuth token exchange and serves as the intermediary for all Agorapulse API calls. The function reads the client ID and secret from environment variables, exchanges them for a Bearer token, caches the token (Bearer tokens typically expire — check the Agorapulse documentation for the expiry time and refresh logic), and forwards data requests to the Agorapulse API. For a Firebase Cloud Function, create a function named `agorapulseProxy`. On cold start (or when the cached token is close to expiry), the function POSTs to `https://app.agorapulse.com/api/oauth/token` with `grant_type=client_credentials`, the client ID, and the client secret. The response includes an `access_token` which the proxy caches in memory (or in Firestore for multi-instance deployments). All subsequent requests to Agorapulse include `Authorization: Bearer {access_token}`. For each downstream route the FlutterFlow app needs — inbox items, publishing queue, analytics — the proxy adds the Authorization header and forwards the request to `app.agorapulse.com/api`. It returns the response JSON (or a shaped subset) to FlutterFlow. Adding a 3-to-5-minute response cache in the proxy (using an in-memory Map or a Firestore TTL document) prevents the app from hitting plan rate limits when users navigate between screens.

1// Firebase Cloud Function — agorapulseProxy (index.js)
2const functions = require('firebase-functions');
3const fetch = require('node-fetch');
4
5const CLIENT_ID = process.env.AGORAPULSE_CLIENT_ID;
6const CLIENT_SECRET = process.env.AGORAPULSE_CLIENT_SECRET;
7const BASE = 'https://app.agorapulse.com/api';
8
9let cachedToken = null;
10let tokenExpiry = 0;
11
12async function getToken() {
13  if (cachedToken && Date.now() < tokenExpiry) return cachedToken;
14  const r = await fetch(`${BASE}/oauth/token`, {
15    method: 'POST',
16    headers: { 'Content-Type': 'application/json' },
17    body: JSON.stringify({
18      grant_type: 'client_credentials',
19      client_id: CLIENT_ID,
20      client_secret: CLIENT_SECRET
21    })
22  });
23  const data = await r.json();
24  cachedToken = data.access_token;
25  // Refresh 60s before expiry (default assume 3600s if not specified)
26  tokenExpiry = Date.now() + ((data.expires_in || 3600) - 60) * 1000;
27  return cachedToken;
28}
29
30exports.agorapulseProxy = functions.https.onRequest(async (req, res) => {
31  res.set('Access-Control-Allow-Origin', '*');
32  if (req.method === 'OPTIONS') { res.status(204).send(''); return; }
33
34  try {
35    const token = await getToken();
36    const path = req.query.path || '/inbox_items';
37    const qs = new URLSearchParams(req.query);
38    qs.delete('path');
39
40    const url = `${BASE}${path}${qs.toString() ? '?' + qs.toString() : ''}`;
41    const r = await fetch(url, {
42      method: req.method,
43      headers: {
44        'Authorization': `Bearer ${token}`,
45        'Content-Type': 'application/json'
46      },
47      body: req.method !== 'GET' ? JSON.stringify(req.body) : undefined
48    });
49    const data = await r.json();
50    res.status(r.status).json(data);
51  } catch (e) {
52    res.status(500).json({ error: e.message });
53  }
54});

In FlutterFlow, open the left navigation panel and click 'API Calls'. Click '+ Add' → 'Create API Group'. Name it 'Agorapulse Proxy' and set the base URL to your Firebase Cloud Function URL (e.g. `https://us-central1-yourproject.cloudfunctions.net/agorapulseProxy`). Do not add Authorization headers here — authentication is handled entirely by the proxy. Add the first API Call: click '+ Add API Call' inside the group. Name it 'Get Inbox Items'. Set the method to GET and the endpoint to `/?path=/inbox_items`. Click the Variables tab and add an optional variable `limit` (Integer, default 20) and `status` (String, default 'pending'). Update the endpoint to `/?path=/inbox_items&limit={{limit}}&status={{status}}`. Click 'Response & Test', press 'Test API Call', and paste a sample Agorapulse inbox response. Click 'Generate from Response' to auto-create JSON paths. Map key fields: `$[*].id`, `$[*].text` (message text), `$[*].author.name`, `$[*].profile.name` (which social channel), `$[*].created_at`, `$[*].type` (comment, mention, DM). Create a Data Type named 'InboxItem' with these fields. You will bind a ListView to a list of InboxItem objects populated by this API Call.

1{
2  "api_group": "Agorapulse Proxy",
3  "base_url": "https://us-central1-yourproject.cloudfunctions.net/agorapulseProxy",
4  "calls": [
5    {
6      "name": "Get Inbox Items",
7      "method": "GET",
8      "endpoint": "/?path=/inbox_items&limit={{limit}}&status={{status}}",
9      "variables": [
10        { "name": "limit", "type": "Integer", "default": 20 },
11        { "name": "status", "type": "String", "default": "pending" }
12      ],
13      "json_paths": {
14        "ids": "$[*].id",
15        "texts": "$[*].text",
16        "authorNames": "$[*].author.name",
17        "profileNames": "$[*].profile.name",
18        "createdAt": "$[*].created_at",
19        "types": "$[*].type"
20      }
21    },
22    {
23      "name": "Get Publishing Queue",
24      "method": "GET",
25      "endpoint": "/?path=/publishing_queue&limit={{limit}}",
26      "variables": [
27        { "name": "limit", "type": "Integer", "default": 20 }
28      ]
29    },
30    {
31      "name": "Get Analytics",
32      "method": "GET",
33      "endpoint": "/?path=/analytics&period={{period}}",
34      "variables": [
35        { "name": "period", "type": "String", "default": "last_7_days" }
36      ]
37    }
38  ]
39}

Create an 'Inbox' screen in FlutterFlow. Set 'Get Inbox Items' as the Backend Query for the page so inbox data loads automatically when the screen opens. In the Backend Query settings, set `limit` to 20 and `status` to 'pending'. Add a ListView to the screen. Inside the list item template, add a Column widget containing: a Row at the top with a Text widget for `authorName` (bold) and a Text widget for `profileName` (styled as a channel badge with a colored Container background — use conditional styling on the Container color based on `type` to differentiate Twitter/X, Facebook, Instagram); a Text widget for `text` set to max 2 lines with ellipsis overflow; a Row at the bottom with a small Text for `createdAt` formatted as a relative time. Add a 'Mark as Done' icon button in each list item's top-right corner. In its Action Flow, trigger a POST API Call to your proxy with `?path=/inbox_items/{{itemId}}/done`, where `itemId` is the current list item's `id`. On success, show a Snackbar and remove the item from the local Page State list. Enable pull-to-refresh on the ListView to reload the inbox. Store the fetched items in Page State to avoid redundant API calls when the user swipes between screens. For the publishing queue: create a separate 'Queue' screen with an identical structure but bound to 'Get Publishing Queue'.

Agorapulse rate limits are plan-dependent — Enterprise plans get higher limits, lower plans have stricter caps (verify exact numbers with Agorapulse support or in current API documentation). Without caching, a mobile app that navigates between Inbox, Queue, and Analytics tabs can trigger multiple API calls per minute per screen, quickly hitting limits and returning 429 errors. Implement two layers of caching. In the proxy (Firebase Cloud Function), store each endpoint's response in a Firestore document (or in-memory if the function stays warm) with a TTL of 3–5 minutes. If the proxy receives a request for a path it fetched less than 3 minutes ago, it returns the cached Firestore data instead of calling Agorapulse. Update the cache on pull-to-refresh (FlutterFlow can pass a `forceRefresh=true` query parameter that the proxy uses to bypass the cache). In FlutterFlow, store page-level cached data in Page State. On tab switch, check whether the data in Page State is populated — if yes, use it immediately without triggering a new Backend Query call. Trigger a fresh Backend Query only on pull-to-refresh or when Page State is empty. If you hit a 429, the proxy should return the Agorapulse error code and a `Retry-After` header value if present. In FlutterFlow, add a conditional in the API Call action handler: if the response code is 429, show a Snackbar 'Too many requests — please wait a moment' and disable the refresh button for 30 seconds using a timer. If the plan-gate or rate-limit complexity is slowing you down, RapidDev's team builds FlutterFlow integrations like this every week — free scoping call at rapidevelopers.com/contact.