# Algorithmia

- Tool: Bubble
- Difficulty: Intermediate
- Time required: 30–45 minutes
- Last updated: July 2026

## TL;DR

Algorithmia's standalone marketplace was discontinued after DataRobot's 2021 acquisition — algorithmia.com no longer accepts new registrations. This guide covers the two current paths: (1) legacy Algorithmia enterprise endpoints for teams migrated to DataRobot, and (2) DataRobot's REST API for model deployments. Both use Bearer-style auth in Bubble's API Connector — but Algorithmia uses 'Simple [key]' as the prefix, not 'Bearer', which requires a custom header instead of Bubble's built-in auth type.

## Algorithmia is deprecated — here's the DataRobot path

If you found this page searching for 'Algorithmia Bubble integration', the first thing to know is that algorithmia.com's public marketplace no longer accepts new user registrations. The platform was acquired by DataRobot in 2021 and folded into DataRobot's enterprise MLOps offering. If you have no existing Algorithmia or DataRobot contract, the best alternative for accessible AI APIs in Bubble is DeepAI (for single-task endpoints) or OpenAI GPT (for language tasks). If your organization does have a DataRobot enterprise account or a legacy Algorithmia enterprise endpoint, this guide covers how to connect both to Bubble. The key technical distinction: Algorithmia uses Authorization: Simple [api_key] while DataRobot uses Authorization: Bearer [token] — both are handled as custom Private headers in Bubble's API Connector.

## Before you start

