Propertybase

Open your Salesforce org and navigate to Setup (the gear icon in the top-right corner) → search 'App Manager' in Quick Find → click 'New Connected App' in the top-right. Fill in the Connected App Name (e.g. 'FlutterFlow Propertybase'), your contact email, and check 'Enable OAuth Settings.' Set the Callback URL to `https://login.salesforce.com/services/oauth2/success` (this is a placeholder for the server-to-server flow). Under 'Selected OAuth Scopes,' add 'Access and manage your data (api)' and 'Perform requests on your behalf at any time (refresh_token, offline_access).' Save, then wait 2–10 minutes for the Connected App to propagate. Go back to App Manager, find your new Connected App, click the dropdown arrow on the right, and select 'View.' Scroll down to the 'API (Enable OAuth Settings)' section and click 'Manage Consumer Details' — you'll be asked to re-verify your Salesforce identity via email or authenticator. Once verified, copy your Consumer Key and Consumer Secret. Store them somewhere secure (a password manager) — you will paste them into your Cloud Function environment variables, never directly into FlutterFlow. Also note your Salesforce org's My Domain URL: go to Setup → 'My Domain' → copy the domain string (e.g. `yourcompany.my.salesforce.com`). This forms the base URL for all Salesforce REST API calls.

Before writing any SOQL, you need to confirm the exact API names of the Propertybase objects in your org. These names use a `pb__` prefix, but they vary depending on the Propertybase version installed and any customizations your admin has made. A wrong object name returns a `INVALID_TYPE: pb__Listing__c is not supported` error from Salesforce that looks like an auth problem but is actually a schema mismatch. In Salesforce Setup, type 'Object Manager' in Quick Find and open it. You'll see a list of all Salesforce and custom objects in your org. Use the search bar at the top of the Object Manager to search for 'pb' — this will surface all Propertybase custom objects. Common objects include: `pb__Listing__c` (property listings), `pb__Transaction__c` (sale/rental transactions), `pb__Commission__c` (commission records), and `pb__Listing_Agent_Role__c` (agent-listing relationships). Click each object to see its Field API Names — for example, the listing price field might be `pb__List_Price__c` not just `Price`. Make a quick reference list of the object API names and the field API names you plan to query. You'll use these directly in your SOQL strings inside the Cloud Function. If you don't see any pb__ objects, your org may have Propertybase installed under a different namespace — check with your Propertybase account manager.

1-- Example SOQL query to test in Salesforce Developer Console (Query Editor tab)
2SELECT Id, pb__Street_Address__c, pb__City__c, pb__List_Price__c,
3       pb__Status__c, pb__Days_On_Market__c, OwnerId
4FROM pb__Listing__c
5WHERE pb__Status__c = 'Active'
6ORDER BY pb__List_Price__c ASC
7LIMIT 10

This is the most critical step: a server-side proxy that holds your OAuth credentials and acts as the only bridge between FlutterFlow and Salesforce. Never put the Consumer Key, Consumer Secret, or Salesforce passwords in FlutterFlow. In your Firebase project, go to the Firebase Console → Functions → Get Started (you need the Blaze plan). Open a browser-based Cloud Functions editor or use the Firebase console's inline editor if available. Create an HTTPS function called `querySalesforce`. The function performs these steps on each call: (1) POST to `https://login.salesforce.com/services/oauth2/token` with `grant_type=client_credentials`, your Consumer Key as `client_id`, and Consumer Secret as `client_secret` to obtain an access token. (2) Use that token to call the Salesforce REST query endpoint with the SOQL passed in the request body. (3) Return the Salesforce response as JSON to FlutterFlow. Store the Consumer Key and Consumer Secret using Firebase environment configuration (set them via the Firebase console Functions → Configuration, NOT hardcoded in the function). The complete function code is shown below — paste it into the inline editor, save, and deploy. The function URL will look like `https://us-central1-your-project.cloudfunctions.net/querySalesforce`. If you'd rather skip writing and maintaining the Cloud Function yourself, RapidDev's team builds FlutterFlow–Salesforce integrations every week — free scoping call at rapidevelopers.com/contact.

