How to Create Branded Client Portals with Fast.io API

What Are Branded Client Portals?: creating branded client portals with fast api

The Fast.io API lets developers build branded, secure client portals for delivering agent-generated files to human users. A client portal is a dedicated digital space where organizations share documents, media assets, and data with external stakeholders. Moving this process to an API lets engineering teams automate file distribution from start to finish. This automation replaces manual email attachments with a programmatic system. Instead of asking employees to drag files into a generic cloud folder, your application creates a unique, white-labeled environment for every new project. This approach saves time and presents a polished image to the end user right from the start.

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

Why Build Portals Programmatically?

Manual file sharing introduces friction and security risks. When team members have to manually create folders, configure permissions, and send email links, the chance of human error increases. Programmatic portal creation solves these issues by standardizing the delivery mechanism. You define the structure, branding, and access controls once in your code. Every portal generated through the API then follows those exact rules without deviation.

Automating your client portals also creates branded handoff links instantly. When your system finishes compiling a monthly report or rendering a video file, it can immediately generate a Fast.io share link and send it via email or Slack. The client receives an interface featuring your company logo and colors, rather than a generic third-party screen. This automation helps high-volume operations where speed and consistency matter most.

The Fast.io Agent-to-Human Handoff

Most traditional cloud storage platforms are designed for human-to-human collaboration. They assume a person is sitting at a keyboard, managing files and sending links. Fast.io introduces an agent-to-human handoff feature via branded shares. In this model, an AI agent or automated script acts as the primary operator. The agent creates the organization, builds the workspaces, uploads the necessary assets, and then transfers ownership to a human client.

This workflow works well for AI-driven applications. If you build an AI research assistant, for instance, the agent can compile its findings into a structured Fast.io workspace. The agent then generates a branded portal and transfers the final product to the user. The agent retains administrative access to update the files later if new data becomes available. The human client receives a secure link to access their organized, branded workspace. This pattern connects machine-generated content directly to human consumption.

Prerequisites and the Free Agent Tier

Before writing your first API request, review the platform limits and available resources. Fast.io offers a free agent tier designed for developers building automated workflows. This tier provides 50GB of free storage and a 1GB maximum file size limit. You also receive multiple monthly operations credits to handle API requests and portal generation. You can sign up and start building right away, as no credit card is required to access these features.

Developers also gain access to 251 MCP tools via Streamable HTTP and SSE. Every action available in the web interface has a corresponding programmatic endpoint. To get started, create a free account and generate an API key from your developer settings. Treat this API key with high security. Store it as an environment variable in your application and never commit it directly to your source code repository.

Authenticating Your API Requests

All requests to the Fast.io API require authentication using a Bearer token in the authorization header. This token ensures that only authorized applications can create or modify your workspaces. You can generate a long-lived API token from the developer console in your dashboard.

Here is a basic example of how to authenticate a request using Python. This script sets up the base headers you will use for all later calls to the platform.

import requests
import os

FASTIO_API_KEY = os.getenv('FASTIO_API_KEY')
BASE_URL = 'https://api.fast.io/api'

headers = {
    'Authorization': f'Bearer {FASTIO_API_KEY}',
    'Content-Type': 'application/json'
}

response = requests.get(f'{BASE_URL}/workspaces', headers=headers)
print(response.json())

If your token is valid, the API will return a list of your current workspaces. If you receive a multiple Unauthorized error, verify that your token is correct and has not expired.

Creating a Workspace Programmatically

A workspace is the primary container for your client portal. It holds all the files, folders, and metadata associated with a specific project or client. When you create a workspace via the API, you can define its name, description, and initial settings.

To create a new workspace, send a POST request to the /workspaces endpoint. The payload should include the name of the project and any relevant descriptive tags. Fast.io workspaces feature Intelligence Mode, which indexes uploaded files and makes them queryable through built-in RAG capabilities. You can enable this feature during workspace creation to ensure uploaded content is immediately searchable by meaning rather than just filename.

{
  "name": "Acme Corp Holiday Campaign",
  "description": "Final assets and reports for the holiday marketing push",
  "intelligence_mode": true
}

Once the workspace is created, the API returns a unique workspace ID. You must store this ID in your database, as you will need it to upload files and generate the final share link.

Uploading Files and Content Imports

With your workspace created, the next step is populating it with files. The Fast.io API offers multiple ways to ingest content. For standard file uploads, you can use the multipart upload endpoints. This method works well for files generated directly by your application, such as rendered PDF reports or compiled code packages.

