How to Integrate Retool with Algorithmia (DataRobot)

Navigate to the Resources tab in your Retool instance and click Add Resource. Select REST API from the resource type list. Name the resource 'Algorithmia API'. In the Base URL field, enter https://api.algorithmia.com/v1. This is Algorithmia's v1 API base. If you are using a private Algorithmia Enterprise instance hosted on your organization's infrastructure, replace this with your organization's custom Algorithmia API URL (e.g., https://algorithmia.yourcompany.com/api). For authentication, Algorithmia uses a Simple API key sent as a Bearer token. In the Authentication section, select Bearer Token from the dropdown. In the Token field, reference a configuration variable: {{ retoolContext.configVars.ALGORITHMIA_API_KEY }}. First, go to Settings → Configuration Variables, create a variable named ALGORITHMIA_API_KEY, paste your 32-character API key, and mark it as Secret. Add a default header: key = Content-Type, value = application/json. This ensures all POST requests to algorithm endpoints are interpreted as JSON. Click Save Changes. Your Algorithmia resource is now configured for both GET queries (browsing algorithms) and POST queries (invoking predictions). If you are migrating to or also using DataRobot, create a second resource named 'DataRobot API' with Base URL https://app.datarobot.com/api/v2 and your DataRobot API token as the Bearer token.

Create queries to browse available algorithms and display their metadata in a catalog view. In your Retool app, open the Code panel and add a new query. Name it searchAlgorithms and select the Algorithmia API resource. Set Method to GET and Path to /algorithms. Add URL parameters: - key = q, value = {{ textInput_search.value }} (search term for algorithm discovery) - key = rows, value = 50 This returns a list of algorithms matching the search term with metadata including name, username, description, version, and pricing information. Create a second query named getAlgorithmDetails. Set Method to GET and Path to /algorithms/{{ table_algorithms.selectedRow.username }}/{{ table_algorithms.selectedRow.algoname }}. This fetches detailed metadata for the algorithm selected in the catalog table, including all available versions, runtime requirements, and documentation. Add a Text Input component named textInput_search connected to the searchAlgorithms query (trigger on change). Add a Table component named table_algorithms bound to {{ searchAlgorithms.data?.results || [] }}. When a row is selected, trigger getAlgorithmDetails to populate a detail panel on the right side of the app. Use a JavaScript transformer on the search results to extract and format the relevant fields for the catalog table view.

1// JavaScript transformer — format algorithm catalog results for Table
2const algorithms = (data.results || []);
3return algorithms.map(algo => {
4  return {
5    name: algo.name || 'N/A',
6    username: algo.username || 'N/A',
7    algoname: algo.algoname || 'N/A',
8    full_path: `${algo.username}/${algo.algoname}`,
9    description: (algo.summary || algo.description || '').substring(0, 100),
10    version: algo.version_info?.semantic_version || 'N/A',
11    language: algo.source?.algoType || 'N/A',
12    cost_credits: algo.cost_factor !== undefined
13      ? `${algo.cost_factor} credits/sec`
14      : 'N/A',
15    visibility: algo.settings?.visibility || 'N/A',
16    label: algo.label || ''
17  };
18});

Create the core inference submission query that lets users invoke an Algorithmia algorithm with custom input data. Add a query named runAlgorithm. Set Method to POST and Path to /algo/{{ textInput_algoPath.value }}/{{ dropdown_version.value || 'latest' }}. For the body, set type to JSON and enter the input payload. The input format depends on the specific algorithm. For most algorithms, it is a JSON object: { 'input': {{ JSON.parse(textArea_input.value) }} }. The actual field names depend on the algorithm's documented input schema. Algorithmia returns prediction results synchronously for most algorithms. The response includes an output field with the prediction, execution_time in seconds, and billing information. For long-running algorithms, the response includes a promise_id for async polling. Add a TextArea component named textArea_input for JSON input entry. Add a Text Input named textInput_algoPath for the algorithm path (e.g., nlp/SentimentAnalysis). Add a Dropdown named dropdown_version for version selection populated from the details query. Add a Submit button that triggers runAlgorithm. On success, display the output in a JSON viewer or formatted Text component: {{ JSON.stringify(runAlgorithm.data?.output, null, 2) }}. Show execution time and credit cost below the output. For RapidDev integrations, adding a structured input form instead of raw JSON input — with labeled fields corresponding to the algorithm's schema — makes the tool accessible to business users who don't understand JSON syntax.

1// JavaScript transformer — format algorithm prediction result for display
2const result = data || {};
3const output = result.output;
4
5// Format output based on type
6let formattedOutput;
7if (typeof output === 'object' && output !== null) {
8  formattedOutput = JSON.stringify(output, null, 2);
9} else if (typeof output === 'number') {
10  formattedOutput = output.toString();
11} else {
12  formattedOutput = String(output || 'No output');
13}
14
15return {
16  output_raw: output,
17  output_formatted: formattedOutput,
18  execution_time_ms: result.metadata?.duration
19    ? (result.metadata.duration * 1000).toFixed(0) + 'ms'
20    : 'N/A',
21  credits_used: result.metadata?.content_type || 'N/A',
22  algorithm_version: result.metadata?.version || 'N/A',
23  status: result.error ? 'Error: ' + result.error : 'Success'
24};

For teams that have migrated or are migrating from Algorithmia to DataRobot, set up a DataRobot resource and build the deployment monitoring panel. Using the DataRobot API resource you created earlier, create a query named getDeployments. Set Method to GET and Path to /deployments. Add URL parameters: - key = limit, value = 100 - key = orderBy, value = createdAt This returns all DataRobot model deployments with their status, prediction server health, and model metadata. Create a second query named getDeploymentAccuracy. Set Method to GET and Path to /deployments/{{ table_deployments.selectedRow.id }}/accuracy. This pulls accuracy metrics for a selected deployment. Create a third query named getDeploymentDrift. Set Method to GET and Path to /deployments/{{ table_deployments.selectedRow.id }}/featureDrift with a time window parameter to check for data drift in production inputs. Add a Table component named table_deployments bound to the deployments query. When a row is selected, trigger both accuracy and drift queries. Display accuracy metrics (log loss, AUC, RMSE depending on model type) in stat components and a drift score chart using Retool's Chart component. For submitting predictions to a DataRobot deployment, create a query named submitPrediction with Method POST and Path /deployments/{{ table_deployments.selectedRow.id }}/predictions. The body contains the feature values formatted according to the deployment's schema.

1// JavaScript transformer — format DataRobot deployments for Table
2const deployments = (data.data || []);
3return deployments.map(dep => {
4  return {
5    id: dep.id,
6    name: dep.label || dep.modelPackage?.name || 'Unnamed',
7    status: dep.status,
8    health: dep.serviceHealth?.status || 'unknown',
9    model_type: dep.model?.type || 'N/A',
10    target: dep.model?.target?.name || 'N/A',
11    accuracy_health: dep.accuracyHealth?.status || 'N/A',
12    drift_health: dep.driftHealth?.status || 'N/A',
13    predictions_last_day: dep.predictionsCount?.lastDay || 0,
14    created_at: dep.createdAt
15      ? new Date(dep.createdAt).toLocaleDateString()
16      : 'N/A'
17  };
18});