JFrog Artifactory

Log in to your JFrog Artifactory instance (for JFrog Cloud: yourcompany.jfrog.io). Click your username in the top-right corner and select 'Edit Profile' or 'User Management.' To generate an API key: scroll to the 'Authentication Settings' section → click 'Generate API Key' (or 'Regenerate API Key' if one already exists) → copy the key immediately. The API key does not expire unless regenerated or revoked, and it is tied to your user account. For more granular, scoped authentication: use 'Access Tokens' instead. Navigate to Administration → Identity and Access → Access Tokens → Generate Token. Set a name (e.g., 'Bubble Integration'), scope (select the repositories you want to access), and optionally an expiry time. Copy the token immediately — access tokens are displayed only once at generation time and cannot be retrieved later. Choose between the two auth methods: API key authentication uses the X-JFrog-Art-Api header (simpler, suitable for most use-cases); access token uses Authorization: Bearer (preferred for scoped, time-limited access). For a read-only Bubble dashboard, the API key method is simpler. For production use with security requirements, access tokens with a 90-day expiry and read-only scope are recommended.

1// Auth method 1: API Key
2// Location: Artifactory → Profile → Authentication Settings → Generate API Key
3// Header: X-JFrog-Art-Api: YOUR_API_KEY
4// Note: API key is persistent until regenerated/revoked
5
6// Auth method 2: Access Token
7// Location: Administration → Identity and Access → Access Tokens → Generate Token
8// Header: Authorization: Bearer YOUR_ACCESS_TOKEN
9// Note: Displayed only ONCE — store immediately
10// Set scope to: 'applied-permissions/user' or specific repo permissions
11// Set expiry: 90 days recommended for production
12
13// JFrog Cloud base URL format (note the required /artifactory segment):
14// https://yourcompany.jfrog.io/artifactory
15
16// Self-hosted base URL format:
17// https://artifactory.internal.company.com/artifactory
18// (must include /artifactory path segment)
19
20// COMMON MISTAKE: Omitting /artifactory from the base URL
21// Without it, all API endpoints return 404
22// Wrong:  https://yourcompany.jfrog.io
23// Right:  https://yourcompany.jfrog.io/artifactory

Open your Bubble app editor → Plugins → API Connector. If the API Connector is not installed, click 'Add plugins,' search for 'API Connector,' and install it (free). Click 'Add another API.' Name this group 'JFrog Artifactory.' In the 'Root URL' field, enter your Artifactory base URL with the /artifactory segment: for JFrog Cloud this is https://yourcompany.jfrog.io/artifactory. Do not add any path beyond /artifactory here — individual calls will append /api/repositories, /api/storageinfo, and so on. Under 'Shared headers across all calls,' add your auth header. If using API key: click 'Add a shared header,' key = 'X-JFrog-Art-Api,' value = your API key, tick 'Private' checkbox. If using access token: key = 'Authorization,' value = 'Bearer YOUR_ACCESS_TOKEN,' tick 'Private' checkbox. Add a second shared header: key = 'Content-Type,' value = 'application/json' (for standard JSON calls — this will be overridden at the call level for the AQL call). The Private checkbox on the auth header ensures the credential stays on Bubble's servers and is never exposed in browser requests. This is the foundation for all Artifactory calls.

1// Bubble API Connector — JFrog Artifactory group configuration
2{
3  "api_group_name": "JFrog Artifactory",
4  "root_url": "https://yourcompany.jfrog.io/artifactory",
5  "shared_headers": [
6    {
7      "key": "X-JFrog-Art-Api",
8      "value": "<private: your-api-key-here>",
9      "private": true,
10      "comment": "Use this for API key auth. Replace with Authorization: Bearer for access token auth."
11    },
12    {
13      "key": "Content-Type",
14      "value": "application/json",
15      "comment": "Default for standard JSON calls. Overridden per-call for AQL (text/plain)."
16    }
17  ]
18}
19
20// Alternative if using Access Token instead of API Key:
21// {
22//   "key": "Authorization",
23//   "value": "Bearer <private: your-access-token>",
24//   "private": true
25// }

Inside the JFrog Artifactory API Connector group, click 'Add call.' Name this call 'List Repositories.' Set method to GET. Endpoint: /api/repositories. Set 'Use as' to 'Data.' You can optionally add a URL parameter 'type' with value 'local' to filter to only local (non-virtual, non-remote) repositories, or leave it empty to retrieve all repository types. Click 'Initialize call.' Bubble makes a real GET request to your Artifactory instance. The response is a JSON array where each element represents a repository with fields: key (the repository name), type (LOCAL, REMOTE, VIRTUAL, FEDERATED), description, packageType (Maven, Docker, npm, pypi, etc.), and url. Bubble detects these fields after initialization. Click 'Save.' This call is the foundation of the Artifactory dashboard — it provides the list of repositories you can display, drill into with storage statistics, or search with AQL. For large Artifactory instances with hundreds of repositories, the response may be large but should be well within Bubble's parsing capacity as it is a flat array without deep nesting.

