Automating Document Summarization with the Manus AI API and Fastio

According to industry research from the Forbes Technology Council, unstructured data comprises between 80% and 90% of all digital information generated by modern enterprises [Forbes Tech Council 2022]. The sheer volume of this unorganized content represents a massive operational bottleneck for digital teams. Relying on humans to open, read, and write summaries of thousands of files is slow, expensive, and error-prone.

While traditional language model APIs can generate text summaries from simple string prompts, they fall short when processing complex, multi-page PDFs, scanned invoices, or financial reports that exceed local context windows. Developers require autonomous systems that can fetch documents from a secure repository, execute multi-step analysis, and write structured findings back to shared databases. The Manus AI document summarization API provides this capability by exposing an autonomous agentic interface that programmatically manages document processing tasks, while Fastio offers a secure collaborative workspace where humans and agents co-edit the results.

The diagram below illustrates the programmatic flow of documents and summaries through the integrated system:

sequenceDiagram
    autonumber
    participant Script as Developer Script
    participant Fastio as Fastio Workspace
    participant Manus as Manus API v2
    
    Fastio->>Script: Trigger webhook (file.created event)
    Script->>Fastio: Download file content via API
    Script->>Manus: Staging request (file.upload)
    Manus-->>Script: Return file_id & upload_url
    Script->>Manus: Upload binary payload to S3 URL
    Script->>Manus: Trigger task (task.create) with file_id
    Manus-->>Script: Return task_id (asynchronous execution)
    loop Poll Status
        Script->>Manus: Get task state (task.get)
        Manus-->>Script: Return status (processing or completed)
    end
    Script->>Fastio: Write summary back to Collaborative Note

To summarize files programmatically with the Manus API v2, developers must follow a two-step process: upload the document to generate a persistent reference identifier, and then submit a task that instructs the agent to analyze that file. This message-based pipeline replaces the deprecated v1 endpoints, providing a clean separation between file ingestion and execution. Because Manus acts as an autonomous agent rather than a simple text predictor, it requires the file to be staged in its environment before it can apply tools like web browsing, python execution, or code editors.

For files up to 512 MB, developers can upload content directly using the file.upload endpoint. For public assets under 20 MB, you can alternatively pass a direct URL or inline base64 data. To upload a local file programmatically, you first send a request to obtain a presigned S3 upload URL, write the binary file content to that URL, and then capture the returned identifier.

Here is a complete Python script demonstrating how to prepare a file for the Manus API v2:

import os
import requests

def upload_to_manus(file_path, api_key):
    upload_url = "https://api.manus.im/v2/file.upload"
    headers = {
        "x-manus-api-key": api_key,
        "Content-Type": "application/json"
    }
    filename = os.path.basename(file_path)
    payload = {"filename": filename}
    
    response = requests.post(upload_url, json=payload, headers=headers)
    response.raise_for_status()
    data = response.json()
    
    file_id = data.get("file_id")
    s3_upload_url = data.get("upload_url")
    
    with open(file_path, "rb") as f:
        upload_response = requests.put(
            s3_upload_url, 
            data=f, 
            headers={"Content-Type": "application/octet-stream"}
        )
        upload_response.raise_for_status()
        
    return file_id

Once the upload is complete, the file is securely cached in the Manus environment. The returned identifier can now be attached to any number of task prompts, allowing you to run multiple summarization runs with different agent instructions without re-uploading the original document.

While uploading files directly to Manus works well for one-off operations, production systems require a more persistent, collaborative layer. Storing business documents in temporary local directories or raw cloud buckets like AWS S3 or Google Drive leads to operational silos. Humans cannot easily inspect what the agent is reading, and version histories are difficult to maintain across multiple concurrent runs. This is where Fastio provides a unified workspace designed for human-agent collaboration.

Instead of raw object storage, Fastio organizes documents into shared workspaces where humans use a web interface and agents connect programmatically via the Fastio API or the Model Context Protocol (MCP) server. When you upload a file to a Fastio workspace, the platform automatically enables its built-in AI capabilities for semantic search, full-text retrieval, and Retrieval-Augmented Generation (RAG) queries with precise page-level citations.

This structure allows agents to work on the same file context as humans. Rather than downloading files to a local server to run a script, developers can point their scripts to the Fastio file system. For example, a webhook in Fastio can notify a developer's application whenever a new PDF contract is dropped into a specific folder. The script catches the event, fetches the file securely from Fastio, and uploads it to the Manus AI document summarization API. The original file remains safe in Fastio, complete with per-file version history and an append-only audit log that tracks who accessed the file, when, and why.

