File Upload & Storage

curl -X POST https://api.core.today/v1/files/upload-url \
  -H "X-API-Key: cdt_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"filename": "reference_image.png", "folder": "inputs"}'

# Add all upload_fields in order, and add file last
curl -X POST "https://s3.ap-northeast-2.amazonaws.com/files.core.today" \
  -F "Content-Type=image/png" \
  -F "key=aiapi/f04423dfab11/inputs/1765720407215_reference_image.png" \
  -F "x-amz-algorithm=AWS4-HMAC-SHA256" \
  -F "x-amz-credential=ASIA.../20251214/ap-northeast-2/s3/aws4_request" \
  -F "x-amz-date=20251214T120000Z" \
  -F "x-amz-security-token=IQoJb3JpZ2luX2VjEG0a..." \
  -F "policy=eyJleHBpcmF0aW9uIjoiMjAyNS0xMi0xNFQxMzowMDowMFoiLCJjb25kaXRpb25zIjpbey..." \
  -F "x-amz-signature=e6444e667072a27fd5589241803c8abf..." \
  -F "file=@/path/to/reference_image.png"

async function uploadFile(file, apiKey) {
  // 1. Get presigned URL
  const urlResponse = await fetch(
    "https://api.core.today/v1/files/upload-url",
    {
      method: "POST",
      headers: {
        "X-API-Key": apiKey,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({ filename: file.name, folder: "inputs" })
    }
  );
  const { upload_url, upload_fields, file_url } = await urlResponse.json();

  // 2. Upload to S3
  const formData = new FormData();
  Object.entries(upload_fields).forEach(([key, value]) => {
    formData.append(key, value);
  });
  formData.append("file", file); // file must be last!

  await fetch(upload_url, {
    method: "POST",
    body: formData
  });

  // 3. Return the CDN URL (use this in prediction requests)
  return file_url;
}

import requests

def upload_file(filepath, api_key, folder="inputs"):
    filename = filepath.split("/")[-1]

    # 1. Get presigned URL
    url_response = requests.post(
        "https://api.core.today/v1/files/upload-url",
        headers={
            "X-API-Key": api_key,
            "Content-Type": "application/json"
        },
        json={"filename": filename, "folder": folder}
    )
    data = url_response.json()

    # 2. Upload to S3
    with open(filepath, "rb") as f:
        files = {"file": (filename, f)}
        requests.post(
            data["upload_url"],
            data=data["upload_fields"],
            files=files
        )

    # 3. Return the CDN URL (use this in prediction requests)
    return data["file_url"]

curl -X POST https://api.core.today/v1/predictions \
  -H "X-API-Key: cdt_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "black-forest-labs/flux-kontext-pro",
    "input": {
      "prompt": "change the background to a beach sunset",
      "image_url": "https://cdn.core.today/inputs/abc123/reference_image.png"
    }
  }'

curl -X POST https://api.core.today/v1/predictions \
  -H "X-API-Key: cdt_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kwaivgi/kling-v2.1",
    "input": {
      "prompt": "camera slowly zooms in, gentle wind blowing",
      "image": "https://cdn.core.today/inputs/abc123/first_frame.jpg",
      "duration": 5
    }
  }'

curl -X POST https://api.core.today/v1/predictions \
  -H "X-API-Key: cdt_your_api_key" \
  -H "Content-Type: application/json" \
  -d {
    "model": "minimax/speech-02-turbo",
    "input": {
      "text": "This sentence is read in the exact same voice as the audio you uploaded.",
      "reference_audio": "https://cdn.core.today/inputs/abc123/voice_sample.wav"
    }
  }

curl -X GET "https://api.core.today/v1/files/storage" \
  -H "X-API-Key: cdt_your_api_key"

# Example response
{
  "total_bytes": 52428800,
  "total_mb": 50.0,
  "file_count": 127,
  "formatted_size": "50.0 MB",
  "by_content_type": [
    {"content_type": "image/png", "size": 31457280, "count": 85},
    {"content_type": "video/mp4", "size": 15728640, "count": 12},
    {"content_type": "audio/wav", "size": 5242880, "count": 30}
  ]
}

