Buildium

Log into your Buildium account and navigate to Settings in the left navigation. Look for the API Configuration section (sometimes under Account Settings or Administration). If you do not see API Configuration, your account plan does not include API access — contact Buildium support to confirm which plan tier enables it, or upgrade to a tier that does. API access is not available on free trials. In API Configuration, toggle API access to Enabled. Once enabled, a form appears to create a new API key. Fill in a label (e.g., 'FlutterFlow App') and click Create. Buildium generates two values: the Client ID (this is your x-buildium-client-id header value) and the Client Secret (your x-buildium-client-secret header value). Copy both values to a secure location immediately — the Client Secret may only be displayed once. These two values are the only credentials you need to authenticate with the Buildium API. There is no token exchange, no OAuth flow, no expiry by default. Every HTTP request to https://api.buildium.com/api/v1/... must include these two headers. The base URL for all Buildium REST calls is https://api.buildium.com/api/v1. Endpoints follow a predictable structure: /rentals for properties, /rentals/leases for lease records, /leases/{id}/outstandingitems for outstanding charges, /maintenance/requests for work orders.

Create a Firebase Cloud Function that accepts requests from your FlutterFlow app and forwards them to the Buildium API with the authentication headers set server-side. Store your Client ID and Client Secret in Firebase Functions config — not in the function code file: run firebase functions:config:set buildium.client_id='YOUR_ID' buildium.client_secret='YOUR_SECRET' from your local terminal. The proxy function receives a request specifying which Buildium resource to fetch (e.g., leases, maintenance requests, transactions). It reads the client ID and secret from Firebase config, adds them as headers to an outbound request to https://api.buildium.com/api/v1/..., and returns the Buildium response to the FlutterFlow app. Keep the proxy thin: let FlutterFlow pass a resource type and optional filter parameters; the proxy constructs the Buildium URL and headers. For pagination, Buildium REST endpoints typically accept offset and limit query parameters and return a total count in the response. Have the proxy accept an offset parameter from FlutterFlow and forward it. For most landlord dashboard use cases — one portfolio of properties with tens to hundreds of units — returning 100 records per call covers the full dataset in one or two calls. Add a cache layer: store the response in a Firestore document with a timestamp, and serve the cached version for the next 3-5 minutes before re-fetching from Buildium. This reduces API calls and speeds up the app.

1// Firebase Cloud Function proxy — index.js
2const functions = require('firebase-functions');
3const admin = require('firebase-admin');
4const axios = require('axios');
5admin.initializeApp();
6
7const BUILDIUM_BASE = 'https://api.buildium.com/api/v1';
8const CACHE_TTL_MS = 4 * 60 * 1000; // 4-minute cache
9
10// Generic proxy function for Buildium endpoints
11exports.buildiumProxy = functions.https.onCall(async (data, context) => {
12  const cfg = functions.config().buildium;
13  // data.resource = 'rentals/leases' | 'maintenance/requests' | 'leases/{id}/outstandingitems' etc.
14  const { resource, params = {}, offset = 0, limit = 100 } = data;
15
16  // Check Firestore cache
17  const cacheKey = `${resource}_${JSON.stringify(params)}_${offset}`;
18  const cacheDoc = await admin.firestore().doc(`buildium_cache/${Buffer.from(cacheKey).toString('hex')}`).get();
19  if (cacheDoc.exists) {
20    const { responseData, cached_at } = cacheDoc.data();
21    if (Date.now() - cached_at < CACHE_TTL_MS) {
22      return { data: responseData, fromCache: true };
23    }
24  }
25
26  // Call Buildium API with credentials in headers (never in the client)
27  const queryParams = new URLSearchParams({ ...params, offset, limit }).toString();
28  const url = `${BUILDIUM_BASE}/${resource}${queryParams ? '?' + queryParams : ''}`;
29  const resp = await axios.get(url, {
30    headers: {
31      'x-buildium-client-id': cfg.client_id,
32      'x-buildium-client-secret': cfg.client_secret,
33      'Content-Type': 'application/json',
34    },
35  });
36
37  // Write to cache
38  await admin.firestore().doc(`buildium_cache/${Buffer.from(cacheKey).toString('hex')}`).set({
39    responseData: resp.data,
40    cached_at: Date.now(),
41  });
42
43  return { data: resp.data, fromCache: false };
44});

Open your FlutterFlow project. Click API Calls in the left navigation panel, then click + Add → Create API Group. Name the group BuildiumProxy. Set the Base URL to your Firebase Functions URL: https://us-central1-YOUR-PROJECT-ID.cloudfunctions.net. Add the first API Call: click + Add API Call. Name it GetLeases. Set the method to POST (Firebase callable functions require POST) and the path to /buildiumProxy. In the Body tab, add a JSON body that passes the resource to the proxy: {"resource": "rentals/leases", "limit": 100}. FlutterFlow will POST this body to your proxy function, which reads the resource field and calls the corresponding Buildium endpoint. For endpoints that need dynamic parameters — like fetching outstanding items for a specific lease — add Variables in the Variables tab. Create a variable leaseId (String). In the Body, reference it as: {"resource": "leases/{{leaseId}}/outstandingitems"}. The variable becomes available in FlutterFlow's UI so you can pass the lease ID when the user taps into a lease detail screen. In the Response & Test tab, paste a sample Buildium leases response (see the code block below) and click Generate JSON Paths. Create a Data Type called BuildiumLease with fields: id (Integer), tenantNames (String), unitAddress (String), monthlyRent (Double), leaseEndDate (String), status (String). Map the JSON paths to this Data Type. Repeat the process to add GetMaintenanceRequests and GetTransactions API Calls for the other screens your app needs.