For structured data extraction, developers can use Fastio Metadata Views to turn workspace files into a live, queryable database. While Intelligence Mode handles semantic search and summaries, Metadata Views extract specific columns like counterparties, renewal dates, or invoice totals. You can define these fields in plain English, and the AI Suggested Schema extracts them into a spreadsheet-like grid, making the data programmatically accessible. Learn more about how to set up extraction in the document data extraction product page.

With the file uploaded and the storage layer configured, you can trigger the summarization task. The Manus API v2 uses a message-based payload structure that accepts an array of content blocks. This design lets you mix text instructions with file references in a single request.

Because document analysis is a complex task that requires the agent to plan, read, and verify its output, the Manus API v2 executes tasks asynchronously. When you submit a task creation request to the task.create endpoint, the API immediately returns a unique task identifier. Your application must then poll the task.get endpoint to monitor the agent's progress and retrieve the final summary once the status transitions to completed.

The following Python script illustrates how to initiate the task and poll for the summarization results:

import time
import requests

def summarize_document(file_id, api_key, prompt):
    url = "https://api.manus.im/v2/task.create"
    headers = {
        "x-manus-api-key": api_key,
        "Content-Type": "application/json"
    }
    
    payload = {
        "title": "Automated Document Summary",
        "agent_profile": "manus-1.6",
        "message": {
            "content": [
                {
                    "type": "text",
                    "text": prompt
                },
                {
                    "type": "file_id",
                    "file_id": file_id
                }
            ]
        },
        "interactive_mode": False
    }
    
    response = requests.post(url, json=payload, headers=headers)
    response.raise_for_status()
    task_data = response.json()
    task_id = task_data.get("task_id")
    
    status_url = f"https://api.manus.im/v2/task.get?task_id={task_id}"
    while True:
        status_response = requests.get(status_url, headers=headers)
        status_response.raise_for_status()
        status_data = status_response.json()
        
        status = status_data.get("status")
        print(f"Task status: {status}")
        
        if status == "completed":
            messages = status_data.get("messages", [])
            if messages:
                return messages[-1].get("content")
            break
        elif status in ["failed", "cancelled"]:
            raise Exception(f"Manus task failed or was cancelled with status: {status}")
            
        time.sleep(10)

In production systems, polling can consume excessive CPU cycles and network bandwidth. If you expect to run dozens of summarization tasks concurrently, we recommend configuring webhook listeners. The Manus API can post a callback payload directly to your application server the moment a task finishes, allowing you to run reactive code without active polling loops.

Store, summarize, and collaborate on your documents in one workspace

Set up secure shared workspaces for your human teams and AI agents. Use our consolidated Model Context Protocol tools, auto-index files for RAG search, and write summaries back to live co-edited notes. Starts with a 14-day free trial.

Start 14-Day Trial

After the Manus agent completes the summarization task, the final step is writing the summary back to your team workspace. In Fastio, both humans and agents are treated as first-class editors. Instead of sending the summary text over email or Slack, the agent can write the summary directly to a Fastio Collaborative Note. These notes support real-time co-editing, meaning an agent can write a draft summary and a human editor can refine it in the same editor window.

Writing summaries directly to Collaborative Notes ensures that the agent's output is immediately indexed for search. If a human colleague queries the workspace later using semantic search, Fastio can retrieve the summary and cite the Collaborative Note as the source. Alternatively, the agent can write the summary back to a customized text field in a Fastio Metadata View, storing the data as a structured spreadsheet row next to the original PDF contract or invoice.

When setting up your organization, Fastio offers clear billing plans that scale with your usage. Rather than charging per user seat, Fastio charges based on the exact storage, bandwidth, and AI operations you consume. Pricing starts at the Starter tier for $29 per month, which includes 1 TB of storage and 300,000 operations credits. For larger teams, the Business tier is available at $99 per month with 10 TB of storage and 1,200,000 credits, while the Growth tier costs $299 per month for 50 TB of storage and 4,500,000 credits.

Every new organization can get started with a 14-day free trial, which requires a credit card to activate. If you are developing an integration for a client, you can sign up as an agent for free, build the workspaces and webhooks, and then trigger an ownership transfer. This transfers the entire workspace to the client, allowing them to enter their credit card and activate the paid subscription while you retain admin credentials to monitor the system.