Browsing Providers

Provider Operations

Providers are storage backends configured through the Elise admin portal. The API exposes read-only access to list and inspect them. For an overview of the API, see the Introduction.

Listing Providers

The list endpoint returns all storage providers accessible to your account, with pagination and optional text filtering. This is your starting point to discover which storage backends are available before browsing their contents.

cURL

curl -s "https://<api-domain>/api/core/providers?page=0&pageSize=20" \
  -H "Authorization: Bearer <your-pat>"

Python (httpx)

from pydantic import BaseModel, Field

class ProviderId(BaseModel):
    id: str
    entity_type: str = Field(alias="entityType")

class ProviderConfig(BaseModel):
    type: str
    bucket_name: str | None = Field(default=None, alias="bucketName")
    region: str | None = None
    container_name: str | None = Field(default=None, alias="containerName")
    site_url: str | None = Field(default=None, alias="siteUrl")

class Provider(BaseModel):
    id: ProviderId
    name: str
    type: str
    system: bool
    config: ProviderConfig | None = None

class ProviderPage(BaseModel):
    data: list[Provider]
    total_pages: int = Field(alias="totalPages")
    total_elements: int = Field(alias="totalElements")
    has_next: bool = Field(alias="hasNext")

response = client.get("/providers", params={"page": 0, "pageSize": 20})
response.raise_for_status()

page = ProviderPage.model_validate(response.json())
for provider in page.data:
    print(f"{provider.id.id}: {provider.name} ({provider.type})")

R

resp <- base_req |>
  req_url_path_append("providers") |>
  req_url_query(page = 0, pageSize = 20) |>
  req_perform()

page <- resp_body_json(resp)

for (provider in page$data) {
  cat(sprintf("%s: %s (%s)\n", provider$id$id, provider$name, provider$type))
}

cat(sprintf("Page 1 of %d (%d total providers)\n", page$totalPages, page$totalElements))

SDK

import asyncio
from biolevate import BiolevateClient

async def main():
    async with BiolevateClient(
        base_url="https://<api-domain>",
        token="<your-pat>",
    ) as client:
        page = await client.providers.list(page=0, page_size=20)
        for provider in page.data:
            print(f"{provider.id.id}: {provider.name} ({provider.type_})")
        print(f"Page 1 of {page.total_pages} ({page.total_elements} total providers)")

asyncio.run(main())

Query Parameters

Parameter	Type	Default	Description
page	integer	0	Page number (0-based)
pageSize	integer	20	Number of items per page
sortBy	string	--	Field to sort by
sortOrder	string	asc	Sort direction (asc or desc)
q	string	--	Text search filter on provider names

Response Structure

{
  "data": [
    {
      "id": { "id": "550e8400-...", "entityType": "PROVIDER" },
      "name": "Research Documents",
      "type": "S3",
      "system": false,
      "config": {
        "type": "S3",
        "bucketName": "research-docs",
        "region": "eu-west-1"
      }
    }
  ],
  "totalPages": 1,
  "totalElements": 3,
  "hasNext": false
}

Getting a Single Provider

Retrieve detailed information about a specific provider by its UUID.

cURL

curl -s "https://<api-domain>/api/core/providers/550e8400-e29b-41d4-a716-446655440000" \
  -H "Authorization: Bearer <your-pat>"

Python (httpx)

provider_id = "550e8400-e29b-41d4-a716-446655440000"

response = client.get(f"/providers/{provider_id}")
response.raise_for_status()

provider = Provider.model_validate(response.json())
print(f"{provider.name}: {provider.type}")
if provider.config:
    print(f"  Bucket: {provider.config.bucket_name}")
    print(f"  Region: {provider.config.region}")

R

provider_id <- "550e8400-e29b-41d4-a716-446655440000"

resp <- base_req |>
  req_url_path_append("providers", provider_id) |>
  req_perform()

provider <- resp_body_json(resp)
cat(sprintf("%s: %s\n", provider$name, provider$type))

SDK

import asyncio
from biolevate import BiolevateClient, NotFoundError

async def main():
    async with BiolevateClient(
        base_url="https://<api-domain>",
        token="<your-pat>",
    ) as client:
        try:
            provider = await client.providers.get("550e8400-e29b-41d4-a716-446655440000")
            print(f"{provider.name}: {provider.type_}")
            print(f"  ID: {provider.id.id}")
        except NotFoundError:
            print("Provider not found")

asyncio.run(main())

Provider Types

Providers can be one of the following storage backend types:

Type	Description
S3	Amazon S3 bucket
AZURE	Azure Blob Storage container
GCS	Google Cloud Storage bucket
SHAREPOINT_ONLINE	SharePoint Online document library
LOCAL	Local file system mount
LEANEAR	Leanear-managed storage
SFTP	SFTP remote file server

Each type exposes different configuration fields. For example, an S3 provider includes bucketName and region, while a SharePoint provider includes siteUrl, documentLibrary, and tenantId.

Secret Redaction

Sensitive fields such as connection strings, access keys, and SAS tokens are never returned by the API. Only structural metadata (bucket names, regions, site URLs) is exposed.

Next Steps

Now that you know which providers are available:

1. Manage provider items to browse, upload, and download files
2. Index files to create EliseFiles and trigger analysis

API Reference

See the Providers endpoints in the API Reference for complete request/response schemas.