Later

Log into Later at `https://app.later.com` and navigate to your account settings (usually via the profile menu in the top-right). Look for an 'API', 'Developer', or 'Integrations' section. If you do not see one, your current plan may not include API access — check Later's current pricing page or contact Later support to confirm whether your plan tier includes the API. Once in the API settings, generate an access token. Later's access tokens are long-lived API credentials tied to your account — they do not expire on a short schedule the way OAuth tokens do, but they should be treated as sensitive secrets. Copy the token and store it immediately in Firebase Functions environment config or Supabase secrets. Use the Firebase CLI command `firebase functions:secrets:set LATER_ACCESS_TOKEN` or the Supabase CLI `supabase secrets set LATER_ACCESS_TOKEN=...` to store it securely. Do not paste the token into a text file, FlutterFlow setting, or anywhere in the app code. Also note your account's configured timezone in Later settings (under Account → Profile or a similar path). Later returns scheduled times in this timezone, and you will need it to display post times correctly in the FlutterFlow UI — a user in New York viewing posts scheduled in Los Angeles time will see times that appear off by hours without this adjustment. Verify the exact API base URL in current Later documentation — `https://api.later.com/v2` is the expected path, but confirm this before building.

Create a Firebase Cloud Function or Supabase Edge Function named `laterProxy` that reads the Later access token from environment variables and proxies requests to `https://api.later.com/v2`. The function accepts a `path` query parameter from FlutterFlow and optional filter parameters, constructs the full Later API URL, adds the Authorization header with the token, and returns the response. For caching: the Later media library changes infrequently (assets are uploaded by the team, not generated dynamically), so cache the `/media` response for 5 minutes. The scheduled posts queue changes more often (new posts are added, others publish and are removed), so cache it for 1–2 minutes. Use a Firestore collection or a Firebase Cloud Function in-memory Map for simple caching. A `forceRefresh=true` query parameter bypasses the cache when FlutterFlow sends a pull-to-refresh request. For a Supabase Edge Function (Deno), read the token with `Deno.env.get('LATER_ACCESS_TOKEN')` and forward requests with `Authorization: Token {{token}}` (verify the exact header format in current Later API documentation — it may be `Bearer` or a custom `Token` prefix). Deploy the function and test it by calling `https://your-function-url/?path=/posts` — it should return your scheduled posts JSON from Later.

1// Firebase Cloud Function — laterProxy (index.js)
2const functions = require('firebase-functions');
3const fetch = require('node-fetch');
4
5const LATER_TOKEN = process.env.LATER_ACCESS_TOKEN;
6const BASE = 'https://api.later.com/v2';
7
8// Simple in-memory cache (expires on cold start)
9const cache = {};
10
11exports.laterProxy = functions.https.onRequest(async (req, res) => {
12  res.set('Access-Control-Allow-Origin', '*');
13  if (req.method === 'OPTIONS') { res.status(204).send(''); return; }
14
15  const path = req.query.path || '/posts';
16  const forceRefresh = req.query.forceRefresh === 'true';
17  const qs = new URLSearchParams(req.query);
18  ['path', 'forceRefresh'].forEach(k => qs.delete(k));
19
20  const cacheKey = `${path}?${qs.toString()}`;
21  const cacheTtl = path.includes('/media') ? 5 * 60 * 1000 : 2 * 60 * 1000;
22
23  if (!forceRefresh && cache[cacheKey] && Date.now() - cache[cacheKey].ts < cacheTtl) {
24    return res.json(cache[cacheKey].data);
25  }
26
27  const url = `${BASE}${path}${qs.toString() ? '?' + qs.toString() : ''}`;
28  const r = await fetch(url, {
29    headers: {
30      'Authorization': `Token ${LATER_TOKEN}`,
31      'Content-Type': 'application/json'
32    }
33  });
34  const data = await r.json();
35  cache[cacheKey] = { data, ts: Date.now() };
36  res.status(r.status).json(data);
37});

In FlutterFlow, open the left navigation and click 'API Calls'. Click '+ Add' → 'Create API Group'. Name it 'Later Proxy' and set the base URL to your Firebase Cloud Function URL (e.g. `https://us-central1-yourproject.cloudfunctions.net/laterProxy`). No Authorization headers are needed in FlutterFlow — the proxy handles authentication. Add the first API Call named 'Get Scheduled Posts'. Method: GET. Endpoint: `/?path=/posts&limit={{limit}}&status={{status}}`. Add variables: `limit` (Integer, default 20), `status` (String, default 'scheduled'). In 'Response & Test', press 'Test API Call' and paste a sample Later posts response. Generate JSON paths for: `$.data[*].id`, `$.data[*].caption`, `$.data[*].scheduled_at`, `$.data[*].social_profile.platform`, `$.data[*].media_urls[0]` (the first thumbnail URL), `$.data[*].status`. Create a Data Type named 'LaterPost' with fields: id (String), caption (String), scheduledAt (String), platform (String), thumbnailUrl (String), status (String). Add a second API Call named 'Get Media Library'. Method: GET. Endpoint: `/?path=/media&limit={{limit}}`. Variables: `limit` (Integer, default 40). JSON paths: `$.data[*].id`, `$.data[*].media_url`, `$.data[*].thumbnail_url`, `$.data[*].type` (image/video), `$.data[*].usage_count`. Add a third API Call named 'Get Posts Force Refresh' with the same config as 'Get Scheduled Posts' but with `&forceRefresh=true` appended to the endpoint — use this for pull-to-refresh.