# Default query (7-day URL)
curl -X GET "https://api.core.today/v1/files/storage/files?folder=inputs&limit=10" \
  -H "X-API-Key: cdt_your_api_key"

# Query with a 1-hour expiration URL
curl -X GET "https://api.core.today/v1/files/storage/files?folder=inputs&limit=10&url_expiration=3600" \
  -H "X-API-Key: cdt_your_api_key"

# Example response
{
  "files": [
    {
      "filename": "photo.png",
      "file_size": 1048576,
      "content_type": "image/png",
      "uploaded_at": "2025-12-14T10:00:00Z",
      "object_key": "aiapi/team123/inputs/1734175200000_photo.png",
      "folder": "inputs",
      "expires_at": "2025-12-21T10:00:00Z",
      "file_url": "https://files.core.today/..."
    }
  ],
  "total_count": 42
}

# Default query (7-day URL)
curl -X GET "https://api.core.today/v1/files/storage/file/aiapi/team123/inputs/1734175200000_photo.png" \
  -H "X-API-Key: cdt_your_api_key"

# Query with a 5-minute expiration URL
curl -X GET "https://api.core.today/v1/files/storage/file/aiapi/team123/inputs/1734175200000_photo.png?url_expiration=300" \
  -H "X-API-Key: cdt_your_api_key"

# Example response
{
  "filename": "photo.png",
  "file_size": 1048576,
  "content_type": "image/png",
  "uploaded_at": "2025-12-14T10:00:00Z",
  "object_key": "aiapi/team123/inputs/1734175200000_photo.png",
  "folder": "inputs",
  "status": "uploaded",
  "expires_at": "2025-12-21T10:00:00Z",
  "file_url": "https://files.core.today/...",
  "metadata": {"project": "avatar-gen", "tags": ["portrait"]},
  "is_public": false,
  "public_url": null
}

curl -X GET "https://api.core.today/v1/files/storage/folders" \
  -H "X-API-Key: cdt_your_api_key"

# Example response
{
  "folders": [
    {"name": "inputs", "path": "inputs", "file_count": 85, "total_size": 31457280},
    {"name": "outputs", "path": "outputs", "file_count": 30, "total_size": 15728640},
    {"name": "projects", "path": "projects", "file_count": 12, "total_size": 5242880}
  ]
}

docs.fileUpload.createFolder.code

docs.fileUpload.deleteFolder.code

docs.fileUpload.deleteFolder.withFilesCode

# Search recently uploaded PNG files
curl -X POST https://api.core.today/v1/files/storage/search \
  -H "X-API-Key: cdt_your_api_key" \
  -H "Content-Type: application/json" \
  -d {
    "filters": {
      "content_type": "image/png",
      "folder": "inputs"
    },
    "sort_by": "created_at",
    "sort_order": "desc",
    "page_size": 10
  }

# List all folders in use
curl -X GET "https://api.core.today/v1/files/storage/distinct/folder" \
  -H "X-API-Key: cdt_your_api_key"

# Example response
{
  "field": "folder",
  "values": ["inputs", "outputs", "projects/avatars", "projects/backgrounds"],
  "count": 4
}

curl -X GET "https://api.core.today/v1/files/storage/schema/fields" \
  -H "X-API-Key: cdt_your_api_key"

# Example response
{
  "fields": [
    {"name": "file_id", "type": "keyword", "searchable": true},
    {"name": "filename", "type": "text", "searchable": true},
    {"name": "created_at", "type": "date", "searchable": true},
    {"name": "size", "type": "long", "searchable": true},
    {"name": "tags", "type": "keyword", "searchable": true, "array": true}
  ],
  "total_fields": 40
}

docs.fileUpload.metaMod.code

curl -X DELETE "https://api.core.today/v1/files/storage/file?object_key=aiapi/team123/inputs/1734175200000_photo.png" \
  -H "X-API-Key: cdt_your_api_key"

