How to Integrate Retool with Backblaze B2 Cloud Storage

B2's native API access is controlled by application keys with explicit capability grants. Navigate to the Backblaze web console (secure.backblaze.com) and go to App Keys → Add a New Application Key. Set the application key configuration: - Name of Key: 'retool-native-api' (descriptive name for tracking purposes) - Allow access to Bucket(s): All (or select specific buckets for tighter access control) - Type of Access: Read and Write — for a monitoring dashboard, Read Only is sufficient - File name prefix: leave blank for full bucket access - Duration: leave blank for a non-expiring key For the native B2 API, the relevant capabilities are: - listBuckets — allows b2_list_buckets - listFiles — allows b2_list_file_names and b2_list_file_versions - readFiles — allows b2_download_file_by_name and b2_download_file_by_id - writeFiles — allows b2_upload_file (only needed for upload features) - deleteFiles — allows b2_delete_file_version (only needed for delete features) - readBucketEncryption — allows reading SSE configuration - writeBucketLifecycle — allows b2_update_bucket lifecycle settings Click Create New Key. Immediately copy both the applicationKeyId (the long numeric/alphanumeric ID) and the applicationKey (the secret value). The applicationKey is shown only once — if you navigate away without copying it, you must create a new key. Next, add these two values as Retool configuration variables: go to Retool Settings → Configuration Variables. Create B2_KEY_ID with the applicationKeyId value (mark as secret), and B2_APPLICATION_KEY with the applicationKey value (mark as secret).

Create a Retool REST API Resource for the B2 authorization endpoint. Go to Resources tab → Add Resource → REST API: - Name: 'Backblaze B2 Native API' - Base URL: https://api.backblazeb2.com - Authentication: Basic Auth - Username: {{ retoolContext.configVars.B2_KEY_ID }} - Password: {{ retoolContext.configVars.B2_APPLICATION_KEY }} Note: Basic Auth here is only used for the b2_authorize_account call. The base URL is B2's fixed authorization endpoint — subsequent API calls will use a dynamic URL returned by the authorization response. Save the resource. Now create an authorization query in your Retool app. Go to the Code panel, create a new query, select the Backblaze B2 Native API resource: - Method: GET - Path: /b2api/v3/b2_authorize_account This call returns a JSON response containing: - authorizationToken — used as the bearer token for all subsequent B2 API calls - apiInfo.storageApi.apiUrl — the dynamic API URL for your account's storage operations - downloadUrl — base URL for direct file downloads - accountId — your B2 account ID Run this query manually and confirm the response. Store the auth token query as 'b2AuthQuery'. Other queries will reference {{ b2AuthQuery.data.authorizationToken }} and {{ b2AuthQuery.data.apiInfo.storageApi.apiUrl }}. Create a second REST API Resource for authenticated B2 API calls: - Name: 'B2 Storage API' - Base URL: {{ b2AuthQuery.data.apiInfo.storageApi.apiUrl }} (note: this is dynamic) - Authentication: Bearer Token - Token: {{ b2AuthQuery.data.authorizationToken }}

Create a query to list all accessible B2 buckets. In the Code panel, create a new query and select the 'B2 Storage API' resource: - Method: GET - Path: /b2api/v3/b2_list_buckets - URL parameter: accountId → {{ b2AuthQuery.data.accountId }} The response returns a buckets array where each bucket includes bucketId, bucketName, bucketType (allPublic, allPrivate, snapshot), and bucketInfo (custom metadata). Bind a Select component to this data with displayField set to bucketName and valueField set to bucketId. Create a file listing query using b2_list_file_names: - Method: GET - Path: /b2api/v3/b2_list_file_names - URL parameter: bucketId → {{ bucketSelect.value }} - URL parameter: maxFileCount → 500 - URL parameter: prefix → {{ prefixInput.value || '' }} - URL parameter: delimiter → / (for folder-like navigation) The response includes a files array where each file has: fileId, fileName, size, contentType, uploadTimestamp, and fileInfo (custom metadata dictionary). Add a JavaScript transformer to format sizes and timestamps, then bind a Table component to {{ fileListQuery.data }}. Enable 'Run automatically when inputs change' on the file list query so it refreshes when the bucket selection changes. Add a Text Input component for prefix filtering to enable folder-like navigation within the bucket.

1// Transformer for b2_list_file_names response
2const files = data.files || [];
3return files.map(file => {
4  const sizeBytes = file.contentLength || 0;
5  let sizeDisplay;
6  if (sizeBytes >= 1073741824) {
7    sizeDisplay = (sizeBytes / 1073741824).toFixed(2) + ' GB';
8  } else if (sizeBytes >= 1048576) {
9    sizeDisplay = (sizeBytes / 1048576).toFixed(2) + ' MB';
10  } else {
11    sizeDisplay = (sizeBytes / 1024).toFixed(1) + ' KB';
12  }
13  return {
14    file_id: file.fileId,
15    file_name: file.fileName,
16    short_name: file.fileName.split('/').pop(),
17    content_type: file.contentType || '',
18    size_bytes: sizeBytes,
19    size_display: sizeDisplay,
20    upload_time: file.uploadTimestamp
21      ? new Date(file.uploadTimestamp).toLocaleString()
22      : '',
23    action: file.action, // 'upload', 'hide', or 'folder'
24    sha1: file.contentSha1 || ''
25  };
26});