1{
2  "api_group": "Later Proxy",
3  "base_url": "https://us-central1-yourproject.cloudfunctions.net/laterProxy",
4  "calls": [
5    {
6      "name": "Get Scheduled Posts",
7      "method": "GET",
8      "endpoint": "/?path=/posts&limit={{limit}}&status={{status}}",
9      "variables": [
10        { "name": "limit", "type": "Integer", "default": 20 },
11        { "name": "status", "type": "String", "default": "scheduled" }
12      ],
13      "json_paths": {
14        "ids": "$.data[*].id",
15        "captions": "$.data[*].caption",
16        "scheduledAt": "$.data[*].scheduled_at",
17        "platforms": "$.data[*].social_profile.platform",
18        "thumbnailUrls": "$.data[*].media_urls[0]",
19        "statuses": "$.data[*].status"
20      }
21    },
22    {
23      "name": "Get Media Library",
24      "method": "GET",
25      "endpoint": "/?path=/media&limit={{limit}}",
26      "variables": [
27        { "name": "limit", "type": "Integer", "default": 40 }
28      ],
29      "json_paths": {
30        "ids": "$.data[*].id",
31        "mediaUrls": "$.data[*].media_url",
32        "thumbnailUrls": "$.data[*].thumbnail_url",
33        "types": "$.data[*].type",
34        "usageCounts": "$.data[*].usage_count"
35      }
36    }
37  ]
38}

Create a 'Content Calendar' screen in FlutterFlow. Set 'Get Scheduled Posts' as the Backend Query so data loads automatically on page open. Configure the Backend Query to pass `limit=20` and `status=scheduled`. Add a ListView widget. In the list item template, add a Row containing: a CachedNetworkImage widget (or the built-in Image widget with 'Fade In' animation enabled) bound to `thumbnailUrl`, sized to 80×80 pixels with a BoxFit of 'Cover'. To the right of the image, add a Column: a Row at the top with a Text for `platform` (styled as a small badge with platform-color background — use a switch/case conditional color) and a Text for `scheduledAt` formatted as 'MMM d, h:mm a'; a Text widget for `caption` set to 2 lines max with ellipsis, 14sp. Enable pull-to-refresh on the ListView: set the refresh action to call 'Get Scheduled Posts' with `forceRefresh=true` (or your force-refresh API Call variant). Store the fetched posts in Page State so navigating away and back does not retrigger the Backend Query unnecessarily. For the media library screen: add a GridView widget set to 3 columns. Each cell contains a CachedNetworkImage bound to `thumbnailUrl` with a BoxFit of 'Cover' and AspectRatio 1:1. Enable lazy loading (images only load as they scroll into view). Add a tap action that opens a bottom sheet or navigates to a detail screen showing the full-size media URL. Timezone handling: Later returns `scheduled_at` in the account's timezone as an ISO string. Display it using FlutterFlow's built-in 'Format Date' transformation with the format string `MMM d 'at' h:mm a` to show a human-readable scheduled time.

Add error handling for the two most common Later API issues: plan-gate 401 errors and timezone display problems. For the plan-gate issue: wrap the Backend Query with an error handler in the Action Flow. If the proxy returns a 401 status, set a Page State boolean `showPlanError` to true. Add a conditional widget at the top of the screen: when `showPlanError` is true, show a banner Container with orange background and text 'Later API is not available on your current plan — upgrade to Agency or Business to use this integration.' This gives the user a clear next step instead of a cryptic error screen. For timezone handling: Later's API returns `scheduled_at` timestamps in the account's own configured timezone. If you simply display them as-is, users in a different timezone than the Later account will see incorrect times. Confirm with the Later API documentation whether timestamps are returned in UTC (with the account timezone noted separately) or in the account-local timezone. If they are account-local, store the account timezone string in App State (fetched from a `GET /account` endpoint) and display a timezone label like 'Scheduled for 3:30 PM PST' next to each post time. For a 429 rate-limit error: display a Snackbar 'Refreshing too quickly — please wait a moment' and disable the pull-to-refresh for 30 seconds using a Page State timer. Remind the user that Later data updates automatically every 2 minutes via the proxy cache. For the platform badge conditional styling: use FlutterFlow's conditional visibility or a custom color expression. Set the Container background color based on the `platform` string: 'instagram' → gradient pink-purple, 'facebook' → blue, 'twitter' → sky blue, 'linkedin' → dark blue, 'tiktok' → black.