# Freaking Fast File Drive

> A private file drive with fast links. Public files are served from the closest of 11 regions,
> stream in any player, and carry no download or streaming fees. Files can be up to 2 TB.

Files upload directly to object storage under a presigned policy, so throughput is not bounded by
the API. Private files are shared with time-limited links; public files get a permanent URL.

## For agents

- Connector: `https://mcp.freakingfast.io/mcp`, listed in Claude's connector directory. Streamable HTTP with
  OAuth sign-in. Every tool of the server below but the two image tools, plus complete_upload: its upload_file
  takes a name and size, the client sends the bytes to storage, and complete_upload saves the file. Plus
  share_with_agent, create_standing_order and list_standing_orders, and get_file_request, deliver_file and
  complete_delivery for sending to file requests. Held to what the person allowed: read, organize (nothing made
  public or sent out), share (nothing deleted), or full, across the drive or in one folder.
- Share links: `https://mcp.freakingfast.io/s/abs_...` is a folder or a file someone shared with your AI. Add it as
  a connector, with no sign-in, read only, until it ends. A folder: list_files, search_files, read_file and
  get_download_url, held to it, with paths that start at it. A file: get_file, read_file, search_file and
  get_download_url, for that file alone.
- Request links: a file request (`https://freakingfast.io/requests/<id>`) takes files from an AI too. deliver_file
  sends a file from your environment straight to storage and complete_delivery files it, through the connector, a
  share link, or the request's own address, `https://mcp.freakingfast.io/r/<id>`, which needs no sign-in.
- [Server on your machine](https://www.npmjs.com/package/freaking-fast-mcp): `npx -y freaking-fast-mcp`, with an
  API token that has full access. Its upload_file reads a file from disk. Tools to
  upload, find, organize and share, collect files and feedback from other people, make images, and work on files
  where they're stored: upload_file, get_download_url, read_file, list_files, search_files,
  get_file_views, set_file_visibility, tag_files, move_files, list_collections, create_playlist,
  add_to_playlist, create_gallery, add_to_gallery, create_file_request, list_file_requests,
  close_file_request, generate_image, get_generated_image, set_cover, create_review_link,
  get_review_notes, reply_to_note, resolve_note, import_from_url, delete_files, restore_files,
  get_storage_usage, get_changes, run_job, get_job, stop_job.
- [A2A 1.0 agent](https://freakingfast.io/.well-known/agent-card.json) at `https://mcp.freakingfast.io/a2a`
  (JSON-RPC, `A2A-Version: 1.0`): hand it a task and it does it in the drive with those tools. Skills for
  saving, sharing, finding and organizing, looking at photos, frames and documents, collecting files and
  reviews, making images, and working on files. A task can wait for files, notes, views, an image or a job and
  pick up when they come, and it posts each change to a webhook given as its taskPushNotificationConfig.
- Inside files: once the owner turns on searching inside files in the app, search_files with `query` finds what's
  said in their audio and video, what their pictures and video scenes show, and the text of their documents, by
  meaning and by its words, and answers moments: the file, the second or page, and the passage. read_file returns
  what's said in a track from `at`, and around a video's frame.
- Jobs: run_job works on files where they're stored, so nothing is downloaded: cut, make proxies, convert,
  shrink to a size, reframe, GIFs, burn in captions or a timecode, join, stills, contact sheets, extract audio,
  even out loudness, split at pauses, strip metadata, watermark, make, merge, split and compress PDFs, take pages
  out or turn them into pictures, zip and unzip, caption files from what was said, and checksums. What a job makes
  lands beside the first file, never over it. Jobs count against the plan's monthly job time; run_job with check
  says how long one should take without starting it, and get_job and stop_job check on and stop one.
- [OpenAPI spec](https://freakingfast.io/openapi.yaml): the underlying HTTP API.

## Authentication

The connector signs people in with OAuth 2.1: discovery at
`https://mcp.freakingfast.io/.well-known/oauth-authorization-server`, dynamic client registration or a
published client identity (CIMD), PKCE (S256), and scopes `files:read`, `files:organize`, `files:share`
and `files:full`. The person picks the limits on a consent page, never past the scope the app asked for.

For the server on your machine, set `FREAKING_FAST_API_TOKEN` to an API token with full access, made under
API tokens in the app. It exchanges it for a short-lived session token automatically and re-mints before
expiry. No browser flow, so it works in headless and containerised environments. A token made with limits
only works as a bearer token at the connector.

## Limits

- Maximum file size: 2 TB per file
- Total storage: set by the account's subscription tier
- Presigned upload policies expire 2 days after issue
- Private download links expire 6 hours after issue

## Uploading without the MCP server

Three calls. Get a presigned form from `POST /generate-file-urls`, `POST` the file as
multipart/form-data to the returned `uploadUrl` including every `uploadForm` field verbatim, then
record it with `POST /insert-file`. The final call re-reads the stored object's length and rejects
the insert if it disagrees with the submitted `fileSize`, so send the exact byte count.

Files over 64 MiB can go up in parts instead: `POST /create-multipart-upload`, send each part to its
signed URL, then `POST /complete-multipart-upload` and `POST /insert-file`. Calling create again with the
same `objectKey` resumes an upload that stopped.