B2's native API provides b2_get_download_authorization for generating time-limited, prefix-scoped download tokens — a B2-specific feature not available through the S3-compatible API. This is essential for sharing private content without making entire buckets public. Create a query to generate download authorization: - Method: POST - Path: /b2api/v3/b2_get_download_authorization - Body type: JSON - Body: ```json { "bucketId": "{{ bucketSelect.value }}", "fileNamePrefix": "{{ fileListTable.selectedRow?.file_name || '' }}", "validDurationInSeconds": "{{ tokenDurationSelect.value }}" } ``` Add a Select component for token duration with options: 3600 (1 hour), 86400 (24 hours), 604800 (7 days). Wire it to the validDurationInSeconds parameter. The response returns an authorizationToken specifically for download operations. Construct the authorized download URL in a JavaScript query: ``` const baseUrl = b2AuthQuery.data.downloadUrl; const bucket = bucketsQuery.data.buckets.find(b => b.bucketId === bucketSelect.value)?.bucketName; const fileName = encodeURIComponent(fileListTable.selectedRow.file_name); const token = downloadAuthQuery.data.authorizationToken; return `${baseUrl}/file/${bucket}/${fileName}?Authorization=${token}`; ``` Display the generated URL in a Text Input component (set to read-only) with a Copy to Clipboard button. Add a Container component that shows the token expiration time: new Date(Date.now() + tokenDurationSelect.value * 1000).toLocaleString().

1// JavaScript query to construct authorized download URL
2// Runs after downloadAuthQuery succeeds
3const baseUrl = b2AuthQuery.data.downloadUrl;
4const selectedBucketId = bucketSelect.value;
5const buckets = bucketsQuery.data.buckets || [];
6const bucket = buckets.find(b => b.bucketId === selectedBucketId);
7if (!bucket) return { url: '', error: 'Bucket not found' };
8const selectedFile = fileListTable.selectedRow;
9if (!selectedFile) return { url: '', error: 'No file selected' };
10const encodedName = selectedFile.file_name.split('/').map(encodeURIComponent).join('/');
11const token = downloadAuthQuery.data.authorizationToken;
12const expiresAt = new Date(Date.now() + (tokenDurationSelect.value * 1000)).toLocaleString();
13return {
14  url: `${baseUrl}/file/${bucket.bucketName}/${encodedName}?Authorization=${token}`,
15  expires_at: expiresAt,
16  file_name: selectedFile.file_name,
17  duration_label: tokenDurationSelect.label
18};

Add a bucket detail panel that shows the selected bucket's configuration, including lifecycle rules, server-side encryption settings, and bucket type. Create a query for bucket details: - Method: GET - Path: /b2api/v3/b2_list_buckets - URL parameter: accountId → {{ b2AuthQuery.data.accountId }} - URL parameter: bucketId → {{ bucketSelect.value }} - URL parameter: bucketTypes → allPrivate,allPublic,snapshot The response includes the full bucket object with lifecycleRules array, defaultServerSideEncryption, and bucketInfo. Display lifecycle rules in an editable table showing daysFromHidingToDeleting and daysFromUploadingToHiding for each rule. For storage usage, B2's b2_list_buckets response includes a filesAndVersionsCount and storageBytesUsed per bucket — use this for a storage summary without needing to enumerate all files. Create a summary transformer that reads from the buckets list to display total storage across all buckets. Drag a Stats Summary section at the top of the dashboard with Statistic components showing: - Total buckets - Total storage (sum of storageBytesUsed in GB) - Estimated monthly cost ($0.006 × total GB) - Total files (sum of filesAndVersionsCount) For complex integrations involving multiple B2 buckets, custom download authorization workflows, and automated lifecycle management via Retool Workflows, RapidDev's team can help architect and build your Retool solution.

1// Storage summary transformer — reads from b2_list_buckets response
2// data.buckets is the array of all bucket objects
3const buckets = data.buckets || [];
4const totalBytes = buckets.reduce((sum, b) => sum + (b.storageBytesUsed || 0), 0);
5const totalFiles = buckets.reduce((sum, b) => sum + (b.filesAndVersionsCount || 0), 0);
6const totalGB = totalBytes / (1024 * 1024 * 1024);
7const monthlyCost = totalGB * 0.006;
8return {
9  bucket_count: buckets.length,
10  total_files: totalFiles.toLocaleString(),
11  total_storage_gb: totalGB.toFixed(3),
12  total_storage_display: totalGB >= 1 ? totalGB.toFixed(2) + ' GB' : (totalBytes / 1048576).toFixed(1) + ' MB',
13  monthly_cost_estimate: '$' + monthlyCost.toFixed(4),
14  buckets_summary: buckets.map(b => ({
15    name: b.bucketName,
16    type: b.bucketType,
17    files: b.filesAndVersionsCount || 0,
18    size_gb: ((b.storageBytesUsed || 0) / 1073741824).toFixed(4)
19  }))
20};