Upload API documentation

import { uploadFile } from 'https://api.rapidfile.cc/sdk.js';

const input = document.querySelector('input[type=file]');
input.addEventListener('change', async () => {
  const file = await uploadFile(input.files[0], {
    getUpload: '/api/upload', // your endpoint that calls POST /v1/uploads
    onProgress: ({ percent }) => console.log(`${percent.toFixed(0)}%`),
  });
  console.log(file.url); // https://cdn.rapidfile.cc/<id>/<name>
});

Authorization: Bearer rk_live_…

{
  "file": {
    "id": "Xy7Kq2Lm9P",
    "appId": "app_9fK2mQ",
    "name": "cat.jpg",
    "size": 48213,
    "type": "image/jpeg",
    "status": "uploading",
    "acl": "public",
    "url": "https://cdn.rapidfile.cc/Xy7Kq2Lm9P/cat.jpg",
    "customId": null,
    "metadata": { "userId": "42" },
    "createdAt": 1792300000000
  },
  "upload": {
    "method": "PUT",
    "url": "https://api.rapidfile.cc/v1/upload/<signed-token>",
    "expiresAt": 1792303600000
  }
}

{
  "file": { "id": "Bq4Wn8Rt2Z", "name": "talk.mp4", "size": 2147483648, "status": "uploading", "...": "..." },
  "upload": {
    "method": "MULTIPART",
    "partSize": 67108864,
    "partCount": 32,
    "partUrl": "https://api.rapidfile.cc/v1/upload/<signed-token>/{n}",
    "completeUrl": "https://api.rapidfile.cc/v1/upload/<signed-token>/complete",
    "expiresAt": 1792303600000
  }
}

const res = await fetch(upload.url, { method: 'PUT', body: file });
const { file: ready } = await res.json(); // ready.status === 'ready'

{
  "file": {
    "id": "Xy7Kq2Lm9P",
    "appId": "app_9fK2mQ",
    "name": "cat.jpg",
    "size": 48213,
    "type": "image/jpeg",
    "status": "ready",
    "acl": "public",
    "url": "https://cdn.rapidfile.cc/Xy7Kq2Lm9P/cat.jpg",
    "customId": "avatar-42",
    "metadata": { "userId": "42" },
    "createdAt": 1792300000000
  }
}

POST upload.completeUrl
Content-Type: application/json

{ "parts": [ { "partNumber": 1, "etag": "…" }, { "partNumber": 2, "etag": "…" } ] }

// Without the SDK: upload a MULTIPART response yourself
const { upload } = created; // the JSON from POST /v1/uploads
const parts = [];
for (let n = 1; n <= upload.partCount; n++) {
  const start = (n - 1) * upload.partSize;
  const chunk = picked.slice(start, Math.min(picked.size, start + upload.partSize));
  const res = await fetch(upload.partUrl.replace('{n}', n), { method: 'PUT', body: chunk });
  const { etag } = await res.json();
  parts.push({ partNumber: n, etag });
}
const done = await fetch(upload.completeUrl, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ parts }),
});
const { file } = await done.json(); // status: "ready"

curl -o src/lib/rapidfile-sdk.js https://api.rapidfile.cc/sdk.js

import { uploadFile } from 'https://api.rapidfile.cc/sdk.js';

const input = document.querySelector('input[type=file]');
input.addEventListener('change', async () => {
  const file = await uploadFile(input.files[0], {
    getUpload: '/api/upload', // your endpoint that calls POST /v1/uploads
    onProgress: ({ percent }) => console.log(`${percent.toFixed(0)}%`),
  });
  console.log(file.url); // https://cdn.rapidfile.cc/<id>/<name>
});

const controller = new AbortController();
cancelButton.onclick = () => controller.abort();

try {
  const files = await uploadFiles(input.files, {
    getUpload: (f) => fetch('/api/upload', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'X-CSRF-Token': csrf },
      body: JSON.stringify({ name: f.name, size: f.size, type: f.type }),
    }).then((r) => r.json()),
    onFileComplete: (file, i) => console.log('done', i, file.url),
    signal: controller.signal,
  });
} catch (err) {
  if (err.name === 'AbortError') console.log('cancelled');
  else console.error(err.status, err.code, err.message); // UploadError
}