1const functions = require('firebase-functions');
2const axios = require('axios');
3
4// Store these in Firebase Functions Config, not hardcoded:
5// firebase functions:config:set sf.consumer_key="YOUR_KEY" sf.consumer_secret="YOUR_SECRET" sf.instance_url="https://yourorg.my.salesforce.com"
6const SF_CONSUMER_KEY = functions.config().sf.consumer_key;
7const SF_CONSUMER_SECRET = functions.config().sf.consumer_secret;
8const SF_INSTANCE_URL = functions.config().sf.instance_url;
9
10async function getSalesforceToken() {
11  const params = new URLSearchParams();
12  params.append('grant_type', 'client_credentials');
13  params.append('client_id', SF_CONSUMER_KEY);
14  params.append('client_secret', SF_CONSUMER_SECRET);
15
16  const res = await axios.post(
17    'https://login.salesforce.com/services/oauth2/token',
18    params
19  );
20  return res.data.access_token;
21}
22
23exports.querySalesforce = functions.https.onRequest(async (req, res) => {
24  // Allow CORS for web builds
25  res.set('Access-Control-Allow-Origin', '*');
26  if (req.method === 'OPTIONS') {
27    res.set('Access-Control-Allow-Methods', 'POST');
28    res.set('Access-Control-Allow-Headers', 'Content-Type');
29    return res.status(204).send('');
30  }
31
32  try {
33    const { soql } = req.body;
34    if (!soql) return res.status(400).json({ error: 'soql is required' });
35
36    const token = await getSalesforceToken();
37    const encodedSoql = encodeURIComponent(soql);
38    const sfRes = await axios.get(
39      `${SF_INSTANCE_URL}/services/data/v59.0/query?q=${encodedSoql}`,
40      { headers: { Authorization: `Bearer ${token}` } }
41    );
42
43    return res.json(sfRes.data);
44  } catch (err) {
45    console.error(err.response?.data || err.message);
46    return res.status(500).json({ error: 'Salesforce query failed' });
47  }
48});

Now that the proxy is live, add it to FlutterFlow as an API Call so your app can query Salesforce listing data. Click 'API Calls' in the left navigation panel of the FlutterFlow editor. Click the '+' (plus) button and choose 'Create API Group.' Name it 'PropertybaseSF.' In the Base URL field, paste your Cloud Function URL (e.g. `https://us-central1-your-project.cloudfunctions.net`). Leave the Headers section empty — no API keys here, since security lives in the Cloud Function. With the API Group created, click '+' again and select 'Create API Call' inside the PropertybaseSF group. Name it 'QueryListings.' Set the Method to POST. Set the Path to `/querySalesforce`. Click the 'Body' tab and set the Content-Type to `application/json`. Click '+ Add Body Field' and add a variable named `soql` with type String. In the body JSON template, set the value to `{{ soql }}`. Now click the 'Response & Test' tab. In the 'Variables' section, fill in the `soql` field with your test SOQL string: `SELECT Id, pb__Street_Address__c, pb__City__c, pb__List_Price__c, pb__Status__c FROM pb__Listing__c WHERE pb__Status__c = 'Active' LIMIT 20`. Click 'Test API Call.' If the function is deployed correctly, you'll see a JSON response with a `records` array. Click 'Generate JSON Paths' — FlutterFlow will parse the response and create JSON path variables like `$.records[*].pb__Street_Address__c` and `$.records[*].pb__List_Price__c` that you can bind directly to widgets.

1// API Call configuration reference (not a file — use this to match FlutterFlow UI settings)
2// Group Name: PropertybaseSF
3// Base URL: https://us-central1-YOUR_PROJECT.cloudfunctions.net
4//
5// Call Name: QueryListings
6// Method: POST
7// Path: /querySalesforce
8// Content-Type: application/json
9// Body: { "soql": "{{ soql }}" }
10//
11// JSON Paths after test:
12// Total records:  $.totalSize
13// Records array:  $.records
14// Address:        $.records[*].pb__Street_Address__c
15// City:           $.records[*].pb__City__c
16// List price:     $.records[*].pb__List_Price__c
17// Status:         $.records[*].pb__Status__c

