SharpSpring

Log in to your SharpSpring account. In the left navigation menu, click Settings (gear icon). Scroll down to the API section and click API Settings. If you have not generated API credentials before, click the Generate button. SharpSpring will display your accountID (a numeric string representing your account) and your secretKey (a long alphanumeric token). Copy both values and store them securely — do not paste them into a FlutterFlow API Call directly, as they will be visible in the compiled app. Note that these credentials grant full read and write access to your entire SharpSpring account, including all leads, campaigns, contacts, and deal data. If an employee leaves or credentials are compromised, regenerating them invalidates all existing keys immediately. Before proceeding, verify the credentials by making a test request — you can use a tool like Postman or the curl command below. A successful response will contain a result object with lead data; an auth error returns an error object inside a 200 HTTP response (not a 401 status code).

1# Test SharpSpring credentials with curl
2curl -X POST \
3  'https://api.sharpspring.com/pubapi/v1.2/?accountID=YOUR_ACCOUNT_ID&secretKey=YOUR_SECRET_KEY' \
4  -H 'Content-Type: application/json' \
5  -d '{
6    "method": "getLeads",
7    "params": { "where": {}, "limit": 1, "offset": 0 },
8    "id": "1"
9  }'
10
11# Expected success: { "result": { "lead": [...] }, "error": null, "id": "1" }
12# Auth failure: { "result": null, "error": { "code": -32000, "message": "..." }, "id": "1" }

Because SharpSpring's accountID and secretKey grant full account-wide read and write access, they cannot be stored in a FlutterFlow API Call that compiles into the client app. The correct pattern is a Firebase Cloud Function that holds both credentials as environment config and accepts requests from FlutterFlow, then forwards them to SharpSpring server-side. In Firebase Console, go to your project → Functions → Get started. Create a new file functions/index.js with the code shown below. Deploy it using the Firebase CLI. Once deployed, you will receive a URL like https://us-central1-{your-project}.cloudfunctions.net/sharpspringProxy. Set your credentials as Firebase environment config using the CLI commands shown — never paste them into the function file itself. The function accepts a JSON body with method and params fields and forwards them to SharpSpring, adding the credentials as URL query parameters server-side. It also inspects the SharpSpring response for an error object and returns it as a proper HTTP 400 if one is found, so FlutterFlow can detect failures through the standard HTTP status mechanism. If setting up a Cloud Function feels complex, the RapidDev team configures FlutterFlow proxy patterns like this regularly — book a free scoping call at rapidevelopers.com/contact.

1// Firebase Cloud Function: functions/index.js
2const functions = require('firebase-functions');
3const axios = require('axios');
4
5const ACCOUNT_ID = functions.config().sharpspring.account_id;
6const SECRET_KEY = functions.config().sharpspring.secret_key;
7const SS_URL = 'https://api.sharpspring.com/pubapi/v1.2/';
8
9exports.sharpspringProxy = functions.https.onRequest(async (req, res) => {
10  res.set('Access-Control-Allow-Origin', '*');
11  if (req.method === 'OPTIONS') {
12    res.set('Access-Control-Allow-Methods', 'POST');
13    res.set('Access-Control-Allow-Headers', 'Content-Type');
14    return res.status(204).send('');
15  }
16
17  const { method, params } = req.body;
18  if (!method) {
19    return res.status(400).json({ error: 'method is required' });
20  }
21
22  try {
23    const response = await axios.post(
24      `${SS_URL}?accountID=${ACCOUNT_ID}&secretKey=${SECRET_KEY}`,
25      { method, params: params || {}, id: '1' },
26      { headers: { 'Content-Type': 'application/json' } }
27    );
28
29    // SharpSpring errors return inside a 200 response
30    if (response.data.error) {
31      return res.status(400).json({ error: response.data.error });
32    }
33
34    return res.json(response.data.result);
35  } catch (err) {
36    return res.status(500).json({ error: err.message });
37  }
38});
39
40// Setup & deploy:
41// firebase functions:config:set sharpspring.account_id="123456" sharpspring.secret_key="abc..."
42// firebase deploy --only functions