export type ApiFile = {
  id: string; appId: string; name: string; size: number; type: string;
  status: 'uploading' | 'ready'; acl: 'public' | 'private'; url: string | null;
  customId: string | null; metadata: Record<string, unknown> | null; createdAt: number;
};
export type Progress = { loaded: number; total: number; percent: number };
export type UploadOptions = {
  getUpload: string | ((file: File) => Promise<unknown>);
  onProgress?: (p: Progress) => void;
  signal?: AbortSignal;
  concurrency?: number;
  retries?: number;
};
export function uploadFile(file: File, opts: UploadOptions): Promise<ApiFile>;
export function uploadFiles(
  files: FileList | File[],
  opts: UploadOptions & { parallelFiles?: number; onFileComplete?: (file: ApiFile, index: number) => void },
): Promise<ApiFile[]>;
export class UploadError extends Error { status: number; code: string }

curl "https://api.rapidfile.cc/v1/files?limit=50" -H "Authorization: Bearer $RAPIDFILE_SECRET_KEY"

{
  "data": [ { "id": "Xy7Kq2Lm9P", "name": "cat.jpg", "status": "ready", "...": "..." } ],
  "nextCursor": "eyJjIjoxNzkyMzAwMDAwMDAwfQ"
}

curl -X DELETE https://api.rapidfile.cc/v1/files/Xy7Kq2Lm9P -H "Authorization: Bearer $RAPIDFILE_SECRET_KEY"

curl https://api.rapidfile.cc/v1/files/Xy7Kq2Lm9P/signed-url \
  -H "Authorization: Bearer $RAPIDFILE_SECRET_KEY" \
  -H "Content-Type: application/json" \
  -d '{"expiresIn":3600}'

{ "url": "https://cdn.rapidfile.cc/Xy7Kq2Lm9P/contract.pdf?…signature…", "expiresAt": 1792303600000 }

{
  "plan": "free",
  "storageBytes": 734003200,
  "storageLimit": 2147483648,
  "requestsToday": 1840,
  "requestsLimit": 100000,
  "maxFileBytes": 536870912,
  "apps": 1,
  "appLimit": 3
}

POST /webhooks/rapidfile
Content-Type: application/json
Rapidfile-Signature: t=1792300042,v1=5f2b8c...e91a

{
  "type": "file.uploaded",
  "data": {
    "id": "Xy7Kq2Lm9P",
    "appId": "app_9fK2mQ",
    "name": "cat.jpg",
    "size": 48213,
    "type": "image/jpeg",
    "status": "ready",
    "acl": "public",
    "url": "https://cdn.rapidfile.cc/Xy7Kq2Lm9P/cat.jpg",
    "customId": "avatar-42",
    "metadata": { "userId": "42" },
    "createdAt": 1792300000000
  },
  "createdAt": 1792300042000
}

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "upload_file",
    "arguments": { "name": "notes.md", "content": "# Meeting notes\n…", "type": "text/markdown" }
  }
}

claude mcp add --transport http rapidfile https://rapidfile.cc/mcp

{ "error": "unauthorized", "message": "Missing or invalid API key." }

// app/api/upload/route.ts: runs on your server, so the secret key stays private
import { auth } from '@/lib/auth'; // your own session check

export async function POST(req: Request) {
  const user = await auth(req);
  if (!user) return Response.json({ error: 'unauthorized' }, { status: 401 });

  const { name, size, type } = await req.json();
  const res = await fetch('https://api.rapidfile.cc/v1/uploads', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.RAPIDFILE_SECRET_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ name, size, type, metadata: { userId: user.id } }),
  });
  return Response.json(await res.json(), { status: res.status });
}

// app/upload/page.tsx
'use client';
import { useState } from 'react';
import { uploadFile } from '@/lib/rapidfile-sdk'; // copy of https://api.rapidfile.cc/sdk.js

export default function UploadPage() {
  const [percent, setPercent] = useState(0);
  const [url, setUrl] = useState('');
  return (
    <div>
      <input
        type="file"
        onChange={async (e) => {
          const picked = e.target.files?.[0];
          if (!picked) return;
          const file = await uploadFile(picked, {
            getUpload: '/api/upload',
            onProgress: (p) => setPercent(Math.round(p.percent)),
          });
          setUrl(file.url);
        }}
      />
      <progress max={100} value={percent} />
      {url && <a href={url}>{url}</a>}
    </div>
  );
}