# Example response
{
  "success": true,
  "deleted_object_key": "aiapi/team123/inputs/1734175200000_photo.png",
  "deleted_at": "2025-12-14T12:00:00Z"
}

import requests

API_KEY = "cdt_your_api_key"
BASE_URL = "https://api.core.today/v1"

def search_files(filters, page=1, page_size=20):
    """Search files."""
    response = requests.post(
        f"{BASE_URL}/files/storage/search",
        headers={
            "X-API-Key": API_KEY,
            "Content-Type": "application/json"
        },
        json={
            "filters": filters,
            "page": page,
            "page_size": page_size,
            "sort_by": "created_at",
            "sort_order": "desc"
        }
    )
    return response.json()

# Example: search PNG images
results = search_files({
    "content_type": "image/png",
    "folder": "inputs"
})

for file in results["files"]:
    print(f"{file['filename']} - {file['size']} bytes")

# Example: search files in a specific project
project_files = search_files({
    "project": "avatar-gen",
    "tags": ["approved"]
})

const API_KEY = "cdt_your_api_key";
const BASE_URL = "https://api.core.today/v1";

async function searchFiles(filters, options = {}) {
  const { page = 1, pageSize = 20, sortBy = "created_at", sortOrder = "desc" } = options;

  const response = await fetch(`${BASE_URL}/files/storage/search`, {
    method: "POST",
    headers: {
      "X-API-Key": API_KEY,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      filters,
      page,
      page_size: pageSize,
      sort_by: sortBy,
      sort_order: sortOrder
    })
  });

  return response.json();
}

// Example: search recently uploaded images
const images = await searchFiles({
  content_type: "image/png",
  folder: "inputs"
});

console.log(`Found ${images.total} files`);
images.files.forEach(file => {
  console.log(`${file.filename} - ${file.size} bytes`);
});

// Example: search files generated by a specific model
const generatedFiles = await searchFiles({
  source_model: "black-forest-labs/flux-schnell",
  created_at: { gte: "2025-12-01T00:00:00Z" }
});

docs.fileUpload.resign.code

docs.fileUpload.chaining.pattern1Code

docs.fileUpload.chaining.pattern2Code

import requests
import time

API_KEY = "cdt_your_api_key"
BASE_URL = "https://api.core.today/v1"

def upload_and_transform(image_path, prompt, project="default"):
    """Upload an image and transform it."""

    # 1. Get presigned URL with metadata
    filename = image_path.split("/")[-1]
    url_response = requests.post(
        f"{BASE_URL}/files/upload-url",
        headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
        json={
            "filename": filename,
            "folder": f"projects/{project}/inputs",
            "metadata": {
                "project": project,
                "source": "upload",
                "original_filename": filename
            }
        }
    )
    url_data = url_response.json()

    # 2. Upload to S3
    with open(image_path, "rb") as f:
        requests.post(
            url_data["upload_url"],
            data=url_data["upload_fields"],
            files={"file": (filename, f)}
        )

    # 3. Create prediction with uploaded image
    pred_response = requests.post(
        f"{BASE_URL}/predictions",
        headers={"X-API-Key": API_KEY, "Content-Type": "application/json"},
        json={
            "model": "black-forest-labs/flux-kontext-pro",
            "input": {
                "prompt": prompt,
                "image_url": url_data["file_url"]
            }
        }
    )
    job_id = pred_response.json()["job_id"]

    # 4. Poll for result
    while True:
        result = requests.get(
            f"{BASE_URL}/predictions/{job_id}",
            headers={"X-API-Key": API_KEY}
        ).json()

        if result["status"] == "completed":
            return result["result"]
        elif result["status"] == "failed":
            raise Exception(result.get("error"))

        time.sleep(2)

# Usage
result = upload_and_transform(
    "/path/to/photo.jpg",
    "make it look like a watercolor painting",
    project="art-styles"
)
print(f"Result: {result}")