File upload

# Initiate
UPLOAD=$(curl -s -X POST "$FILES_BASE/v1/uploads" \
  -H "Authorization: Bearer $ADCLEAR_API_KEY" \
  -H "X-External-User-ID: $USER_ID" \
  -H "Content-Type: application/json" \
  -d '{ "fileName": "ad.pdf", "fileSize": 2048576, "contentType": "application/pdf" }')
UPLOAD_ID=$(echo "$UPLOAD" | jq -r .uploadId)

# Send the bytes (single chunk)
curl -s -X PUT "$FILES_BASE/v1/uploads/$UPLOAD_ID" \
  -H "Authorization: Bearer $ADCLEAR_API_KEY" \
  -H "Content-Type: application/pdf" \
  -H "Content-Range: bytes 0-2048575/2048576" \
  --data-binary @ad.pdf

import { readFile } from "node:fs/promises";
import { basename } from "node:path";

const FILES_BASE = "https://files.adclear.ai";
const API_KEY = process.env.ADCLEAR_API_KEY!;
const auth = { Authorization: `Bearer ${API_KEY}`, "X-External-User-ID": process.env.USER_ID! };

async function upload(filePath: string, contentType = "application/pdf") {
  const file = await readFile(filePath);

  // 1 — initiate
  const init = await fetch(`${FILES_BASE}/v1/uploads`, {
    method: "POST",
    headers: { ...auth, "Content-Type": "application/json" },
    body: JSON.stringify({ fileName: basename(filePath), fileSize: file.byteLength, contentType }),
  });
  if (!init.ok) throw new Error(`Initiate failed (${init.status})`);
  const { uploadId, maxChunkSize } = await init.json();

  // 2 — send chunks
  for (let offset = 0; offset < file.byteLength; ) {
    const end = Math.min(offset + maxChunkSize, file.byteLength) - 1;
    const res = await fetch(`${FILES_BASE}/v1/uploads/${uploadId}`, {
      method: "PUT",
      headers: { ...auth, "Content-Type": contentType,
                 "Content-Range": `bytes ${offset}-${end}/${file.byteLength}` },
      body: file.subarray(offset, end + 1),
    });
    if (!res.ok) throw new Error(`Chunk failed (${res.status})`);
    offset = end + 1;
  }
  return uploadId;
}

import os, requests
from pathlib import Path

FILES_BASE = "https://files.adclear.ai"
auth = {"Authorization": f"Bearer {os.environ['ADCLEAR_API_KEY']}",
        "X-External-User-ID": os.environ["USER_ID"]}

def upload(file_path: str, content_type: str = "application/pdf") -> str:
    data = Path(file_path).read_bytes()

    # 1 — initiate
    init = requests.post(f"{FILES_BASE}/v1/uploads", headers={**auth, "Content-Type": "application/json"},
        json={"fileName": Path(file_path).name, "fileSize": len(data), "contentType": content_type})
    init.raise_for_status()
    upload_id, max_chunk = init.json()["uploadId"], init.json()["maxChunkSize"]

    # 2 — send chunks
    offset = 0
    while offset < len(data):
        end = min(offset + max_chunk, len(data)) - 1
        res = requests.put(f"{FILES_BASE}/v1/uploads/{upload_id}",
            headers={**auth, "Content-Type": content_type,
                     "Content-Range": f"bytes {offset}-{end}/{len(data)}"},
            data=data[offset:end + 1])
        res.raise_for_status()
        offset = end + 1
    return upload_id