1// Bubble API Connector — 'List Repositories' call
2{
3  "call_name": "List Repositories",
4  "method": "GET",
5  "endpoint": "/api/repositories",
6  "parameters": [
7    {
8      "key": "type",
9      "value": "local",
10      "comment": "Optional filter: local | remote | virtual. Remove to get all types."
11    }
12  ],
13  "use_as": "Data"
14}
15
16// Artifactory response (array of repository objects):
17// [
18//   {
19//     "key": "docker-local",
20//     "type": "LOCAL",
21//     "description": "Local Docker repository for CI build artifacts",
22//     "url": "https://company.jfrog.io/artifactory/docker-local",
23//     "packageType": "Docker"
24//   },
25//   {
26//     "key": "npm-proxy",
27//     "type": "REMOTE",
28//     "description": "Proxy for npmjs.org",
29//     "url": "https://company.jfrog.io/artifactory/npm-proxy",
30//     "packageType": "Npm"
31//   }
32// ]

This is the most important and most commonly misconfigured step. Click 'Add call.' Name it 'AQL Search.' Set method to POST. Endpoint: /api/search/aql. Now, before configuring the body: add a call-level header (not group-level) to override the Content-Type for this specific call. In the call's headers section, add: key = 'Content-Type,' value = 'text/plain.' This is critical — without it, Bubble sends the group-level 'application/json' Content-Type, and Artifactory returns a 400 error. Next, set the Body Type. In Bubble's API Connector body configuration, find the body type selector and choose 'Raw (text/plain).' The body field should accept free-form text. Enter a sample AQL query as the body value: items.find({"repo":{"$eq":"docker-local"}}).include("name","path","size","modified").sort({"$desc":["modified"]}).limit(25). This is valid AQL that finds the 25 most recently modified items in the docker-local repository. The body should be treated as a dynamic parameter in Bubble so you can pass different AQL queries from workflows. Set 'Use as' to 'Data.' Click 'Initialize call.' If you see a 400 error, the Content-Type or Body Type is not set correctly. If the response returns results, Bubble will detect an outer 'results' array containing artifact objects with name, path, size, modified, and other fields. Click 'Save.'

1// Bubble API Connector — 'AQL Search' call
2// THIS IS THE CRITICAL CONFIGURATION — read carefully
3
4{
5  "call_name": "AQL Search",
6  "method": "POST",
7  "endpoint": "/api/search/aql",
8
9  "call_level_headers": [
10    {
11      "key": "Content-Type",
12      "value": "text/plain",
13      "comment": "REQUIRED: Overrides the group-level application/json header. AQL endpoint ONLY accepts text/plain."
14    }
15  ],
16
17  "body_type": "Raw (text/plain)",
18
19  "body": "items.find({\"repo\":{\"$eq\":\"docker-local\"}}).include(\"name\",\"path\",\"size\",\"modified\").sort({\"$desc\":[\"modified\"]}).limit(25)",
20
21  "use_as": "Data"
22}
23
24// AQL query format (raw text — NOT JSON-encoded):
25// items.find({"repo":{"$eq":"docker-local"}})
26//   .include("name","path","size","modified","created")
27//   .sort({"$desc":["modified"]})
28//   .limit(25)
29
30// Common AQL query examples:
31// Find all Docker image folders in a repo:
32// items.find({"repo":{"$eq":"docker-local"}, "type":{"$eq":"folder"}}).include("name","path","modified").limit(50)
33
34// Find artifacts by file extension:
35// items.find({"repo":{"$eq":"maven-releases"}, "name":{"$match":"*.jar"}}).include("name","size","modified").limit(25)
36
37// Artifactory AQL response structure:
38// {
39//   "results": [
40//     { "repo": "docker-local", "path": "my-image/1.2.3", "name": ".manifest", "size": 0, "modified": "2026-07-09T10:00:00.000Z" },
41//     ...
42//   ],
43//   "range": { "start_pos": 0, "end_pos": 25, "total": 142 }
44// }

Click 'Add call.' Name it 'Get Storage Info.' Set method to GET. Endpoint: /api/storageinfo. Set 'Use as' to 'Data.' No URL parameters needed. Click 'Initialize call.' The /api/storageinfo endpoint returns a large JSON object with a 'repositoriesSummaryList' array, where each element has: repoKey (repository name), repoType (LOCAL, REMOTE, VIRTUAL), usedSpace (human-readable string like '2.63 GB'), foldersCount, filesCount, itemsCount, and percentageOfTotalSize. It also contains a 'fileStoreSummary' object with totalSpace and usedSpace for the entire Artifactory instance. Important: /api/storageinfo can be slow — it calculates storage usage across the entire Artifactory file store, which may take several seconds for large instances. Do not call this endpoint live on every page load. Instead, create a Bubble data type 'ArtifactoryStorage' with fields: repo_key (text), repo_type (text), used_space (text), files_count (number), folders_count (number), last_synced (date). Set up a Scheduled Backend Workflow to call 'Get Storage Info' daily (every 86400 seconds), upsert ArtifactoryStorage records using repo_key as the deduplication key, and serve the dashboard from these cached Bubble database records.