Open your FlutterFlow project. Click API Calls in the left navigation bar. Click + Add → Create API Group. Name it SharpSpring and set the Base URL to your Firebase Cloud Function URL — for example, https://us-central1-{your-project}.cloudfunctions.net/sharpspringProxy. Add a Content-Type: application/json header to the API Group. Click Save. Now click + Add API Call inside the SharpSpring group. Name it CallSharpSpring. Set the method to POST. Leave the endpoint blank (the proxy URL is the full path). Click the Body tab and set the body type to JSON. Add the following body structure: { "method": "{{ss_method}}", "params": { "where": {}, "limit": {{limit}}, "offset": {{offset}} } } Click the Variables tab and add three variables: ss_method (String, no default), limit (Integer, default 50), offset (Integer, default 0). This single API Call configuration now serves every SharpSpring operation by changing the ss_method variable value: pass 'getLeads' to list leads, 'getCampaigns' to list campaigns, 'getDealStages' to list pipeline stages. Click Response & Test. In the test form, set ss_method to 'getLeads', limit to 5, offset to 0. Click Test API. You should see a response containing a lead array. Click Generate JSON Paths to create path variables. For leads, key paths include $[:].lead (if the proxy returns the array directly) or look for the array root. Inspect the actual response structure and adjust paths accordingly.

1{
2  "group": "SharpSpring",
3  "name": "CallSharpSpring",
4  "method": "POST",
5  "endpoint": "",
6  "body_type": "JSON",
7  "body": {
8    "method": "{{ss_method}}",
9    "params": {
10      "where": {},
11      "limit": "{{limit}}",
12      "offset": "{{offset}}"
13    }
14  },
15  "variables": [
16    { "name": "ss_method", "type": "String" },
17    { "name": "limit", "type": "Integer", "default": 50 },
18    { "name": "offset", "type": "Integer", "default": 0 }
19  ]
20}

Open your leads screen in FlutterFlow. Add a Page State variable called currentOffset (Integer, default 0) and a second one called leads (list of JSON or dynamic, default empty). Select the ListView widget on the screen and open its Backend Query. Add an API Call query pointing to SharpSpring → CallSharpSpring. Set ss_method to 'getLeads', limit to 50, offset to currentOffset. Enable Trigger on Page Load. For the ListView child template, add a Card with three Text widgets. Bind the first Text to the lead's firstName and lastName fields (check the exact JSON path from your test response — SharpSpring lead fields include firstName, lastName, emailAddress, leadScore, and accountName). Bind the second Text to emailAddress. Bind the third to leadScore and add a color conditional: score above 80 = green, 40-80 = orange, below 40 = red. Below the ListView, add a Row with a 'Load more' Button. Wire the button's action flow to: 1) Set currentOffset Page State to currentOffset + 50, 2) Re-trigger the CallSharpSpring API Call with the new offset, 3) Append the new results to the existing leads list in App State. This pagination pattern is critical because SharpSpring silently returns at most 100 results per call with no indication that more exist. Without pagination, a database with 500 leads appears to have only 50-100 in your app. Always implement the 'Load more' pattern from the start.

On your campaigns screen, wire a backend query to CallSharpSpring with ss_method set to 'getCampaigns' and appropriate limit/offset values. Campaign fields in the response include id, campaignName, status, openRate, clickRate, and sentCount. Bind these to a ListView of campaign cards showing the campaign name, status badge (active/paused/draft), and performance metrics. More importantly, you must handle SharpSpring's error response pattern in your action flows. Because the Cloud Function proxy translates SharpSpring's error objects into HTTP 400 responses, you can now use FlutterFlow's standard API Call error handling. In the Action Flow Editor for any SharpSpring API Call action, expand the On Error branch and add a Show Alert Dialog action with the error message text. This gives users a clear error message rather than a silently empty screen. Also add an explicit check for the 100-result silent cap: in your action flow, after the API Call succeeds, check if the number of returned items equals your limit value. If result count equals limit, there may be more records — show the 'Load more' button. If result count is less than limit, you have reached the end — hide the 'Load more' button and optionally show a 'All leads loaded' message. This prevents users from tapping 'Load more' on an already-complete list and getting a confusing empty response.