// app/api/webhooks/rapidfile/route.ts
import { verifyRapidfileSignature } from '@/lib/rapidfile-webhook'; // the Node function above

export async function POST(req: Request) {
  const raw = Buffer.from(await req.arrayBuffer());
  const ok = verifyRapidfileSignature(raw, req.headers.get('rapidfile-signature'), process.env.RAPIDFILE_WEBHOOK_SECRET!);
  if (!ok) return new Response('bad signature', { status: 400 });
  const event = JSON.parse(raw.toString('utf8'));
  // event.type: 'file.uploaded' | 'file.deleted', event.data: ApiFile
  return new Response('ok');
}

// server.js: Express creates the upload, the browser sends the bytes
import express from 'express';

const app = express();
app.use(express.json());

app.post('/api/upload', requireUser, async (req, res) => {
  const { name, size, type } = req.body;
  const r = await fetch('https://api.rapidfile.cc/v1/uploads', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.RAPIDFILE_SECRET_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ name, size, type, metadata: { userId: req.user.id } }),
  });
  res.status(r.status).json(await r.json());
});

app.listen(3000);

import { uploadFile } from 'https://api.rapidfile.cc/sdk.js';

const input = document.querySelector('input[type=file]');
input.addEventListener('change', async () => {
  const file = await uploadFile(input.files[0], {
    getUpload: '/api/upload', // your endpoint that calls POST /v1/uploads
    onProgress: ({ percent }) => console.log(`${percent.toFixed(0)}%`),
  });
  console.log(file.url); // https://cdn.rapidfile.cc/<id>/<name>
});

// src/routes/api/upload/+server.ts
import { json, error } from '@sveltejs/kit';
import { RAPIDFILE_SECRET_KEY } from '$env/static/private';

export async function POST({ request, locals }) {
  if (!locals.user) error(401, 'Sign in first');
  const { name, size, type } = await request.json();
  const res = await fetch('https://api.rapidfile.cc/v1/uploads', {
    method: 'POST',
    headers: { Authorization: `Bearer ${RAPIDFILE_SECRET_KEY}`, 'Content-Type': 'application/json' },
    body: JSON.stringify({ name, size, type, metadata: { userId: locals.user.id } }),
  });
  return json(await res.json(), { status: res.status });
}

<!-- src/routes/upload/+page.svelte -->
<script>
  import { uploadFile } from '$lib/rapidfile-sdk.js'; // copy of https://api.rapidfile.cc/sdk.js
  let percent = 0;
  let url = '';
  async function onChange(e) {
    const file = await uploadFile(e.currentTarget.files[0], {
      getUpload: '/api/upload',
      onProgress: (p) => (percent = Math.round(p.percent)),
    });
    url = file.url;
  }
</script>

<input type="file" on:change={onChange} />
<progress max="100" value={percent}></progress>
{#if url}<a href={url}>{url}</a>{/if}

<!doctype html>
<input type="file" id="pick" multiple>
<progress id="bar" max="100" value="0"></progress>
<ul id="out"></ul>

<script type="module">
  import { uploadFiles } from 'https://api.rapidfile.cc/sdk.js';

  document.getElementById('pick').addEventListener('change', async (e) => {
    const files = await uploadFiles(e.target.files, {
      getUpload: '/api/upload', // any backend that calls POST /v1/uploads
      onProgress: ({ percent }) => (document.getElementById('bar').value = percent),
    });
    for (const f of files) {
      const li = document.createElement('li');
      li.textContent = f.url;
      document.getElementById('out').append(li);
    }
  });
</script>

import os, requests
from flask import Flask, request

app = Flask(__name__)

@app.post("/api/upload")
def create_upload():
    body = request.get_json()
    if body["size"] > 50 * 1024 * 1024:
        return {"error": "too_large", "message": "Max 50 MB"}, 413
    r = requests.post(
        "https://api.rapidfile.cc/v1/uploads",
        headers={"Authorization": f"Bearer {os.environ['RAPIDFILE_SECRET_KEY']}"},
        json={"name": body["name"], "size": body["size"], "type": body["type"]},
    )
    return r.json(), r.status_code