1// Bubble API Connector — 'Get Storage Info' call
2{
3  "call_name": "Get Storage Info",
4  "method": "GET",
5  "endpoint": "/api/storageinfo",
6  "use_as": "Data"
7}
8
9// Artifactory /api/storageinfo response structure:
10// {
11//   "repositoriesSummaryList": [
12//     {
13//       "repoKey": "docker-local",
14//       "repoType": "LOCAL",
15//       "foldersCount": 142,
16//       "filesCount": 891,
17//       "usedSpace": "2.63 GB",
18//       "itemsCount": 1033,
19//       "packageType": "Docker",
20//       "percentageOfTotalSize": "18.2%"
21//     }
22//   ],
23//   "fileStoreSummary": {
24//     "storageType": "filesystem",
25//     "storageDirectory": "/var/opt/jfrog/artifactory/data",
26//     "totalSpace": "500 GB",
27//     "usedSpace": "14.44 GB",
28//     "freeSpace": "485.56 GB"
29//   }
30// }
31
32// Bubble data type: ArtifactoryStorage
33// Fields: repo_key(text), repo_type(text), used_space(text),
34//         files_count(number), folders_count(number), last_synced(date)
35
36// Scheduled Backend Workflow: 'Sync Artifactory Storage'
37// Step 1: Call Artifactory > Get Storage Info
38// Step 2: Schedule API Workflow on result.repositoriesSummaryList
39//   Sub: upsert ArtifactoryStorage where repo_key = current item's repoKey
40// Schedule: every 86400 seconds (daily)

Create a Bubble page named 'artifact-dashboard' or 'devops-storage.' Add a summary section at the top with total storage used across all repositories (a Text element displaying 'Do a search for ArtifactoryStorage:sum of files_count' for total file count), and total repositories count. Add a primary Repeating Group with type ArtifactoryStorage, data source = search for ArtifactoryStorage sorted by used_space descending (note: alphabetical sort, not numeric, due to the string format). Cells display: repo_key as the repository name, a packageType badge (stored from the List Repositories call), used_space string, files_count formatted with commas, and a 'Last synced' date. Add a second section for AQL artifact search: a Text Input for the AQL query, a Dropdown for common queries (pre-loaded with options like 'Latest Docker images,' 'Recent Maven JARs'), and a 'Search' button. On Search button click, call the 'AQL Search' API Connector action with the text input value as the AQL body. Display results in a Repeating Group with artifact name, path, size, and modified date. For a drill-down experience, clicking a repository row in the first repeating group can navigate to a detail page and trigger an AQL query filtered to that specific repository. If your team is building a production artifact management dashboard in Bubble and needs architecture support, RapidDev has worked with engineering teams on similar DevOps tooling — book a free scoping call at rapidevelopers.com/contact.

1// Bubble page: artifact-dashboard
2
3// Summary metrics (at page top):
4// Total repositories: Do a search for ArtifactoryStorage:count
5// Total files:        Do a search for ArtifactoryStorage:sum of files_count
6// Last storage sync:  Do a search for ArtifactoryStorage:first item's last_synced (formatted)
7
8// Primary Repeating Group — Repository List:
9// Type: ArtifactoryStorage
10// Source: Do a search for ArtifactoryStorage, sorted by used_space descending
11// Cells:
12//   repo_key       → Text element (bold)
13//   repo_type      → Badge (LOCAL=blue, REMOTE=gray, VIRTUAL=purple)
14//   used_space     → Text element (right-aligned)
15//   files_count    → Text element, formatted: formatted as #,###
16//   last_synced    → Text element, formatted as 'Updated MMM D'
17
18// AQL Search section:
19// Text Input: placeholder 'Enter AQL query or select preset below'
20// Dropdown: preset queries
21//   Options: ['Latest Docker Images', 'Recent Maven JARs', 'Large Files (>100MB)']
22//   Value templates:
23//     'Latest Docker Images': items.find({"type":{"$eq":"folder"}}).include("name","path","modified").sort({"$desc":["modified"]}).limit(20)
24//     'Recent Maven JARs': items.find({"name":{"$match":"*.jar"}}).include("name","path","size","modified").sort({"$desc":["modified"]}).limit(25)
25
26// AQL results Repeating Group:
27// Workflow: Button click → Call API connector: JFrog Artifactory > AQL Search
28//   body = Text Input's value (or Dropdown's selected template)
29// Type: result of AQL Search's results
30// Cells: name, path, size (formatted as MB), modified date