Imazeo API Key Setup: Your First Authenticated Request

export IMAZEO_API_ORIGIN="https://api.imazeo.com"
export IMAZEO_PROJECT_ID="00000000-0000-4000-8000-000000000001"
export IMAZEO_API_KEY="imz_00000000-0000-4000-8000-000000000001.REPLACE_WITH_YOUR_SECRET"
export IMAZEO_INPUT="./field-notebook.png"
export IMAZEO_OUTPUT="./output.webp"

# 1) Upload an original you own
curl --fail-with-body --silent --show-error \
  --request POST "$IMAZEO_API_ORIGIN/v1/projects/$IMAZEO_PROJECT_ID/images" \
  --header "X-API-Key: $IMAZEO_API_KEY" \
  --header "X-Upload-Length: $(wc -c < "$IMAZEO_INPUT" | tr -d '[:space:]')" \
  --form "file=@$IMAZEO_INPUT" \
  --output upload.json

IMAZEO_IMAGE_ID=$(node -e 'const fs=require("node:fs"); const r=JSON.parse(fs.readFileSync("upload.json","utf8")); if(!r.success || !r.data?._id) process.exit(1); process.stdout.write(r.data._id);')
export IMAZEO_IMAGE_ID

# 2) Transform to a 600×600 cover WebP
curl --fail-with-body --silent --show-error \
  --request POST "$IMAZEO_API_ORIGIN/v1/projects/$IMAZEO_PROJECT_ID/transforms" \
  --header "X-API-Key: $IMAZEO_API_KEY" \
  --header "Content-Type: application/json" \
  --data "{\"imageId\":\"$IMAZEO_IMAGE_ID\",\"mode\":\"CACHE\",\"transform\":{\"width\":600,\"height\":600,\"fit\":\"cover\",\"format\":\"webp\",\"quality\":80}}" \
  --dump-header response-headers.txt \
  --output "$IMAZEO_OUTPUT"

import json
import os
from pathlib import Path

import requests

origin = os.environ["IMAZEO_API_ORIGIN"].rstrip("/")
project_id = os.environ["IMAZEO_PROJECT_ID"]
api_key = os.environ["IMAZEO_API_KEY"]
input_path = Path(os.environ["IMAZEO_INPUT"])
output_path = Path(os.environ["IMAZEO_OUTPUT"])

headers = {"X-API-Key": api_key}
base = f"{origin}/v1/projects/{project_id}"

with input_path.open("rb") as handle:
    raw = handle.read()

upload = requests.post(
    f"{base}/images",
    headers={**headers, "X-Upload-Length": str(len(raw))},
    files={"file": (input_path.name, raw)},
    timeout=60,
    allow_redirects=False,
)
upload.raise_for_status()
envelope = upload.json()
image_id = envelope["data"]["_id"]

transform = requests.post(
    f"{base}/transforms",
    headers={**headers, "Content-Type": "application/json"},
    json={
        "imageId": image_id,
        "mode": "CACHE",
        "transform": {
            "width": 600,
            "height": 600,
            "fit": "cover",
            "format": "webp",
            "quality": 80,
        },
    },
    timeout=60,
    allow_redirects=False,
)

if transform.status_code != 200:
    raise SystemExit(
        f"Transform failed ({transform.status_code}): {transform.text}"
    )

output_path.write_bytes(transform.content)
print(
    "Saved",
    output_path,
    "transformation:",
    transform.headers.get("X-Transformation-ID"),
    "cache:",
    transform.headers.get("X-Cache"),
)

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

const origin = process.env.IMAZEO_API_ORIGIN;
const projectId = process.env.IMAZEO_PROJECT_ID;
const apiKey = process.env.IMAZEO_API_KEY;
const input = process.env.IMAZEO_INPUT;
const output = process.env.IMAZEO_OUTPUT;

if (!origin || !projectId || !apiKey || !input || !output) {
  throw new Error("Set IMAZEO_API_ORIGIN, IMAZEO_PROJECT_ID, IMAZEO_API_KEY, IMAZEO_INPUT, and IMAZEO_OUTPUT.");
}

const endpoint = `${origin.replace(/\/$/, "")}/v1/projects/${encodeURIComponent(projectId)}`;
const headers = { "X-API-Key": apiKey };

async function checked(response: Response) {
  if (!response.ok) {
    const body = await response.json().catch(() => null);
    const code = body?.error?.code ?? "REQUEST_FAILED";
    const requestId =
      body?.meta?.requestId ?? response.headers.get("X-Request-ID") ?? "unavailable";
    throw new Error(`HTTP ${response.status}: ${code}; request ID: ${requestId}`);
  }
  return response;
}

const bytes = await readFile(input);
const form = new FormData();
form.append("file", new Blob([bytes]), basename(input));

const upload = await checked(
  await fetch(`${endpoint}/images`, {
    method: "POST",
    headers: { ...headers, "X-Upload-Length": String(bytes.byteLength) },
    body: form,
    redirect: "error",
  }),
);

const envelope = await upload.json();
if (envelope.success !== true || typeof envelope.data?._id !== "string") {
  throw new Error("Unexpected upload response; expected data._id.");
}

const transformed = await checked(
  await fetch(`${endpoint}/transforms`, {
    method: "POST",
    headers: { ...headers, "Content-Type": "application/json" },
    body: JSON.stringify({
      imageId: envelope.data._id,
      mode: "CACHE",
      transform: {
        width: 600,
        height: 600,
        fit: "cover",
        format: "webp",
        quality: 80,
      },
    }),
    redirect: "error",
  }),
);

if (!(transformed.headers.get("Content-Type") ?? "").startsWith("image/")) {
  throw new Error("Expected an image response; output was not written.");
}

await writeFile(output, Buffer.from(await transformed.arrayBuffer()));
console.log("Transformation completed.", {
  imageId: envelope.data._id,
  transformationId: transformed.headers.get("X-Transformation-ID"),
  cache: transformed.headers.get("X-Cache"),
});