1// Paste as sample in FlutterFlow Response & Test for GetLeases
2{
3  "data": [
4    {
5      "Id": 10042,
6      "StartDate": "2024-01-01",
7      "EndDate": "2025-12-31",
8      "Rent": 1850.00,
9      "Status": "Active",
10      "Tenants": [
11        { "Id": 2201, "FirstName": "Jordan", "LastName": "Smith" }
12      ],
13      "Unit": {
14        "Id": 305,
15        "Address": {
16          "AddressLine1": "12 Maple Street",
17          "Unit": "3B",
18          "City": "Portland",
19          "State": "OR"
20        }
21      }
22    }
23  ]
24}

Add a new Screen called Rentals. Add a ListView widget. Set its Backend Query to BuildiumProxy → GetLeases. Set the list type to BuildiumLease. FlutterFlow calls the proxy on screen load and populates the list. Inside the ListView item template, add a Container with a card style (border radius 10, drop shadow, white background). Inside, add a Column with: a Text widget for the unit address (bound to BuildiumLease.unitAddress), a Text widget for the tenant names (bound to BuildiumLease.tenantNames), a Row with the monthly rent amount (BuildiumLease.monthlyRent formatted as currency) and the lease end date (BuildiumLease.leaseEndDate), and a status Badge widget showing Active or Expired based on BuildiumLease.status. Above the ListView, add summary cards: a Container Row with three cards showing total active leases (count of BuildiumLease items with status=Active), total monthly rent (sum of BuildiumLease.monthlyRent), and leases expiring within 90 days (filter on leaseEndDate within 90 days). These computed values use FlutterFlow's List Aggregation and Filter functions without requiring additional API calls. Add a pull-to-refresh gesture by wrapping the ListView in a RefreshIndicator. Bind the refresh action to the GetLeases API Call. Because the proxy caches results for 4 minutes, rapid pull-to-refresh requests will return the cached data — this is acceptable behaviour; users can wait for the cache to expire for truly fresh data.

Add a second Screen called Maintenance. Add a ListView widget bound to BuildiumProxy → GetMaintenanceRequests. The request body to the proxy should be {"resource": "maintenance/requests", "params": {"Status": "New,InProgress"}}. This filters to only open and in-progress requests. Create a Data Type called MaintenanceRequest with fields: id (Integer), title (String), description (String), status (String), priority (String), unitAddress (String), submittedDate (String). Map JSON paths from a sample maintenance request response. Inside the ListView item, show the issue title, unit address, status, and a priority colour indicator (red for Urgent, amber for Normal, green for Low). For navigation: on the Rentals screen, make each lease card tappable. In the Action Flow Editor for the card's on-tap action, add a Navigate action to a Lease Detail screen. Pass the leaseId as a page parameter. On the Lease Detail screen, make a GetOutstandingItems API Call using the passed leaseId as a variable: Body = {"resource": "leases/{{leaseId}}/outstandingitems"}. This shows rent due, fees, and other charges for the specific lease. At the bottom of the Lease Detail screen, add a separate section for recent transactions for that lease, bound to another API Call: {"resource": "leases/{{leaseId}}/transactions", "params": {"limit": 20}}. This gives a complete financial picture for that lease without the user leaving the app.

For property managers with large portfolios — hundreds of units — a single API call returning 100 records may not be sufficient. Buildium's API supports pagination via offset and limit parameters. In FlutterFlow, add a Load More button at the bottom of the ListView. Bind it to an App State variable called currentOffset (Integer, starts at 0). When the user taps Load More, trigger a GetLeases API Call with the body {"resource": "rentals/leases", "offset": currentOffset + 100, "limit": 100}, then append the new results to your existing lease list in App State, and increment currentOffset by 100. For error states, add a Conditional widget to the Rentals screen that shows a different layout when the GetLeases API Call returns an error. A simple column with an icon, 'Could not load rental data', and a Retry button (which re-triggers the GetLeases call) handles this gracefully. Also add a check for the case where the proxy returns an empty data array: show a 'No active leases found' empty state instead of a blank screen. For the API key itself: if the key is ever compromised, regenerate it in Buildium's Settings → API Configuration and update the Firebase Functions config (firebase functions:config:set buildium.client_id='NEW_ID' buildium.client_secret='NEW_SECRET'), then redeploy. The FlutterFlow side needs no changes because it talks to your proxy URL, not directly to Buildium. If you would rather have a team set up the proxy, configure the caching, and handle ongoing maintenance for your property management app, RapidDev builds FlutterFlow integrations like this regularly — free scoping call at rapidevelopers.com/contact.