Buildium

Log into your Buildium account at buildium.com. Navigate to Settings (gear icon in the top navigation) → Application Settings → API. If you do not see an API section, your Buildium plan does not include API access — Essential, Growth, or Premium plans are required. Free trial and entry-level accounts do not have API settings. In the API settings section, click 'Create Client ID and Secret' (the exact button label may vary slightly by Buildium UI version). Buildium will generate two values: - Client ID (referred to as 'clientid' in API documentation): your API identifier - Client Secret (referred to as 'clientsecret'): your secret authentication value Copy both values immediately and store them securely — the client secret is typically shown only once at creation time. If you lose it, you will need to regenerate new credentials and update your Bubble API Connector configuration. Note that unlike most modern APIs, Buildium's authentication uses these values as query parameters on every API call — not in headers. This means every request URL to Buildium's API will include ?clientid=[value]&clientsecret=[value] appended to it. In the Bubble API Connector, you handle this by adding them as shared query parameters so they automatically append to all calls without being repeated in each individual call configuration.

Buildium's query parameter authentication requires a specific API Connector configuration that differs from header-based APIs. Follow these steps carefully. In your Bubble editor, go to Plugins → API Connector. Click 'Add another API' and name it 'Buildium'. Set the shared base URL to https://api.buildium.com/api/v1. Instead of adding an Authorization header, add shared query parameters: - Click 'Add shared headers or parameters' → select 'Shared parameters' - Add parameter: Key = clientid, Value = [your clientid], check the 'Private' checkbox - Add another parameter: Key = clientsecret, Value = [your clientsecret], check the 'Private' checkbox These shared query parameters will automatically append to every API call URL: https://api.buildium.com/api/v1/properties?clientid=[value]&clientsecret=[value]. They never appear in browser network requests because Bubble proxies calls server-side. Now add your first call to test the connection. Name it 'Get Properties'. Set: - Method: GET - URL path: /properties - No additional parameters needed for a basic list Click 'Initialize call'. Bubble will send a GET request to https://api.buildium.com/api/v1/properties with the clientid and clientsecret query parameters automatically appended. If the call succeeds, Bubble detects the response fields — property id, name, address, unitCount, etc. If you see 'There was an issue setting up your call': double-check that clientid and clientsecret are spelled exactly as lowercase (Buildium is case-sensitive on parameter names) and that both are in the query parameters section, not the headers section.

1// Buildium API Connector configuration
2// Base URL: https://api.buildium.com/api/v1
3
4// Shared QUERY PARAMETERS (NOT headers):
5// clientid: <your_clientid_private>
6// clientsecret: <your_clientsecret_private>
7
8// Example resulting request URL:
9// GET https://api.buildium.com/api/v1/properties?clientid=abc&clientsecret=xyz
10
11// Properties call
12{
13  "method": "GET",
14  "url": "https://api.buildium.com/api/v1/properties",
15  "params": {
16    "clientid": "<shared_private>",
17    "clientsecret": "<shared_private>",
18    "limit": "100",
19    "offset": "<dynamic_offset>"
20  }
21}

With the API Connector configured, build the core tenant management view. This is the primary use case for most Buildium-Bubble integrations: a property manager sees all their tenants, can filter by property, and can click a tenant row for details. First, add a call to your Buildium API Connector: name it 'Get Tenants'. Method: GET. URL path: /rentals/tenants. Add dynamic query parameters: - propertyids (multi-select by property ID): allows filtering to a specific property - statuses (filter by tenant status: Current, Past, Future) - limit: 100 (static) - offset: [dynamic, starting 0] Initialize with real values (use an actual property ID from your Buildium account and status='Current') to detect the response field structure. Next, create a Bubble data type called Tenant with fields that map to Buildium's response: buildium_tenant_id (number), first_name (text), last_name (text), email (text), phone (text), unit_id (number), lease_id (number), monthly_rent (number), lease_end_date (date), status (text), last_synced (date). Create a page workflow ('when page is loaded'): call Get Tenants, loop through results with 'Create or update Tenant' (match on buildium_tenant_id), and set last_synced to Current date/time. Add a Repeating Group to your page with data source 'Do a search for Tenant sorted by last_name'. Include filter inputs: a Property dropdown (populated from your Bubble Property data type), a Status dropdown (Current/Past/Future), and a text search on first_name or last_name. Inside each row: tenant name, unit number, monthly rent, lease end date, and a 'View Details' button that opens a popup with the full tenant record. Configure Bubble privacy rules on the Tenant data type before testing: Data tab → Tenant → Privacy → add rule: Current User is logged in, View all fields. Test by confirming a logged-out incognito browser cannot see any tenant records.

