Large File Uploads

curl -X POST "https://platform.kodexa-enterprise.com/api/intake/my-org/my-intake/multipart-upload-abort?s3Key=${s3Key}&uploadId=${uploadId}" \
  -H "x-api-key: kit_your-intake-token"

import requests
import os
import math

BASE_URL = "https://platform.kodexa-enterprise.com"
TOKEN = "kit_your-intake-token"
HEADERS = {"x-api-key": TOKEN}
PART_SIZE = 50 * 1024 * 1024  # 50 MB per part

def upload_large_file(org_slug, intake_slug, file_path):
    file_size = os.path.getsize(file_path)
    filename = os.path.basename(file_path)

    if file_size <= 256 * 1024 * 1024:
        # Direct upload for files under 256 MB
        with open(file_path, "rb") as f:
            resp = requests.post(
                f"{BASE_URL}/api/intake/{org_slug}/{intake_slug}",
                headers=HEADERS,
                files={"file": (filename, f)},
            )
        return resp.json()

    # Step 1: Initiate multipart upload
    resp = requests.post(
        f"{BASE_URL}/api/intake/{org_slug}/{intake_slug}/multipart-upload-request",
        headers=HEADERS,
        params={"path": filename, "contentType": "application/octet-stream", "contentLength": file_size},
    )
    resp.raise_for_status()
    init = resp.json()
    s3_key = init["s3Key"]
    upload_id = init["uploadId"]

    # Step 2: Upload parts
    total_parts = math.ceil(file_size / PART_SIZE)
    completed_parts = []

    with open(file_path, "rb") as f:
        for batch_start in range(0, total_parts, 500):
            batch_end = min(batch_start + 500, total_parts)
            part_numbers = list(range(batch_start + 1, batch_end + 1))

            # Get presigned URLs for this batch
            urls_resp = requests.post(
                f"{BASE_URL}/api/intake/{org_slug}/{intake_slug}/multipart-upload-part-urls",
                headers={**HEADERS, "Content-Type": "application/json"},
                params={"s3Key": s3_key, "uploadId": upload_id},
                json=part_numbers,
            )
            urls_resp.raise_for_status()
            part_urls = urls_resp.json()["parts"]

            for part_info in part_urls:
                chunk = f.read(PART_SIZE)
                put_resp = requests.put(part_info["uploadUrl"], data=chunk)
                put_resp.raise_for_status()
                completed_parts.append({
                    "partNumber": part_info["partNumber"],
                    "etag": put_resp.headers["ETag"],
                })
                print(f"  Uploaded part {part_info['partNumber']}/{total_parts}")

    # Step 3: Complete
    complete_resp = requests.post(
        f"{BASE_URL}/api/intake/{org_slug}/{intake_slug}/multipart-upload-complete",
        headers={**HEADERS, "Content-Type": "application/json"},
        params={"s3Key": s3_key, "uploadId": upload_id, "path": filename},
        json={"parts": completed_parts},
    )
    complete_resp.raise_for_status()
    return complete_resp.json()

const BASE_URL = "https://platform.kodexa-enterprise.com";
const TOKEN = "kit_your-intake-token";
const PART_SIZE = 50 * 1024 * 1024; // 50 MB

async function uploadLargeFile(orgSlug: string, intakeSlug: string, file: File) {
  const headers = { "x-api-key": TOKEN };

  if (file.size <= 256 * 1024 * 1024) {
    // Direct upload for files under 256 MB
    const form = new FormData();
    form.append("file", file);
    const resp = await fetch(`${BASE_URL}/api/intake/${orgSlug}/${intakeSlug}`, {
      method: "POST", headers, body: form,
    });
    return resp.json();
  }

  // Step 1: Initiate multipart upload
  const params = new URLSearchParams({
    path: file.name,
    contentType: file.type || "application/octet-stream",
    contentLength: String(file.size),
  });
  const initResp = await fetch(
    `${BASE_URL}/api/intake/${orgSlug}/${intakeSlug}/multipart-upload-request?${params}`,
    { method: "POST", headers },
  );
  const { s3Key, uploadId } = await initResp.json();

  // Step 2: Upload parts
  const totalParts = Math.ceil(file.size / PART_SIZE);
  const completedParts: { partNumber: number; etag: string }[] = [];

  for (let batchStart = 0; batchStart < totalParts; batchStart += 500) {
    const batchEnd = Math.min(batchStart + 500, totalParts);
    const partNumbers = Array.from({ length: batchEnd - batchStart }, (_, i) => batchStart + i + 1);

    const urlParams = new URLSearchParams({ s3Key, uploadId });
    const urlsResp = await fetch(
      `${BASE_URL}/api/intake/${orgSlug}/${intakeSlug}/multipart-upload-part-urls?${urlParams}`,
      { method: "POST", headers: { ...headers, "Content-Type": "application/json" }, body: JSON.stringify(partNumbers) },
    );
    const { parts: partUrls } = await urlsResp.json();

    for (const partInfo of partUrls) {
      const start = (partInfo.partNumber - 1) * PART_SIZE;
      const end = Math.min(start + PART_SIZE, file.size);
      const chunk = file.slice(start, end);

      const putResp = await fetch(partInfo.uploadUrl, { method: "PUT", body: chunk });
      completedParts.push({ partNumber: partInfo.partNumber, etag: putResp.headers.get("ETag")! });
    }
  }

  // Step 3: Complete
  const completeParams = new URLSearchParams({ s3Key, uploadId, path: file.name });
  const completeResp = await fetch(
    `${BASE_URL}/api/intake/${orgSlug}/${intakeSlug}/multipart-upload-complete?${completeParams}`,
    {
      method: "POST",
      headers: { ...headers, "Content-Type": "application/json" },
      body: JSON.stringify({ parts: completedParts }),
    },
  );
  return completeResp.json();
}