The API also includes a URL Import capability. If your assets are currently hosted on another platform like Google Drive, OneDrive, Box, or Dropbox, you do not need to download them locally before uploading them to Fast.io. You can pass the source URLs to the API, and Fast.io will pull the files directly from the external provider without using any local I/O on your servers. This speeds up the portal creation process and reduces the bandwidth requirements for your application infrastructure.

Generating the Branded Share Link

This is the final step in the process. Once your workspace contains the necessary files, you need to create the client portal interface. To build a branded client portal via the Fast.io API, send a POST request to the /shares endpoint with your workspace ID and branding configuration. The required API payload includes the workspace_id, share_type, and a branding object specifying your logo URL and primary color.

Here is the API payload required to create a branded Fast.io share link:

{
  "workspace_id": "ws_abcxyz_demo",
  "share_type": "receive",
  "name": "Holiday Campaign Assets",
  "branding": {
    "logo_url": "https://example.com/logo.png",
    "primary_color": "#4A90E2",
    "hide_fastio_logo": true
  },
  "access_control": {
    "require_email": true,
    "expires_at": "YYYY-MM-DDTHH:MM:SSZ"
  }
}

When you send this request, the API returns a unique, secure URL. This URL serves as the entry point for your client. Because you defined the branding object in the request, the portal will display your logo and use your primary brand color for all buttons and interface elements. The client only sees your branding, ensuring a white-labeled experience.

Handling File Structure and Directory Organization

When dealing with complex projects, a flat file structure often falls short. Professional client portals need organized directories to help users locate specific assets quickly. The Fast.io API allows you to create nested folder hierarchies within your workspaces before generating the final share link. Organizing content logically improves the end-user experience and reduces confusion during the handoff process.

To create a folder programmatically, send a POST request to the /folders endpoint. You must specify the parent workspace ID and the desired folder name. If you need to create nested folders, pass the parent folder ID in your request. Once the directory structure is established, include the target folder ID when executing your file upload requests. This programmatic organization ensures every client portal you generate follows a consistent structure, regardless of which automated agent or script created it.

Error Handling and Retry Logic

Strong API integrations must account for network instability and temporary service interruptions. When your application attempts to create a workspace or upload a large file, network timeouts can occasionally occur. Implementing proper error handling and exponential backoff strategies helps your client portal generation processes remain reliable.

When interacting with the Fast.io API, always inspect the HTTP status codes returned by your requests. A multiple Too Many Requests response indicates that you have exceeded your rate limits. In this scenario, your application should pause execution and retry the request after a short delay. For large file uploads, use the platform's chunked upload endpoints. This approach divides large assets into smaller pieces, allowing your system to resume interrupted uploads without restarting the entire process from the beginning. Building these safeguards into your code helps your automated agent-to-human handoff workflows succeed even during network issues.

Managing Permissions and File Locks

Security remains a key component of any client portal. The Fast.io API lets you enforce strict access controls on every share link you generate. In the payload example above, the require_email parameter forces the client to enter their email address before viewing the files. This creates an audit log showing exactly who accessed the portal and when they viewed specific documents.

If you have multiple AI agents or automated scripts interacting with the same workspace simultaneously, you must manage concurrency. The API provides a system of file locks for concurrent multi-agent access. Before an agent modifies a file, it must acquire a lock via the API. Once the lock is secured, no other agent can alter that file until the lock is released. This mechanism prevents data corruption and ensures your client portals always present the most accurate information.

Advanced Implementation: Webhooks for Reactive Workflows

To build smart systems, your application needs to know when clients interact with the portals you create. Polling the API for status updates is inefficient and consumes your monthly operations credits. You should use the platform's webhook integration instead to build reactive workflows.

You can configure webhooks to send HTTP POST requests to your server whenever specific events occur within a workspace. You can set up a listener to notify your application the moment a client downloads a file or leaves a comment on a document, for example. When your server receives this webhook payload, it can trigger automated follow-up actions. Your system could automatically send a thank-you email, notify an account manager in Slack, or update a status field in your CRM software. Webhooks transform your static client portals into interactive, data-driven endpoints.

Implementing OpenClaw for Natural Language Control

If you are building an AI application, interacting with the REST API directly is only one option. Fast.io provides a native integration with OpenClaw, allowing your agents to manage workspaces using natural language commands. You can install the integration via your terminal by running the standard ClawHub installation command.

Once installed, your agent gains access to multiple zero-config tools for file management. Instead of writing complex JSON payloads to create a portal, the agent can state its intent. For example, the agent can determine that a project is complete and automatically issue the commands to create a workspace, apply the client's branding, and generate the final share link. This integration reduces the amount of boilerplate code required to build intelligent file delivery systems.