1// Get Tenants API call configuration
2{
3  "method": "GET",
4  "url": "https://api.buildium.com/api/v1/rentals/tenants",
5  "params": {
6    "clientid": "<shared_private>",
7    "clientsecret": "<shared_private>",
8    "propertyids": "<dynamic_property_id>",
9    "statuses": "<dynamic_status>",
10    "limit": "100",
11    "offset": "<dynamic_offset>"
12  }
13}

Maintenance request management is a critical workflow for property managers. Buildium's API supports reading, creating, and updating maintenance requests. The status update uses PATCH (not PUT) — a specific HTTP method that updates only the supplied fields rather than replacing the entire record. Add three calls to your Buildium API Connector: 1. 'Get Maintenance Requests' — GET /maintenance/requests with dynamic parameters: propertyids, statuses (New, InProgress, Completed, Deferred, Closed), limit, offset. 2. 'Update Maintenance Status' — PATCH /maintenance/requests/{id} with dynamic path variable {id} and JSON body: {"status": "[dynamic_status]"}. Set body type to JSON. 3. (Optional) 'Create Maintenance Request' — POST /maintenance/requests with JSON body containing unitId, title, description, and requestedByTenantId. Create a Bubble data type MaintenanceRequest: buildium_request_id, unit_id, property_id, title, description, status (text), reported_date (date), closed_date (date), last_synced (date). Build a maintenance board page (or tab on your main dashboard) with a Repeating Group of MaintenanceRequest records, filtered by status using a dropdown (All / New / InProgress / Completed). Inside each row: title, property name, unit number, status badge (colored text element), reported date. For the status update: clicking a row opens a popup showing request details. The popup includes a dropdown 'Change status' with values New, InProgress, Completed, Deferred. A 'Save' button triggers: 1. Call 'Update Maintenance Status' with the request ID and new status value. 2. Make changes to the MaintenanceRequest thing in Bubble's DB to update the status field locally (so the Repeating Group updates without a full page reload). 3. Show a success alert. Note on PATCH body type: in Bubble's API Connector, when you set up the 'Update Maintenance Status' call, choose body type 'JSON' and add the body parameter 'status' as a dynamic field. If you accidentally set body type to 'Form parameters URL-encoded', Buildium will return a 400 error on PATCH calls — the JSON body type is required for Buildium's PATCH endpoint.

1// Get Maintenance Requests
2{
3  "method": "GET",
4  "url": "https://api.buildium.com/api/v1/maintenance/requests",
5  "params": {
6    "clientid": "<shared_private>",
7    "clientsecret": "<shared_private>",
8    "propertyids": "<dynamic_property_id>",
9    "statuses": "<dynamic_status_filter>",
10    "limit": "100",
11    "offset": "<dynamic_offset>"
12  }
13}
14
15// PATCH Maintenance Request Status
16{
17  "method": "PATCH",
18  "url": "https://api.buildium.com/api/v1/maintenance/requests/<dynamic_request_id>",
19  "headers": {
20    "Content-Type": "application/json"
21  },
22  "body": {
23    "status": "<dynamic_new_status>"
24  }
25}