- An existing DataRobot enterprise account OR access to a legacy Algorithmia enterprise endpoint (algorithmia.com marketplace is not accepting new signups)
- An API key from your DataRobot account settings OR your legacy Algorithmia API key
- For DataRobot: knowledge of your DataRobot instance URL (either app.datarobot.com or your organization's custom enterprise domain)
- For Algorithmia: knowledge of the specific algorithm endpoint path you're calling (/v1/algo/{owner}/{algorithm_name})
- Bubble app on any plan including Free; Bubble's API Connector plugin installed (Plugins tab → Add plugins → search 'API Connector')

## Step-by-step guide

### 1. Confirm which path you're on: Algorithmia legacy or DataRobot REST API

Before touching Bubble, identify which endpoint you're calling. This determines the auth header format and base URL.

Path A — Legacy Algorithmia enterprise endpoint: If your DataRobot contact gave you access to endpoints at api.algorithmia.com/v1/algo/..., you're on the Algorithmia path. Your API key will be an Algorithmia-format key, and the Authorization header uses 'Simple [key]' (not Bearer).

Path B — DataRobot REST API: If you're logging into app.datarobot.com (or a custom domain like companyname.datarobot.com) and accessing Models/Deployments there, you're on the DataRobot path. Your API token is in DataRobot → Account → Developer Tools, and the Authorization header uses standard 'Bearer [token]'.

If you have neither and are searching for a way to use Algorithmia for the first time: algorithmia.com's public marketplace no longer accepts new registrations. Instead, consider DeepAI (single-task AI endpoints, free tier available) or OpenAI GPT (language model tasks). Both integrate with Bubble in a similar API Connector pattern.

Once you've confirmed your path, collect your API key or token and note the base URL you'll be calling.

**Expected result:** You know whether you're using a legacy Algorithmia endpoint or the DataRobot REST API, and you have the correct API key or token.

### 2. Configure the API Connector for Algorithmia legacy endpoints (Path A)

If you're on the Algorithmia legacy path, follow this step. If you're using DataRobot REST API, skip to Step 3.

In your Bubble editor, click Plugins tab → API Connector → Add another API. Name it 'Algorithmia'. Set Authentication to 'None or self-handled' — this is critical. Do NOT use Bubble's 'Bearer Token' authentication type, because Algorithmia uses 'Simple [key]' not 'Bearer [key]', and Bubble's auth type would add the wrong prefix.

Under Shared headers, add a header with key Authorization and value: Simple (with a space) — then click the token icon to add a Private parameter named algo_key. Set the default value to your Algorithmia API key. The full header value at runtime becomes 'Simple your_actual_key_here'.

Set the Base URL to https://api.algorithmia.com.

Click 'Add a new call'. Name it 'runAlgorithm'. Set method to POST and path to /v1/algo/{owner}/{algorithm_name}/{version} — replace the path segments with your specific algorithm. The request body is whatever input your algorithm accepts (JSON, plain text, or binary — note that Bubble's API Connector only supports JSON and text bodies, not binary/raw bytes).

For the initialize call, provide a real input your algorithm will accept. Algorithmia's response wraps results in { "result": ..., "metadata": { "duration": 0.5, "content_type": "json" } }. Bubble will parse both result and metadata fields.

```
{
  "api_name": "Algorithmia",
  "base_url": "https://api.algorithmia.com",
  "authentication": "None or self-handled",
  "shared_headers": {
    "Authorization": "Simple <algo_key: PRIVATE>"
  },
  "call": {
    "method": "POST",
    "path": "/v1/algo/{owner}/{algorithm_name}/{version}",
    "body": "<your_algorithm_input>"
  }
}
```

**Expected result:** Algorithmia API group is configured with 'Simple [key]' as a custom Private Authorization header. The runAlgorithm call is initialized successfully.

### 3. Configure the API Connector for DataRobot REST API (Path B)

If you're using DataRobot's REST API directly, follow this step. Skip if you're on the Algorithmia legacy path.

In your Bubble editor, click Plugins tab → API Connector → Add another API. Name it 'DataRobot'. You can use Bubble's built-in authentication here since DataRobot uses standard Bearer tokens.

In the Authentication field, select 'Bearer token (shared headers)'. A header row will appear with 'Authorization' pre-filled. Click the token icon and add a Private parameter named datarobot_token. Set the default value to your DataRobot API token from Account → Developer Tools.

Set the Base URL to your DataRobot instance URL — either https://app.datarobot.com/api/v2 for cloud customers, or your organization's custom enterprise domain if on a private instance. Confirm the correct URL with your DataRobot admin if unsure.

To get your API token in DataRobot: log in to DataRobot → click your profile icon top right → Developer Tools → API Token. Copy the token.

Add a first call to test connectivity: name it 'listDeployments', method GET, path /deployments. Initialize with no parameters — this should return a list of your organization's active deployments in a JSON array.

```
{
  "api_name": "DataRobot",
  "base_url": "https://app.datarobot.com/api/v2",
  "authentication": "Bearer Token",
  "shared_headers": {
    "Authorization": "Bearer <datarobot_token: PRIVATE>"
  },
  "call": {
    "method": "GET",
    "path": "/deployments"
  }
}
```

**Expected result:** DataRobot API group is configured with standard Bearer auth. The listDeployments GET call initializes successfully and Bubble can parse the deployment list response.

### 4. Create a prediction submission workflow in Bubble

With your API group configured, add a prediction call. This step covers both paths since the workflow pattern is similar.

For DataRobot: click 'Add a new call' in the DataRobot group. Name it 'submitPrediction'. Set method to POST and path to /deployments/{deployment_id}/predictions — you'll need the specific deployment ID from the listDeployments response (it's in each deployment object as 'id'). You can either hardcode the deployment ID for a single-model app or make it a dynamic parameter.

The prediction request body for DataRobot follows this format:
{
  "data": [
    { "feature1": "<value1>", "feature2": "<value2>" }
  ]
}

For Algorithmia: the call body format is whatever the specific algorithm expects — check the algorithm documentation.

Design a Bubble page with Input elements for each model feature, a Submit button, and a Text element for the prediction result. In the button's workflow: call the prediction API, then use a 'Set state' action to store the result in a Custom State for display.

For DataRobot, the prediction result is typically in the response at data[0].prediction or similar — check the actual response after initialization to find the exact path. Bubble's API Connector initialize call will show you the parsed response structure.

For Algorithmia, the result is in the 'result' field of the response object.

```
{
  "method": "POST",
  "url": "https://app.datarobot.com/api/v2/deployments/{deployment_id}/predictions",
  "headers": {
    "Authorization": "Bearer <private: datarobot_token>",
    "Content-Type": "application/json"
  },
  "body": {
    "data": [
      {
        "feature1": "<dynamic: value1>",
        "feature2": "<dynamic: value2>"
      }
    ]
  }
}
```

**Expected result:** The prediction call is configured and initialized. Submitting model input from a Bubble form returns a prediction score that can be displayed or stored in the Bubble database.

### 5. Parse the prediction response and display results in Bubble

After the initialize call succeeds, Bubble knows the structure of the response. Now wire the prediction result to a user-visible element.

For Algorithmia responses: the result field contains your algorithm's output. If the algorithm returns a JSON object, Bubble will show sub-fields. If it returns a number or string, 'result' itself is the value. Add a Text element with content set to 'Result of step X's result'.

For DataRobot responses: prediction data is typically in a 'data' array. Individual prediction values may be at 'data[0].prediction' or similar — verify by checking the parsed response in Bubble after initialization. DataRobot may also include a 'predictionExplanations' array for models with explainability enabled.

For displaying confidence scores or probabilities: if your model returns class probabilities (e.g., 0.85 for positive, 0.15 for negative), format the number in Bubble using ':formatted as 0%' on the Text element to show it as '85%'.

For saving predictions to the Bubble database: after the API call step, add a 'Create a new Thing' or 'Make changes to a Thing' step. Map the prediction result to a Number field on a 'PredictionResult' data type. Include the input features and a timestamp so you can review what was submitted and when.

Add privacy rules (Data tab → Privacy) to any PredictionResult records: restrict reads to the user who created the record, especially if inputs include sensitive business data. RapidDev's team has helped enterprise clients connect DataRobot to Bubble for internal ML tooling — if you need support mapping a complex response schema, reach out at rapidevelopers.com/contact.

**Expected result:** Prediction results display correctly in the Bubble UI. Results are stored in the database with input features and timestamps for future reference.

### 6. Handle algorithm-specific input formats and add error workflows

Both Algorithmia and DataRobot integrations have model-specific input format requirements. This step covers validation and error handling.

For Algorithmia: some algorithms accept only specific data types — plain text, JSON arrays, nested objects. The algorithm documentation specifies the expected input. If your algorithm doesn't accept JSON (e.g., it expects raw bytes for image processing), Bubble's JSON body type won't work and you'll need to find an algorithm that accepts JSON or URL-based image inputs instead.

For DataRobot: the 'data' array's feature object must match the exact feature names used when the model was trained. A misspelled feature name or missing required feature will return a 422 Unprocessable Entity error. Get the exact feature names from DataRobot → Deployments → your deployment → Features.

Add an error handling workflow for all prediction calls: in Bubble's workflow editor, under your API call step, there's an 'Add an action' for error handling. Add a 'Show message' or 'Display data' action that catches the error and shows a user-friendly message like 'Prediction unavailable — please try again.' Also log the error to a database record so you can debug later.

Common error codes to handle: 400 (invalid input format), 401 (API key/token invalid or expired), 422 (feature mismatch), 500/503 (model or infrastructure error). Display different messages for auth errors vs input errors vs infrastructure errors.

**Expected result:** Input validation prevents malformed requests from reaching the API. Error handling workflows surface friendly messages for users when predictions fail, and errors are logged for developer debugging.

## Best practices

- For Algorithmia endpoints: always use a custom shared header with 'Simple [key]' format — never use Bubble's Bearer Token auth type, which adds the wrong 'Bearer' prefix.
- Mark all API keys and tokens as Private in Bubble's API Connector to keep them server-side and out of browser network requests.
- Confirm your DataRobot instance URL with your admin before building — using app.datarobot.com for a private enterprise deployment will fail silently with auth errors.
- Get the exact model feature names from DataRobot's deployment details page before building the prediction call in Bubble — feature name mismatches return 422 errors that are hard to diagnose without knowing the expected schema.
- Add explicit error handling workflows for all prediction calls that distinguish between auth errors (401/403), input errors (400/422), and infrastructure errors (500/503) — users need different messages for each.
- Cache prediction results in the Bubble database when the same inputs are submitted repeatedly — this reduces API calls and DataRobot/Algorithmia costs for high-volume use cases.
- Set Bubble privacy rules on any PredictionResult data type to restrict reads to the record creator — prediction inputs often contain sensitive business or personal data.
- If you have no existing Algorithmia or DataRobot contract, use DeepAI or OpenAI GPT instead — both are accessible without enterprise agreements and integrate with Bubble in a simpler setup pattern.

## Use cases

### DataRobot prediction portal for business analysts

Enterprise teams with models deployed on DataRobot want non-technical business analysts to submit prediction requests through a clean Bubble form, without accessing DataRobot's technical interface. Bubble surfaces input fields matching the model's feature schema, sends the prediction call, and displays the result score.

Prompt example:

```
Build a Bubble page with input fields for customer age, account tenure, and product category. Add a Predict button that POSTs these values to our DataRobot deployment's predictions endpoint and shows the returned prediction score and confidence level in a results panel.
```

### Legacy Algorithmia algorithm calls for migrated enterprise teams

Organizations that were DataRobot enterprise customers before the acquisition may still have internal algorithm endpoints accessible via Algorithmia-style REST URLs. Bubble can call these endpoints to run specific algorithms — such as anomaly detection, NLP pipelines, or data transformation tasks — from a Bubble app UI.

Prompt example:

```
Create a Bubble workflow that takes text input from a form field and POSTs it to our Algorithmia NLP algorithm endpoint at api.algorithmia.com. Display the result object's output field in a Bubble Text element and log the processing duration from the metadata object.
```

### Model monitoring dashboard with DataRobot management API

MLOps teams want to surface model performance metrics and deployment health in a Bubble dashboard for stakeholders who don't use DataRobot directly. Bubble pulls deployment status and accuracy scores from DataRobot's management API and displays them in Repeating Groups with visual indicators.

Prompt example:

```
Create a Bubble Repeating Group that lists all DataRobot deployments from our account. Show each deployment's name, status, and model accuracy metric. Add a filter dropdown for deployment status (Active/Inactive/Failed). Refresh the list every 5 minutes using a scheduled workflow.
```

## Troubleshooting

### Algorithmia API call returns 401 Unauthorized

Cause: The Authorization header is using 'Bearer' prefix instead of 'Simple', or Bubble's built-in Bearer Token auth type was used instead of a custom header.

Solution: In the API Connector, confirm Authentication is set to 'None or self-handled'. Check the shared Authorization header — the value must start with 'Simple ' (capital S, followed by a space) before the Private parameter. If you used Bubble's Bearer Token auth type, delete it and manually add the Authorization header as a custom shared header with 'Simple [key]' format.

### DataRobot returns 401 or 403 even with a valid-looking token

Cause: The DataRobot instance URL doesn't match the organization's actual deployment, or the API token has expired or been revoked.

Solution: Confirm the base URL with your DataRobot admin — enterprise customers may have a custom domain (e.g., yourcompany.datarobot.com) rather than app.datarobot.com. In DataRobot, go to your profile → Developer Tools and regenerate the API token if needed. Update the Private parameter in Bubble's API Connector with the new token and re-initialize the call.

### There was an issue setting up your call during initialize

Cause: The initialize call requires a real, valid request that returns a successful response. For Algorithmia, the algorithm may not accept the test input format. For DataRobot, feature names in the request body may not match the trained model.

Solution: For Algorithmia: check the algorithm's documentation for expected input format and provide a matching test value. For DataRobot: use the exact feature names from the model's training schema — get them from DataRobot → Deployments → your deployment → Features tab. A single misspelled feature name causes a 422 and Bubble cannot parse the response.

### Cannot find Algorithmia account or access algorithmia.com

Cause: The standalone algorithmia.com marketplace is discontinued for new users following DataRobot's acquisition in 2021.

Solution: If you don't have an existing DataRobot enterprise contract that includes Algorithmia endpoint access, you cannot create a new Algorithmia account. Consider DeepAI (deepai.org) as an alternative for pre-built AI task endpoints, or OpenAI GPT for language model capabilities — both work with Bubble's API Connector with simpler setup than Algorithmia.

### DataRobot 422 Unprocessable Entity on prediction submission

Cause: The feature names in the request body don't match the model's expected input schema, or required features are missing.

Solution: In DataRobot, navigate to your deployment → Overview → Features tab to see the exact feature names the model was trained on. Update the Bubble API Connector call body to use these exact names (case-sensitive). Also check that all required features are included — DataRobot may require features that weren't in your initial test.

## Frequently asked questions

### Is Algorithmia still available? Can I sign up for a new account?

No. Algorithmia's standalone public marketplace at algorithmia.com is discontinued and no longer accepts new user registrations following DataRobot's 2021 acquisition. Existing enterprise customers were migrated to DataRobot's MLOps platform. If you're starting fresh without an existing Algorithmia or DataRobot contract, use DeepAI or OpenAI GPT instead — both work well with Bubble's API Connector.

### Why does Algorithmia use 'Simple [key]' instead of 'Bearer [key]' for authentication?

Algorithmia implemented a custom authentication scheme using 'Simple' as the auth prefix rather than the OAuth2 standard 'Bearer'. This was a design choice specific to their platform. The practical consequence in Bubble is that you cannot use Bubble's built-in Bearer Token auth type — you must add the Authorization header manually as a custom shared header with 'Simple ' as the hardcoded prefix, followed by the key as a Private parameter.

### How do I find my DataRobot deployment ID to use in prediction API calls?

In DataRobot, navigate to Deployments in the left sidebar and click on your deployment. The deployment ID is visible in the browser URL: app.datarobot.com/deployments/{deployment_id}/overview. Copy this ID. You can also retrieve it programmatically by calling GET /api/v2/deployments from Bubble — the response includes an 'id' field for each deployment.

### What happens if my Algorithmia algorithm expects binary input, not JSON?

Bubble's API Connector supports JSON and text body types — it cannot send raw binary data (byte arrays or binary file streams). If your algorithm requires binary input (e.g., raw image bytes), this integration path won't work. Look for an algorithm version that accepts image URLs or base64-encoded strings in a JSON body instead, which Bubble can send.

### Do I need a paid Bubble plan to connect to Algorithmia or DataRobot?

No. The basic prediction call setup (API Connector with custom headers) works on Bubble's Free plan. You only need a paid Bubble plan if you add Backend Workflows for token management or scheduled workflows for polling. The core integration — calling a prediction endpoint from a button click — works on all Bubble plans.

### What's the best alternative to Algorithmia if I don't have a DataRobot contract?

For pre-built AI task endpoints (image generation, text summarization, sentiment): DeepAI at deepai.org has a free tier and requires only one custom header. For language model capabilities (text generation, Q&A, summarization): OpenAI GPT at platform.openai.com has transparent public pricing. For custom trained models: Google Vertex AI or Azure Machine Learning both provide managed inference endpoints accessible to individual cloud customers without enterprise contracts.

---

Source: https://www.rapidevelopers.com/bubble-integrations/algorithmia
© RapidDev — https://www.rapidevelopers.com/bubble-integrations/algorithmia