Algorithmia

Algorithmia no longer accepts new self-serve signups — it was acquired by DataRobot and the public marketplace is being wound down. Before starting the FlutterFlow build, you need to answer a critical question: which platform do you actually have? Option A — Legacy Algorithmia cluster: Your organization has an existing enterprise Algorithmia deployment at a custom domain like https://your-company.algorithmia.com. In this case, your API key uses the Authorization: Simple {key} header format (not Bearer), and algorithm endpoints follow the pattern /api/v1/algo/{owner}/{algorithm}/{version} under your cluster URL. Algorithm responses are wrapped: {"result": ..., "metadata": {...}}. The result field contains the actual algorithm output. Option B — DataRobot: You are using DataRobot's platform at https://app.datarobot.com/api/v2. DataRobot uses a standard Bearer token in the Authorization header, and the response format is DataRobot's prediction JSON structure, not the Algorithmia envelope. Contact your account administrator or DataRobot/Algorithmia account representative to confirm which platform you have, get the correct base URL, your API key, and the exact algorithm or model endpoint path. Write these down — you will need them in your Cloud Function. Do not guess the base URL or auth format: getting either wrong produces silent 401 or 404 failures that are hard to debug.

The Algorithmia or DataRobot API key is a secret credential that must never appear in a FlutterFlow API Call header or in any Dart code — both end up in the compiled app binary. The Cloud Function proxy sits between FlutterFlow and the inference API, adding the correct Authorization header server-side. Create a Node.js 18 Firebase Cloud Function named algorithmiaProxy. The function should: 1. Read the API key from an environment variable (ALGO_KEY) set via Firebase Functions Config or Google Cloud Secret Manager. 2. Determine the auth header format: for legacy Algorithmia clusters use Authorization: Simple {key}; for DataRobot use Authorization: Bearer {key}. Confirm this with your account documentation. 3. POST the JSON body from FlutterFlow (the model input) to the algorithm endpoint URL, adding the Authorization header. 4. Return the response JSON to FlutterFlow with CORS headers for web build support. For legacy Algorithmia, the endpoint URL follows the pattern https://your-cluster.algorithmia.com/api/v1/algo/{owner}/{algo}/{version}. For DataRobot, your account team provides the specific prediction endpoint URL. Deploy with firebase deploy --only functions and note the HTTPS trigger URL. That URL is what FlutterFlow calls — not the Algorithmia or DataRobot URL.

1// functions/index.js (Firebase Cloud Functions, Node.js 18)
2// Adjust BASE_URL, ALGO_PATH, and auth header format per your platform
3const functions = require('firebase-functions');
4const axios = require('axios');
5
6exports.algorithmiaProxy = functions.https.onRequest(async (req, res) => {
7  res.set('Access-Control-Allow-Origin', '*');
8  res.set('Access-Control-Allow-Methods', 'POST, OPTIONS');
9  res.set('Access-Control-Allow-Headers', 'Content-Type');
10  if (req.method === 'OPTIONS') { res.status(204).send(''); return; }
11
12  const apiKey = functions.config().algo.key;
13  const baseUrl = functions.config().algo.baseurl;   // e.g. https://your-cluster.algorithmia.com
14  const algoPath = functions.config().algo.path;     // e.g. /api/v1/algo/owner/AlgoName/1.0.0
15
16  // For legacy Algorithmia: 'Simple {key}' | For DataRobot: 'Bearer {key}'
17  const authScheme = functions.config().algo.authscheme || 'Simple'; // 'Simple' or 'Bearer'
18
19  try {
20    const response = await axios.post(
21      `${baseUrl}${algoPath}`,
22      req.body,
23      {
24        headers: {
25          'Authorization': `${authScheme} ${apiKey}`,
26          'Content-Type': 'application/json',
27        },
28      }
29    );
30    res.json(response.data);
31  } catch (err) {
32    res.status(err.response?.status || 500).json({ error: err.message });
33  }
34});

Open FlutterFlow and click API Calls in the left navigation panel. Click + Add and choose Create API Group. Name it Algorithmia (or DataRobot, or a more specific name like ImageClassifier if you are only calling one algorithm). Set the Base URL to your Cloud Function HTTPS trigger URL — for example https://us-central1-YOUR-PROJECT.cloudfunctions.net/algorithmiaProxy. Do not enter the Algorithmia cluster URL or DataRobot URL here — the Cloud Function handles that routing internally. Inside the group, click + Add to create an API Call. Name it RunInference (or something that matches your algorithm's purpose, like ClassifyImage or PredictDemand). Set the method to POST. Leave the path empty — the Cloud Function's own endpoint logic determines the algorithm URL. For the body, set the type to JSON. The body shape depends on what your algorithm expects as input. For many Algorithmia algorithms, the input is a simple value or object; for example, a text classification algorithm might expect: { "text": "{{ inputText }}" } For image inputs, you typically encode the image as a base64 string using a Custom Action before calling the API, then pass it in the body: { "image_base64": "{{ imageData }}" } Add the appropriate variables in the Variables tab. You do not need to add any Authorization header to the FlutterFlow API Call — the proxy injects it.