On your FlutterFlow listing-search screen, add a ListView widget from the widget panel. Select the ListView, open its 'Backend Query' settings in the right panel, choose 'API Call,' select the PropertybaseSF group and QueryListings call. In the 'Variables' section, bind the `soql` variable to a string that includes a LIMIT and an OFFSET driven by a Page State variable. Create two Page State variables: `pageOffset` (Integer, default 0) and `listings` (List of JSON, default empty). On the page's 'On Page Load' action, add an API Call action for QueryListings with `soql` = `SELECT Id, pb__Street_Address__c, pb__City__c, pb__List_Price__c, pb__Status__c FROM pb__Listing__c WHERE pb__Status__c = 'Active' ORDER BY CreatedDate DESC LIMIT 20 OFFSET 0`. Store the result in the `listings` Page State variable. Inside the ListView, add a Column widget for each card: a Text widget bound to `$.pb__Street_Address__c` from the current list item, another Text bound to `$.pb__City__c`, and a formatted Text for list price. Add a 'Load More' button below the ListView that increments `pageOffset` by 20 and fires another QueryListings call with the updated OFFSET, then appends results to the `listings` list. For the SOQL 2,000-record hard cap: Salesforce will simply stop returning records at 2,000 regardless of your OFFSET. If your listing portfolio exceeds that, filter by date range in the WHERE clause (`CreatedDate = LAST_N_DAYS:90`) or by status to keep each query well under the cap. Always add `LIMIT 20` or `LIMIT 50` to every query — an open-ended SOQL query will fetch all matching records in one call and hit the cap silently.

1-- Paginated SOQL with LIMIT/OFFSET
2SELECT Id, pb__Street_Address__c, pb__City__c,
3       pb__List_Price__c, pb__Status__c, pb__Days_On_Market__c
4FROM pb__Listing__c
5WHERE pb__Status__c = 'Active'
6  AND CreatedDate = LAST_N_DAYS:90
7ORDER BY pb__List_Price__c ASC
8LIMIT 20 OFFSET {{ pageOffset }}

Propertybase's object model connects Listings to Contacts and Accounts through relationship fields. When you include relationship fields in SOQL (e.g. `pb__Listing__r.OwnerId`), Salesforce returns them as nested JSON objects when present, but returns `null` when the relationship is empty. FlutterFlow's JSON Path bindings do not gracefully handle null nested objects by default — binding `$.records[*].pb__Listing_Agent_Role__r.Name` to a Text widget will render a blank or error if the relationship record doesn't exist. To guard against this, write your Cloud Function to reshape the Salesforce response before sending it to FlutterFlow: for each record, explicitly check for null relationship fields and substitute a safe default string. Alternatively, use SOQL's colon syntax to avoid nulls: `SELECT Id, (SELECT Contact.Name FROM pb__Listing_Agent_Roles__r) FROM pb__Listing__c` and flatten the sub-query in the Cloud Function before returning. For writing new contacts (e.g. open-house sign-ins), add a second API Call in FlutterFlow — also a POST to your Cloud Function, but with a different body field `operation: 'create_contact'`. In the Cloud Function, detect `operation` and call the Salesforce REST API POST `/services/data/v59.0/sobjects/Contact` with the provided first name, last name, email, and phone fields. Return the new Contact Id to FlutterFlow so you can show a success confirmation. Always validate required Salesforce fields (at minimum, `LastName`) before calling the API, since Salesforce returns a `REQUIRED_FIELD_MISSING` error that your app should surface clearly rather than silently swallowing.

1// Add to the Cloud Function to handle contact creation:
2// In req.body, check for operation === 'create_contact'
3
4if (req.body.operation === 'create_contact') {
5  const { firstName, lastName, email, phone } = req.body;
6  if (!lastName) {
7    return res.status(400).json({ error: 'LastName is required for Salesforce Contact creation' });
8  }
9  const token = await getSalesforceToken();
10  const contactRes = await axios.post(
11    `${SF_INSTANCE_URL}/services/data/v59.0/sobjects/Contact`,
12    { FirstName: firstName, LastName: lastName, Email: email, Phone: phone },
13    { headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' } }
14  );
15  return res.json({ id: contactRes.data.id, success: contactRes.data.success });
16}