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.
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 "$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 "$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 -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"

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"})
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']}")
    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"])
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;

$client = new Client([
    'base_uri' => 'https://www.iminify.com/api/v1/',
    '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', [
    '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']]);

// 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';

const call = async (path, options = {}) => {
  const response = await fetch(`${API}${path}`, {
    ...options,
    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 })).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`);
await writeFile(image.name, Buffer.from(await download.arrayBuffer()));