Iminify API

export IMINIFY_API_KEY="paste-your-key-here"

curl "https://www.iminify.com/api/v1/account" \
  -H "Authorization: Bearer $IMINIFY_API_KEY" \
  -H "Accept: application/json"

#!/usr/bin/env bash
# Compress photo.jpg to WebP at 1600 pixels wide, wait for it, save the result.
# Needs curl 7.76 or newer and jq.
# Each call gives up after 10 seconds without a connection and after --max-time seconds overall,
# so a stalled network can't hang the script.
set -euo pipefail

API="https://www.iminify.com/api/v1"
AUTH="Authorization: Bearer $IMINIFY_API_KEY"

# 1. Upload. The answer comes back straight away, queued, with the image's id.
id=$(curl -sS --fail-with-body --connect-timeout 10 --max-time 1800 "$API/images" \
  -H "$AUTH" -H "Accept: application/json" \
  -F "[email protected]" -F "format=webp" -F "width=1600" \
  | jq -r '.data.id')

# 2. Poll until it has finished.
while true; do
  image=$(curl -sS --fail-with-body --connect-timeout 10 --max-time 30 "$API/images/$id" \
    -H "$AUTH" -H "Accept: application/json")
  status=$(jq -r '.data.status' <<< "$image")

  case "$status" in
    completed|already-optimized) break ;;
    failed|cancelled) echo "The image ended as $status" >&2; exit 1 ;;
  esac

  sleep 2
done

jq -r '.data | "\(.original.size) bytes -> \(.optimized.size) bytes (\(.saved_percent)% smaller)"' <<< "$image"

# 3. Download the optimized copy under the name it was given.
curl -sS --fail-with-body --connect-timeout 10 --max-time 1800 -o "$(jq -r '.data.name' <<< "$image")" \
  "$API/images/$id/download" -H "$AUTH"

"""Compress photo.jpg to WebP at 1600 pixels wide, wait for it, save the result.

Needs Python 3.8 or newer and the requests package (pip install requests).
"""
import os
import time

import requests

API = "https://www.iminify.com/api/v1"

# requests waits forever by default. These calls give up after 10 seconds without
# a connection and after 30 seconds without an answer, or 5 minutes for a file.
TIMEOUT = (10, 30)
FILE_TIMEOUT = (10, 300)

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {os.environ['IMINIFY_API_KEY']}",
    "Accept": "application/json",
})

# 1. Upload. The answer comes back straight away, queued, with the image's id.
with open("photo.jpg", "rb") as file:
    response = session.post(
        f"{API}/images",
        files={"file": file},
        data={"format": "webp", "width": "1600"},
        timeout=FILE_TIMEOUT,
    )
response.raise_for_status()
image = response.json()["data"]

# 2. Poll until it has finished.
while image["status"] in ("queued", "optimizing"):
    time.sleep(2)
    response = session.get(f"{API}/images/{image['id']}", timeout=TIMEOUT)
    response.raise_for_status()
    image = response.json()["data"]

if image["status"] not in ("completed", "already-optimized"):
    raise SystemExit(f"The image ended as {image['status']}")

print(f"{image['original']['size']} bytes -> {image['optimized']['size']} bytes ({image['saved_percent']}% smaller)")

# 3. Download the optimized copy under the name it was given.
response = session.get(image["optimized"]["download_url"], timeout=FILE_TIMEOUT)
response.raise_for_status()
with open(image["name"], "wb") as out:
    out.write(response.content)

<?php

declare(strict_types=1);

// Compress photo.jpg to WebP at 1600 pixels wide, wait for it, save the result.
// Needs PHP 8.1 or newer and Guzzle (composer require guzzlehttp/guzzle).

require __DIR__ . '/vendor/autoload.php';

use GuzzleHttp\Client;

// Guzzle waits forever by default. These calls give up after 10 seconds without a
// connection and after 30 seconds overall, or 30 minutes for a file, so a large one
// gets through a slow connection.
$client = new Client([
    'base_uri' => 'https://www.iminify.com/api/v1/',
    'connect_timeout' => 10,
    'timeout' => 30,
    'headers' => [
        'Authorization' => 'Bearer ' . getenv('IMINIFY_API_KEY'),
        'Accept' => 'application/json',
    ],
]);

// 1. Upload. The answer comes back straight away, queued, with the image's id.
$response = $client->post('images', [
    'timeout' => 1800,
    'multipart' => [
        ['name' => 'file', 'contents' => fopen('photo.jpg', 'r'), 'filename' => 'photo.jpg'],
        ['name' => 'format', 'contents' => 'webp'],
        ['name' => 'width', 'contents' => '1600'],
    ],
]);
$image = json_decode((string) $response->getBody(), true)['data'];

// 2. Poll until it has finished.
while (in_array($image['status'], ['queued', 'optimizing'], true)) {
    sleep(2);

    $response = $client->get("images/{$image['id']}");
    $image = json_decode((string) $response->getBody(), true)['data'];
}

if ( ! in_array($image['status'], ['completed', 'already-optimized'], true)) {
    fwrite(STDERR, "The image ended as {$image['status']}\n");
    exit(1);
}

echo "{$image['original']['size']} bytes -> {$image['optimized']['size']} bytes ({$image['saved_percent']}% smaller)\n";

// 3. Download the optimized copy under the name it was given.
$client->get("images/{$image['id']}/download", ['sink' => $image['name'], 'timeout' => 1800]);

// Compress photo.jpg to WebP at 1600 pixels wide, wait for it, save the result.
// Needs Node 20 or newer. Save it as compress.mjs and run: node compress.mjs
import { openAsBlob } from 'node:fs';
import { writeFile } from 'node:fs/promises';
import { setTimeout as sleep } from 'node:timers/promises';

const API = 'https://www.iminify.com/api/v1';

// Node's fetch waits up to five minutes on a stalled connection. Each call gives up
// after `seconds` instead: 30, or 1800 when it moves a file, so a large one gets
// through a slow connection.
const call = async (path, options = {}, seconds = 30) => {
  const response = await fetch(`${API}${path}`, {
    ...options,
    signal: AbortSignal.timeout(seconds * 1000),
    headers: {
      Authorization: `Bearer ${process.env.IMINIFY_API_KEY}`,
      Accept: 'application/json',
    },
  });

  if (!response.ok) {
    throw new Error(`${response.status}: ${(await response.json()).message}`);
  }

  return response;
};

// 1. Upload. The answer comes back straight away, queued, with the image's id.
const form = new FormData();
form.append('file', await openAsBlob('photo.jpg'), 'photo.jpg');
form.append('format', 'webp');
form.append('width', '1600');

let { data: image } = await (await call('/images', { method: 'POST', body: form }, 1800)).json();

// 2. Poll until it has finished.
while (['queued', 'optimizing'].includes(image.status)) {
  await sleep(2000);
  ({ data: image } = await (await call(`/images/${image.id}`)).json());
}

if (!['completed', 'already-optimized'].includes(image.status)) {
  throw new Error(`The image ended as ${image.status}`);
}

console.log(`${image.original.size} bytes -> ${image.optimized.size} bytes (${image.saved_percent}% smaller)`);

// 3. Download the optimized copy under the name it was given.
const download = await call(`/images/${image.id}/download`, {}, 1800);
await writeFile(image.name, Buffer.from(await download.arrayBuffer()));