The vacancy dashboard is the most immediately valuable view for property managers: which units are currently empty and available to rent, and which active leases are approaching expiration. Add two calls to your Buildium API Connector: 1. 'Get Vacant Units' — GET /units with query parameter filterByVacancyStatus=Vacant (static), limit=100, offset=[dynamic]. This returns units with no active tenant. 2. 'Get Expiring Leases' — GET /leases with query parameters leasestatus=Active (static), limit=100, offset=[dynamic]. You will filter in Bubble for leases ending within 60 days. Create a Bubble data type Unit: buildium_unit_id, unit_number, property_id, property_name, vacancy_status (text), bedrooms (number), bathrooms (number), monthly_rent (number), available_date (date), last_synced (date). Create a Bubble data type Lease: buildium_lease_id, tenant_id, unit_id, property_id, lease_start (date), lease_end (date), monthly_rent (number), status (text), last_synced (date). Build a Vacancy Dashboard page with two sections: Section 1 — Vacant Units: a Repeating Group with data source 'Search for Unit where vacancy_status = Vacant, sorted by property_name'. Display unit number, property name, available_date, monthly_rent, and a 'Mark as listed' action button. A summary count element shows 'X units currently vacant'. Section 2 — Expiring Leases: a Repeating Group with data source 'Search for Lease where lease_end < Current date/time + 60 days AND status = Active, sorted by lease_end ascending'. Display tenant name (via the associated Tenant record), unit number, property name, and lease end date. Color-code the lease_end date: red if < 30 days, yellow if 30–60 days. Populate both data types via a page-loaded workflow that calls the Buildium API and upserts records. A Refresh button triggers the same workflow on demand. For portfolios larger than 100 units, you will hit Buildium's 100-record pagination limit. Implement offset-based pagination: after each API call, check if the response count equals 100. If so, run a 'Schedule API Workflow' step (Backend Workflow, requires paid Bubble plan) that re-calls the same endpoint with offset+100 until the response count is less than 100.

1// Get Vacant Units
2{
3  "method": "GET",
4  "url": "https://api.buildium.com/api/v1/units",
5  "params": {
6    "clientid": "<shared_private>",
7    "clientsecret": "<shared_private>",
8    "filterByVacancyStatus": "Vacant",
9    "limit": "100",
10    "offset": "<dynamic_offset>"
11  }
12}
13
14// Get Active Leases (filter by expiry in Bubble)
15{
16  "method": "GET",
17  "url": "https://api.buildium.com/api/v1/leases",
18  "params": {
19    "clientid": "<shared_private>",
20    "clientsecret": "<shared_private>",
21    "leasestatus": "Active",
22    "limit": "100",
23    "offset": "<dynamic_offset>"
24  }
25}

Tenant data in property management includes some of the most sensitive personal information: full names, email addresses, phone numbers, Social Security numbers (used in screening), bank account numbers (for ACH rent payments), and rental payment history. Before any version of your Bubble app reaches real users, privacy rules must be configured and tested. Go to Bubble's Data tab. For every data type that stores Buildium data — Tenant, Lease, Unit, MaintenanceRequest — click the Privacy tab at the top of the data type editor. For the Tenant data type (most sensitive): add a privacy rule with condition 'Current User is logged in'. Enable 'View all fields'. If your app has user roles (property managers vs tenants vs owners), add a more specific condition: 'Current User's role is in [list of authorized roles]'. This prevents a logged-in tenant from viewing other tenants' records if they know the URL structure. For the Unit and Lease data types (moderately sensitive): similar rule — logged-in users only, optionally scoped by property ownership (e.g., 'Current User's managed_property_ids contains Current Unit's property_id'). For MaintenanceRequest (less sensitive but still protected): logged-in users who own the unit or who are property managers. After configuring rules, test in three scenarios: 1. Open an incognito browser window, navigate to your Bubble app without logging in, and try to access any page showing Buildium data. Confirm no data appears. 2. Log in as a tenant user (if your app has tenant-facing pages) and confirm they see only their own tenant record, not other tenants'. 3. Log in as a property manager and confirm they see all tenants across their properties. RapidDev's team has built tenant portal applications on Bubble with complex multi-role privacy rule structures — if your access control requirements are complex, a free scoping call at rapidevelopers.com/contact can help design the right Bubble privacy rule architecture before you build.

1// Bubble Privacy Rules configuration
2// Data tab → [DataType] → Privacy
3
4// Tenant (most sensitive — includes PII):
5// Rule name: Authenticated property managers only
6// Condition: Current User is logged in
7//            AND Current User's role = "Property Manager"
8// Permissions: View all fields = checked
9
10// For tenant self-view (tenants see their own record only):
11// Rule name: Own record
12// Condition: Current User's tenant_profile = Current User's Tenant
13// Permissions: View all fields = checked
14
15// Unit (less sensitive):
16// Rule name: Logged in users
17// Condition: Current User is logged in
18// Permissions: View all fields = checked