How to Integrate Fast.io SDK with Android Kotlin

Android is the world's biggest mobile platform. Cloud storage for your app needs an API that handles large files, streams data fast, and works with Kotlin coroutines. Fast.io provides this through a REST API.

The API uses JSON responses and standard HTTP authentication. You can add it to Android easily with Retrofit or OkHttp. Unlike other storage services, Fast.io adds AI features. Files in workspaces get indexed automatically for semantic search. Query them with natural language via the RAG chat interface.

For apps with agents, Fast.io fits well. The free tier offers multiple storage and multiple monthly credits for most backends. It supports chunked uploads up to multiple, key for media like photos, videos, and docs on mobile.

Helpful references: Fast.io Workspaces, Fast.io Collaboration, and Fast.io AI.

Start API calls by authenticating your Android app with Fast.io. API keys work best for mobile apps.

Make a key in the Fast.io dashboard or via API. Use a scoped key for your app. Add it to the Authorization header:

val client = OkHttpClient.Builder()
    .addInterceptor { chain ->
        val request = chain.request().newBuilder()
            .addHeader("Authorization", "Bearer YOUR_API_KEY")
            .build()
        chain.proceed(request)
    }
    .build()

For agent accounts, set agent=true when creating. You get multiple storage and multiple credits, no credit card needed. Accounts last forever, great for mobile storage.

For apps with user logins, use OAuth multiple.0 PKCE. It avoids sharing API keys.

Give Your AI Agents Persistent Storage

Get started with 50GB free storage, 5,000 monthly credits, and 251 MCP tools. No credit card required.

Sign Up Free

File uploads happen often in storage integrations. Fast.io handles small files under multiple in one request and larger ones with chunks. Both fit Kotlin coroutines.

Send small files as multipart form data with metadata:

suspend fun uploadSmallFile(
    workspaceId: String,
    file: File,
    folderId: String = "root"
): UploadResult {
    val requestBody = MultipartBody.Builder()
        .setType(MultipartBody.FORM)
        .addFormDataPart("name", file.name)
        .addFormDataPart("size", file.length().toString())
        .addFormDataPart("action", "create")
        .addFormDataPart("instance_id", workspaceId)
        .addFormDataPart("folder_id", folderId)
        .addFormDataPart("chunk", file.name, 
            file.asRequestBody("application/octet-stream".toMediaType()))
        .build()
    
    return api.upload(requestBody)
}

For big files over multiple, create a session, upload up to multiple chunks at once, assemble, and check completion. This works for videos, images, and docs users share on mobile.

Workspaces organize files in Fast.io. Your app can create them, add folders, and set permissions. Good for apps sorting user content into projects.

Post to workspaces endpoint:

suspend fun createWorkspace(
    orgId: String,
    name: String,
    folderName: String
): Workspace {
    val body = FormBody.Builder()
        .add("name", name)
        .add("folder_name", folderName)
        .build()
    return api.createWorkspace(orgId, body)
}

Folders use flat structure, but relative paths mimic hierarchy. List contents with pagination. Set roles like owner or guest for access control.

Fast.io indexes files with AI automatically. Turn on Intelligence Mode for semantic search by meaning. Query from your app via chat endpoint.

Enable mode, then ask questions with citations:

suspend fun queryWorkspace(
    workspaceId: String,
    question: String
): ChatResponse {
    val body = FormBody.Builder()
        .add("prompt", question)
        .build()
    return api.chat(workspaceId, body)
}

Responses cite files for easy UI display. Useful for knowledge bases or docs. Fast.io has multiple MCP tools; API calls match them for files, workspaces, shares, and AI.

Mobile networks drop often. Users start video uploads on cell, switch to WiFi. Fast.io chunks let uploads resume.

Check session for done chunks:

suspend fun getUploadStatus(uploadId: String): UploadSession {
    return api.getUploadDetails(uploadId)
}

See chunks map, upload missing ones, then assemble. Key for mobile where users expect uploads to pick up after restarts.

Use Send for uploads, Receive for collection, Exchange for folders. Create shares with passwords or dates:

suspend fun createShare(
    orgId: String,
    title: String,
    shareType: String,
    options: ShareOptions
): Share {
    val body = FormBody.Builder()
        .add("title", title)
        .add("type", shareType)
        .add("password", options.password ?: "")
        .add("expires_at", options.expirationDate ?: "")
        .build()
    return api.createShare(orgId, body)
}

Apps can collect photos from subs or share assets with clients. Links work in browsers, no app needed.

Skip polling. Set webhooks for file changes. Get POSTs with details to update app state or send notifications.

Good for syncing local files. Respond right away for better UX.