How to Create Branded Client Portals with Fastio API

The Fastio 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: Fastio Workspaces, Fastio Collaboration, and Fastio AI.

• How to Set Up AI Agent File Indexing (The Easy Way)Most AI agent file indexing requires complex Python pipelines and vector databases. This guide shows you how to skip...
• How to Extract Metadata from Excel SpreadsheetsExcel spreadsheets store far more than visible cell data. Author names, revision history, external data connections,...
• Top 5 File Sharing Tools for AI WorkflowsOver 60% of AI workflows involve document or file processing. Multi-agent systems can generate hundreds of artifacts...
• How to Extract Metadata from SharePoint DocumentsSharePoint document libraries hold structured metadata across custom columns, content types, and managed metadata term...
• How to Extract Metadata from Docker Container ImagesDocker container images carry structured metadata far beyond the filesystem layers themselves. OCI manifests, image...
• How to Automate File Classification with AI AgentsAI agent file classification automation uses intelligent agents to categorize incoming documents, apply tags, and route...

More on this subject: Agent File and Document Workflows (183 guides)

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 Fastio 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.

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. Fastio 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 Fastio 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.

Build Custom Client Portals Fast

Connect your developer stack to Fastio workspaces with a consolidated MCP toolset and version history. Built for fast api workflows.

Start 14-Day Trial

Before writing your first API request, review the platform limits and available resources. Fastio offers a Business Trial designed for developers building automated workflows. This tier provides generous storage and a generous file size limits 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 a consolidated MCP toolset via Streamable HTTP and SSE. Every action available in the web interface has a corresponding programmatic endpoint. To get started, sign up for a trial 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.

All requests to the Fastio 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/current'

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.

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. Fastio 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.

With your workspace created, the next step is populating it with files. The Fastio 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 Fastio. You can pass the source URLs to the API, and Fastio 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.

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 Fastio 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 Fastio 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.

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 Fastio 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.

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 Fastio 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.

Security remains a key component of any client portal. The Fastio 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 safely. Rather than relying on rigid file locks that cause deadlocks, Fastio uses automatic file version history, granular folder permissions, and an append-only audit log. Every write is preserved as a new version, allowing teams to review changes or restore prior revisions at any time without blocking collaborative pipelines.

To build smart systems, your application needs to know when clients interact with the portals you create. Fastio provides real-time event streaming via its WebSocket events feed as well as an activity feed you can poll for updates.

You can connect a listener to the WebSocket events feed to notify your application the moment a client downloads a file or leaves an anchored comment on a document. When your server receives an event, it can trigger automated follow-up actions. Your system could automatically send an alert or update a status field in your CRM software. Real-time event monitoring transforms static client portals into interactive, data-driven endpoints.

If you are building an AI application, interacting with the REST API directly is only one option. Fastio provides a remote Model Context Protocol (MCP) server at https://mcp.fast.io/mcp, allowing autonomous AI agents to manage workspaces using natural language tools. Agents connect directly via Streamable HTTP or legacy SSE without installing local packages or running custom containers.

Once connected, your agent gains access to a consolidated toolset 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.