1// Example API Call body templates (adjust to your algorithm's input spec)
2
3// For text classification:
4{ "text": "{{ inputText }}" }
5
6// For image classification (image sent as base64):
7{ "image_base64": "{{ imageData }}" }
8
9// For a DataRobot tabular prediction:
10{
11  "datarobot-key": "{{ datarobotKey }}",
12  "data": [
13    { "feature1": "{{ val1 }}", "feature2": "{{ val2 }}" }
14  ]
15}

Click the Response & Test tab inside the RunInference API Call. Enter sample values in the input variables — for example, a short text string for a text classification algorithm. Click Send Test Request. If the proxy is configured correctly, you will receive a JSON response. For legacy Algorithmia, the response is wrapped in an envelope: { "result": "positive", "metadata": { "content_type": "text", "duration": 0.045 } } For DataRobot, the prediction format is specific to your model type and will look different — consult your DataRobot documentation for the exact response structure. For Algorithmia, click Generate JSON Paths from Response. The critical path is $.result — name it predictionResult and set the type to String (or Dynamic if the result is a number or object). Also generate $.metadata.duration as durationMs (Double) if you want to display processing time. If the test returns 401: the API key is wrong or the auth scheme is incorrect — check your Cloud Function config and confirm with your account team whether to use Simple or Bearer. If the test returns 404: the algorithm path is wrong — double-check the full path including version number. If the test returns 500 from the proxy itself: check Cloud Function logs in the Firebase Console for the specific error.

With the API Call tested and JSON paths generated, connect it to your FlutterFlow UI. The exact UI depends on your algorithm's purpose, but here is the pattern for a text classification screen: Add a Column to your screen containing a TextField for the input text, a Classify button, a Text widget for the prediction result, and a CircularProgressIndicator visible only when isLoading is true. Create Page State variables: inputText (String), predictionResult (String), isLoading (Boolean). For the Classify button's Action Flow: 1. Update Page State: set isLoading to true. 2. Backend/API Call: select Algorithmia → RunInference; set inputText to the TextField value. 3. On Success: Update Page State to set predictionResult from the predictionResult JSON path; set isLoading to false. 4. On Error: show a Snack Bar with an error message; reset isLoading to false. Set the prediction Text widget's value to predictionResult Page State and add conditional styling if the prediction is a categorical label (for example, green text for 'positive', red for 'negative'). For image classification, the flow is slightly more complex: add a Custom Action before the API Call that accesses the device camera or gallery (using the image_picker package), encodes the selected image to base64, and stores it in a Page State variable. That base64 string is then passed as the imageData variable in the RunInference API Call body.

Before publishing your FlutterFlow app, add error handling for the most common failure scenarios and test on the target platforms. Error branches to add in your Action Flow: • 401 Unauthorized: the API key is wrong or the auth scheme (Simple vs Bearer) does not match your platform — check your Cloud Function config and confirm with your account team. • 404 Not Found: the algorithm path or model URL is incorrect — verify the full path including version number. • 429 Too Many Requests: you have hit your algorithm's rate limit or your account quota — show a try again later message and do not auto-retry immediately. • 500 from the proxy: check Cloud Function logs for the Algorithmia or DataRobot error; common causes include malformed input JSON or algorithm-side exceptions. For web builds, the Cloud Function's Access-Control-Allow-Origin: * header allows browser requests to the proxy. Direct calls from FlutterFlow to your Algorithmia cluster URL or app.datarobot.com would fail with XMLHttpRequest error due to CORS — always route through the proxy. For mobile builds (iOS/Android), CORS is not enforced, but the proxy is still required to keep the API key off the device. Test on a real device rather than just FlutterFlow's web Test Mode if you are using Custom Actions for image encoding — those run on device and may behave differently in the preview than in a real build. The DataRobot acquisition means Algorithmia's product direction is evolving — if your cluster or account setup changes, update the base URL and API key in your Cloud Function config rather than in FlutterFlow. If you need help navigating the platform ambiguity or setting up the proxy, RapidDev builds FlutterFlow AI integrations every week — free scoping call at rapidevelopers.com/contact.