Image Processing

Resize, compress, convert, watermark and read image metadata.

1. Overview

Base path: https://api.infrai.cc/v1/image

Auth header: Authorization: Bearer $INFRAI_API_KEY

bash

# Call any /v1/image capability over raw HTTP — no SDK to install.
# curl:
curl https://api.infrai.cc/v1/image/... \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json"

2. Methods (18)

2.1image.process

POST /v1/image/process

Process an image: resize, compress, convert, watermark, rotate or remove background.

Parameters

Name	Type	Required	Description
`input`	`ImageRef { url? \| base64? }`	Required	Image reference as URL or base64.
`width`	`number`	Optional	Target width in pixels.
`height`	`number`	Optional	Target height in pixels.
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output image format.
`quality`	`number`	Optional	Compression quality from 0 to 100.
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

ImageOpResult { image_url, mime, width?, height?, bytes }

Name	Type	Description
`image_id`	`string`	Unique identifier for this image `pattern: ^pim_[A-Za-z0-9]{20,}$`
`url`	`string`	URL for this resource or endpoint
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Output or input format (e.g. json, csv, png)
`width`	`integer`	Width of the image in pixels `≥ 1`
`height`	`integer`	Height of the image in pixels `≥ 1`
`size_bytes`	`integer`	Size of the resource in bytes `≥ 0`
`sha256`	`string`	SHA-256 hash of the resource content `pattern: ^[a-f0-9]{64}$`
`original_sha256`	`string \| null`	SHA-256 hash of the original image before processing
`ops_applied`	`string[]`	List of image operations that were applied
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/process \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": {"url": "https://example.com/photo.jpg"}, "ops": [{"op": "resize", "params": {"width": 800}}, {"op": "compress", "params": {"quality": 80}}]}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/process",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': {'url': 'https://example.com/photo.jpg'}, 'ops': [{'op': 'resize', 'params': {'width': 800}}, {'op': 'compress', 'params': {'quality': 80}}]},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/process",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": {"url": "https://example.com/photo.jpg"}, "ops": [{"op": "resize", "params": {"width": 800}}, {"op": "compress", "params": {"quality": 80}}]}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/process",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": {"url": "https://example.com/photo.jpg"}, "ops": [{"op": "resize", "params": {"width": 800}}, {"op": "compress", "params": {"quality": 80}}]}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"image": {"url": "https://example.com/photo.jpg"}, "ops": [{"op": "resize", "params": {"width": 800}}, {"op": "compress", "params": {"quality": 80}}]}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/process", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/process"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"image\": {\"url\": \"https://example.com/photo.jpg\"}, \"ops\": [{\"op\": \"resize\", \"params\": {\"width\": 800}}, {\"op\": \"compress\", \"params\": {\"quality\": 80}}]}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/process");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"image\": {\"url\": \"https://example.com/photo.jpg\"}, \"ops\": [{\"op\": \"resize\", \"params\": {\"width\": 800}}, {\"op\": \"compress\", \"params\": {\"quality\": 80}}]}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/process");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"image\": {\"url\": \"https://example.com/photo.jpg\"}, \"ops\": [{\"op\": \"resize\", \"params\": {\"width\": 800}}, {\"op\": \"compress\", \"params\": {\"quality\": 80}}]}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/process")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"image": {"url": "https://example.com/photo.jpg"}, "ops": [{"op": "resize", "params": {"width": 800}}, {"op": "compress", "params": {"quality": 80}}]}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/process")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"image": {"url": "https://example.com/photo.jpg"}, "ops": [{"op": "resize", "params": {"width": 800}}, {"op": "compress", "params": {"quality": 80}}]}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.2image.metadata

POST /v1/image/metadata

Read image dimensions, MIME type and EXIF metadata.

Parameters

Name	Type	Required	Description
`input`	`ImageRef { url? \| base64? }`	Required	Image reference as URL or base64.

Returns

{ width, height, mime, exif? }

Name	Type	Description
`width`	`integer`	Width of the image in pixels `≥ 1`
`height`	`integer`	Height of the image in pixels `≥ 1`
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Output or input format (e.g. json, csv, png)
`size_bytes`	`integer`	Size of the resource in bytes `≥ 0`
`exif`	`object \| null`	Raw EXIF tag map; null when not read / not present.
`color_space`	`string \| null`	e.g. 'sRGB', 'CMYK'.
`has_alpha`	`boolean \| null`	Whether the image has an alpha channel
`orientation`	`integer \| null`	EXIF orientation tag (1-8); null when unknown. `1–8`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/metadata \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": "sample"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/metadata",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': 'sample'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/metadata",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/metadata",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"image": "sample"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/metadata", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/metadata"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"image\": \"sample\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/metadata");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"image\": \"sample\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/metadata");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"image\": \"sample\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/metadata")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"image": "sample"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/metadata")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"image": "sample"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.3image.upload

POST /v1/image/upload

Upload image resources and return asset id and URL

Parameters

Name	Type	Required	Description
`file`	`string`	Required	Image to upload: local file path or byte data
`filename`	`string`	Optional	Optional file name for storage and display
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

ImageAsset { id, url, mime, width?, height?, bytes }

Name	Type	Description
`image_id`	`string`	Unique identifier for this image `pattern: ^pim_[A-Za-z0-9]{20,}$`
`url`	`string`	URL for this resource or endpoint
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Output or input format (e.g. json, csv, png)
`width`	`integer`	Width of the image in pixels `≥ 1`
`height`	`integer`	Height of the image in pixels `≥ 1`
`size_bytes`	`integer`	Size of the resource in bytes `≥ 0`
`sha256`	`string`	SHA-256 hash of the resource content `pattern: ^[a-f0-9]{64}$`
`original_sha256`	`string \| null`	SHA-256 hash of the original image before processing
`ops_applied`	`string[]`	List of image operations that were applied
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/upload \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"file": "sample"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/upload",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'file': 'sample'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/upload",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"file": "sample"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/upload",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"file": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"file": "sample"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/upload", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/upload"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"file\": \"sample\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/upload");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"file\": \"sample\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/upload");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"file\": \"sample\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/upload")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"file": "sample"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/upload")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"file": "sample"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.4image.get

GET /v1/image/get/{id}

Read the meta information of a single image asset by id

Parameters

Name	Type	Required	Description
`id`	`string`	Required	Image asset id

Returns

ImageAsset { id, url, mime, width?, height?, bytes }

Name	Type	Description
`image_id`	`string`	Unique identifier for this image `pattern: ^pim_[A-Za-z0-9]{20,}$`
`url`	`string`	URL for this resource or endpoint
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Output or input format (e.g. json, csv, png)
`width`	`integer`	Width of the image in pixels `≥ 1`
`height`	`integer`	Height of the image in pixels `≥ 1`
`size_bytes`	`integer`	Size of the resource in bytes `≥ 0`
`sha256`	`string`	SHA-256 hash of the resource content `pattern: ^[a-f0-9]{64}$`
`original_sha256`	`string \| null`	SHA-256 hash of the original image before processing
`ops_applied`	`string[]`	List of image operations that were applied
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/image/get/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/image/get/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/get/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/get/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"fmt"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/image/get/ID", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/get/ID"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/image/get/ID");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/get/ID");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/get/ID")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/image/get/ID")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.5image.delete

DELETE /v1/image/delete/{id}

Delete stored image assets by id

Parameters

Name	Type	Required	Description
`id`	`string`	Required	Image asset id to delete
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

{ ok: boolean }

Name	Type	Description
`deleted`	`boolean`	Whether the resource was successfully deleted
`image_id`	`string \| null`	Unique identifier for this image `pattern: ^pim_[A-Za-z0-9]{20,}$`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X DELETE https://api.infrai.cc/v1/image/delete/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.delete(
    "https://api.infrai.cc/v1/image/delete/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/delete/ID",
  {
    method: "DELETE",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/delete/ID",
  {
    method: "DELETE",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"fmt"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("DELETE", "https://api.infrai.cc/v1/image/delete/ID", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/delete/ID"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("DELETE"), "https://api.infrai.cc/v1/image/delete/ID");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/delete/ID");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/delete/ID")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Delete.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .delete("https://api.infrai.cc/v1/image/delete/ID")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.6image.resize

POST /v1/image/resize

Scale image to specified width and height

Parameters

Name	Type	Required	Description
`image`	`ImageRef { url? \| base64? \| id? }`	Required	Image reference as URL or base64.
`width`	`number`	Optional	Target width in pixels. `≥ 1`
`height`	`number`	Optional	Target height in pixels. `≥ 1`
`fit`	`"cover" \| "contain" \| "fill" \| "inside" \| "outside"`	Optional	Scaling adaptation mode: inside/cover/contain/fill
`enlarge`	`boolean`	Optional	Whether to allow enlargement when the original image is smaller than the target size `default: false`
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output image format.
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

ProcessedImage { image_url, mime, width, height, bytes }

Name	Type	Description
`image_id`	`string`	Unique identifier for this image `pattern: ^pim_[A-Za-z0-9]{20,}$`
`url`	`string`	URL for this resource or endpoint
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Output or input format (e.g. json, csv, png)
`width`	`integer`	Width of the image in pixels `≥ 1`
`height`	`integer`	Height of the image in pixels `≥ 1`
`size_bytes`	`integer`	Size of the resource in bytes `≥ 0`
`sha256`	`string`	SHA-256 hash of the resource content `pattern: ^[a-f0-9]{64}$`
`original_sha256`	`string \| null`	SHA-256 hash of the original image before processing
`ops_applied`	`string[]`	List of image operations that were applied
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/resize \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": {"base64": "<...>"}, "width": 800, "fit": "cover"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/resize",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': {'base64': '<...>'}, 'width': 800, 'fit': 'cover'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/resize",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": {"base64": "<...>"}, "width": 800, "fit": "cover"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/resize",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": {"base64": "<...>"}, "width": 800, "fit": "cover"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"image": {"base64": "<...>"}, "width": 800, "fit": "cover"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/resize", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/resize"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"image\": {\"base64\": \"<...>\"}, \"width\": 800, \"fit\": \"cover\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/resize");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"image\": {\"base64\": \"<...>\"}, \"width\": 800, \"fit\": \"cover\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/resize");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"image\": {\"base64\": \"<...>\"}, \"width\": 800, \"fit\": \"cover\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/resize")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"image": {"base64": "<...>"}, "width": 800, "fit": "cover"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/resize")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"image": {"base64": "<...>"}, "width": 800, "fit": "cover"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.7image.crop

POST /v1/image/crop

Crop image according to xywh rectangle

Parameters

Name	Type	Required	Description
`image`	`ImageRef { url? \| base64? \| id? }`	Required	Image reference as URL or base64.
`x`	`number`	Required	The abscissa of the cropping starting point (pixels) `≥ 0`
`y`	`number`	Required	The vertical coordinate of the cropping starting point (pixels) `≥ 0`
`width`	`number`	Required	Target width in pixels. `≥ 1`
`height`	`number`	Required	Target height in pixels. `≥ 1`
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output image format.
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

ProcessedImage { image_url, mime, width, height, bytes }

Name	Type	Description
`image_id`	`string`	Unique identifier for this image `pattern: ^pim_[A-Za-z0-9]{20,}$`
`url`	`string`	URL for this resource or endpoint
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Output or input format (e.g. json, csv, png)
`width`	`integer`	Width of the image in pixels `≥ 1`
`height`	`integer`	Height of the image in pixels `≥ 1`
`size_bytes`	`integer`	Size of the resource in bytes `≥ 0`
`sha256`	`string`	SHA-256 hash of the resource content `pattern: ^[a-f0-9]{64}$`
`original_sha256`	`string \| null`	SHA-256 hash of the original image before processing
`ops_applied`	`string[]`	List of image operations that were applied
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/crop \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": "sample", "x": 1, "y": 1, "width": 1, "height": 1}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/crop",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': 'sample', 'x': 1, 'y': 1, 'width': 1, 'height': 1},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/crop",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample", "x": 1, "y": 1, "width": 1, "height": 1}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/crop",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample", "x": 1, "y": 1, "width": 1, "height": 1}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"image": "sample", "x": 1, "y": 1, "width": 1, "height": 1}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/crop", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/crop"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"image\": \"sample\", \"x\": 1, \"y\": 1, \"width\": 1, \"height\": 1}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/crop");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"image\": \"sample\", \"x\": 1, \"y\": 1, \"width\": 1, \"height\": 1}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/crop");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"image\": \"sample\", \"x\": 1, \"y\": 1, \"width\": 1, \"height\": 1}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/crop")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"image": "sample", "x": 1, "y": 1, "width": 1, "height": 1}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/crop")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"image": "sample", "x": 1, "y": 1, "width": 1, "height": 1}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.8image.smart_crop

POST /v1/image/smart_crop

Saliency-aware cropping to specified aspect ratio

Parameters

Name	Type	Required	Description
`image`	`ImageRef { url? \| base64? \| id? }`	Required	Image reference as URL or base64.
`aspect`	`string`	Required	Target aspect ratio, such as 1:1, 16:9
`target`	`"face" \| "saliency"`	Optional	Crop focus target: face (face) or saliency (subject)
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output image format.
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

ProcessedImage { image_url, mime, width, height, bytes }

Name	Type	Description
`image_id`	`string`	Unique identifier for this image `pattern: ^pim_[A-Za-z0-9]{20,}$`
`url`	`string`	URL for this resource or endpoint
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Output or input format (e.g. json, csv, png)
`width`	`integer`	Width of the image in pixels `≥ 1`
`height`	`integer`	Height of the image in pixels `≥ 1`
`size_bytes`	`integer`	Size of the resource in bytes `≥ 0`
`sha256`	`string`	SHA-256 hash of the resource content `pattern: ^[a-f0-9]{64}$`
`original_sha256`	`string \| null`	SHA-256 hash of the original image before processing
`ops_applied`	`string[]`	List of image operations that were applied
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/smart_crop \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": "sample", "aspect": "sample"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/smart_crop",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': 'sample', 'aspect': 'sample'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/smart_crop",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample", "aspect": "sample"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/smart_crop",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample", "aspect": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"image": "sample", "aspect": "sample"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/smart_crop", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/smart_crop"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"image\": \"sample\", \"aspect\": \"sample\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/smart_crop");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"image\": \"sample\", \"aspect\": \"sample\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/smart_crop");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"image\": \"sample\", \"aspect\": \"sample\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/smart_crop")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"image": "sample", "aspect": "sample"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/smart_crop")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"image": "sample", "aspect": "sample"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.9image.rotate

POST /v1/image/rotate

Rotate image by angle

Parameters

Name	Type	Required	Description
`image`	`ImageRef { url? \| base64? \| id? }`	Required	Image reference as URL or base64.
`degrees`	`number`	Required	Rotation angle (degrees)
`auto_orient`	`boolean`	Optional	Whether to automatically correct the orientation according to EXIF information `default: true`
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output image format.
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

ProcessedImage { image_url, mime, width, height, bytes }

Name	Type	Description
`image_id`	`string`	Unique identifier for this image `pattern: ^pim_[A-Za-z0-9]{20,}$`
`url`	`string`	URL for this resource or endpoint
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Output or input format (e.g. json, csv, png)
`width`	`integer`	Width of the image in pixels `≥ 1`
`height`	`integer`	Height of the image in pixels `≥ 1`
`size_bytes`	`integer`	Size of the resource in bytes `≥ 0`
`sha256`	`string`	SHA-256 hash of the resource content `pattern: ^[a-f0-9]{64}$`
`original_sha256`	`string \| null`	SHA-256 hash of the original image before processing
`ops_applied`	`string[]`	List of image operations that were applied
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/rotate \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": "sample", "degrees": 1.0}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/rotate",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': 'sample', 'degrees': 1.0},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/rotate",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample", "degrees": 1.0}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/rotate",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample", "degrees": 1.0}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"image": "sample", "degrees": 1.0}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/rotate", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/rotate"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"image\": \"sample\", \"degrees\": 1.0}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/rotate");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"image\": \"sample\", \"degrees\": 1.0}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/rotate");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"image\": \"sample\", \"degrees\": 1.0}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/rotate")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"image": "sample", "degrees": 1.0}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/rotate")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"image": "sample", "degrees": 1.0}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.10image.compress

POST /v1/image/compress

Compress images by quality or target number of bytes

Parameters

Name	Type	Required	Description
`image`	`ImageRef { url? \| base64? \| id? }`	Required	Image reference as URL or base64.
`quality`	`number`	Optional	Compression quality from 0 to 100. `1–100`
`target_bytes`	`number`	Optional	The upper limit of the target output bytes, used to limit the compressed size `≥ 1`
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output image format.
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

ProcessedImage { image_url, mime, width, height, bytes }

Name	Type	Description
`image_id`	`string`	Unique identifier for this image `pattern: ^pim_[A-Za-z0-9]{20,}$`
`url`	`string`	URL for this resource or endpoint
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Output or input format (e.g. json, csv, png)
`width`	`integer`	Width of the image in pixels `≥ 1`
`height`	`integer`	Height of the image in pixels `≥ 1`
`size_bytes`	`integer`	Size of the resource in bytes `≥ 0`
`sha256`	`string`	SHA-256 hash of the resource content `pattern: ^[a-f0-9]{64}$`
`original_sha256`	`string \| null`	SHA-256 hash of the original image before processing
`ops_applied`	`string[]`	List of image operations that were applied
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/compress \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": "sample"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/compress",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': 'sample'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/compress",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/compress",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"image": "sample"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/compress", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/compress"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"image\": \"sample\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/compress");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"image\": \"sample\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/compress");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"image\": \"sample\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/compress")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"image": "sample"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/compress")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"image": "sample"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.11image.convert

POST /v1/image/convert

Recode the image to another format

Parameters

Name	Type	Required	Description
`image`	`ImageRef { url? \| base64? \| id? }`	Required	Image reference as URL or base64.
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Required	Output image format.
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

ProcessedImage { image_url, mime, width, height, bytes }

Name	Type	Description
`image_id`	`string`	Unique identifier for this image `pattern: ^pim_[A-Za-z0-9]{20,}$`
`url`	`string`	URL for this resource or endpoint
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Output or input format (e.g. json, csv, png)
`width`	`integer`	Width of the image in pixels `≥ 1`
`height`	`integer`	Height of the image in pixels `≥ 1`
`size_bytes`	`integer`	Size of the resource in bytes `≥ 0`
`sha256`	`string`	SHA-256 hash of the resource content `pattern: ^[a-f0-9]{64}$`
`original_sha256`	`string \| null`	SHA-256 hash of the original image before processing
`ops_applied`	`string[]`	List of image operations that were applied
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/convert \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": "sample", "format": "auto"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/convert",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': 'sample', 'format': 'auto'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/convert",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample", "format": "auto"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/convert",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample", "format": "auto"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"image": "sample", "format": "auto"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/convert", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/convert"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"image\": \"sample\", \"format\": \"auto\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/convert");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"image\": \"sample\", \"format\": \"auto\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/convert");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"image\": \"sample\", \"format\": \"auto\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/convert")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"image": "sample", "format": "auto"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/convert")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"image": "sample", "format": "auto"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.12image.watermark

POST /v1/image/watermark

Add text or image watermark to images

Parameters

Name	Type	Required	Description
`image`	`ImageRef { url? \| base64? \| id? }`	Required	Image reference as URL or base64.
`text`	`string`	Optional	Watermark text content
`watermark_image`	`ImageRef { url? \| base64? \| id? }`	Optional	Image reference used as watermark (url/base64/id)
`position`	`"top_left" \| "top" \| "top_right" \| "left" \| "center" \| "right" \| "bottom_left" \| "bottom" \| "bottom_right"`	Optional	Watermark position: four corners or center `default: "bottom_right"`
`opacity`	`number`	Optional	Watermark opacity, between 0 and 1 `0–1default: 1`
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output image format.
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

ProcessedImage { image_url, mime, width, height, bytes }

Name	Type	Description
`image_id`	`string`	Unique identifier for this image `pattern: ^pim_[A-Za-z0-9]{20,}$`
`url`	`string`	URL for this resource or endpoint
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Output or input format (e.g. json, csv, png)
`width`	`integer`	Width of the image in pixels `≥ 1`
`height`	`integer`	Height of the image in pixels `≥ 1`
`size_bytes`	`integer`	Size of the resource in bytes `≥ 0`
`sha256`	`string`	SHA-256 hash of the resource content `pattern: ^[a-f0-9]{64}$`
`original_sha256`	`string \| null`	SHA-256 hash of the original image before processing
`ops_applied`	`string[]`	List of image operations that were applied
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/watermark \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": {"base64": "<...>"}, "text": "© Infrai", "position": "bottom_right", "opacity": 0.6}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/watermark",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': {'base64': '<...>'}, 'text': '© Infrai', 'position': 'bottom_right', 'opacity': 0.6},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/watermark",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": {"base64": "<...>"}, "text": "© Infrai", "position": "bottom_right", "opacity": 0.6}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/watermark",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": {"base64": "<...>"}, "text": "© Infrai", "position": "bottom_right", "opacity": 0.6}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"image": {"base64": "<...>"}, "text": "© Infrai", "position": "bottom_right", "opacity": 0.6}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/watermark", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/watermark"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"image\": {\"base64\": \"<...>\"}, \"text\": \"\u00a9 Infrai\", \"position\": \"bottom_right\", \"opacity\": 0.6}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/watermark");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"image\": {\"base64\": \"<...>\"}, \"text\": \"\u00a9 Infrai\", \"position\": \"bottom_right\", \"opacity\": 0.6}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/watermark");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"image\": {\"base64\": \"<...>\"}, \"text\": \"\u00a9 Infrai\", \"position\": \"bottom_right\", \"opacity\": 0.6}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/watermark")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"image": {"base64": "<...>"}, "text": "© Infrai", "position": "bottom_right", "opacity": 0.6}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/watermark")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"image": {"base64": "<...>"}, "text": "© Infrai", "position": "bottom_right", "opacity": 0.6}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.13image.background_remove

POST /v1/image/background_remove

AI cutout to remove picture background

Parameters

Name	Type	Required	Description
`image`	`ImageRef { url? \| base64? \| id? }`	Required	Image reference as URL or base64.
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output image format.
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

ProcessedImage { image_url, mime, width, height, bytes }

Name	Type	Description
`image_id`	`string`	Unique identifier for this image `pattern: ^pim_[A-Za-z0-9]{20,}$`
`url`	`string`	URL for this resource or endpoint
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Output or input format (e.g. json, csv, png)
`width`	`integer`	Width of the image in pixels `≥ 1`
`height`	`integer`	Height of the image in pixels `≥ 1`
`size_bytes`	`integer`	Size of the resource in bytes `≥ 0`
`sha256`	`string`	SHA-256 hash of the resource content `pattern: ^[a-f0-9]{64}$`
`original_sha256`	`string \| null`	SHA-256 hash of the original image before processing
`ops_applied`	`string[]`	List of image operations that were applied
`cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/background_remove \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": "sample"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/background_remove",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': 'sample'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/background_remove",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/background_remove",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"image": "sample"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/background_remove", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/background_remove"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"image\": \"sample\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/background_remove");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"image\": \"sample\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/background_remove");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"image\": \"sample\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/background_remove")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"image": "sample"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/background_remove")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"image": "sample"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.14image.transformation.create

POST /v1/image/transformation/create

Parameters

Name	Type	Required	Description
`name`	`string`	Required	Transform template name for reuse in serving URLs `1–128 chars`
`transform`	`ImageTransform`	Required	Image transformation parameter object (width, height, format, cropping, etc.)
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

ImageTransformation { id, name, transform, created_at }

Name	Type	Description
`transformation_id`	`string`	Unique identifier for this transformation `pattern: ^imgtf_[A-Za-z0-9]{20,}$`
`name`	`string`	Human-readable name for this resource `1–128 chars`
`transform`	`object`	Image transformation specification
`transform.w`	`integer \| null`	Target width. `≥ 1`
`transform.h`	`integer \| null`	Target height. `≥ 1`
`transform.f`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Format for the output image
`transform.q`	`integer \| null`	Encoder quality 1-100. `1–100`
`transform.fit`	`"cover" \| "contain" \| "fill" \| "inside" \| "outside"`	Fit mode for resizing (cover, contain, fill, inside, outside)
`created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/transformation/create \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "example", "transform": {}}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/transformation/create",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'name': 'example', 'transform': {}},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/transformation/create",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"name": "example", "transform": {}}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/transformation/create",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"name": "example", "transform": {}}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"name": "example", "transform": {}}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/transformation/create", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/transformation/create"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"name\": \"example\", \"transform\": {}}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/transformation/create");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"name\": \"example\", \"transform\": {}}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/transformation/create");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"name\": \"example\", \"transform\": {}}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/transformation/create")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"name": "example", "transform": {}}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/transformation/create")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"name": "example", "transform": {}}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.15image.transformation.list

GET /v1/image/transformation/list

List registered named image transform templates

Parameters

Name	Type	Required	Description
`cursor`	`string`	Optional	Paging cursor: Pass in the next_cursor returned from the previous page to get the next page.
`limit`	`number`	Optional	The maximum number of items returned on a single page.

Returns

{ items: ImageTransformation[], next_cursor? }

Name	Type	Description
`items`	`object[]`	Array of result items in this page
`items[].transformation_id`	`string`	Unique identifier for this transformation `pattern: ^imgtf_[A-Za-z0-9]{20,}$`
`items[].name`	`string`	Human-readable name for this resource `1–128 chars`
`items[].transform`	`object`	Image transformation specification
`items[].transform.w`	`integer \| null`	Target width. `≥ 1`
`items[].transform.h`	`integer \| null`	Target height. `≥ 1`
`items[].transform.f`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Format for the output image
`items[].transform.q`	`integer \| null`	Encoder quality 1-100. `1–100`
`items[].transform.fit`	`"cover" \| "contain" \| "fill" \| "inside" \| "outside"`	Fit mode for resizing (cover, contain, fill, inside, outside)
`items[].created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`
`next_cursor`	`string \| null`	Opaque cursor to fetch the next page; null/absent if this is the last page

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/image/transformation/list \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/image/transformation/list",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/transformation/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/transformation/list",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"fmt"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/image/transformation/list", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/transformation/list"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/image/transformation/list");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/transformation/list");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/transformation/list")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/image/transformation/list")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.16image.batch.submit

POST /v1/image/batch/submit

Submit batch image processing tasks

Parameters

Name	Type	Required	Description
`items`	`Array<{ image, ops }>`	Required	Array of batch entries, each containing image and ops (processing steps) `≥ 1 item`
`webhook_url`	`string`	Optional	Webhook address for callback notification when the task is completed `format: uri`
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

ImageJob { id, status, count, created_at }

Name	Type	Description
`job_id`	`string`	Unique identifier for this async job `pattern: ^imgjob_[A-Za-z0-9]{20,}$`
`status`	`"queued" \| "in_progress" \| "completed" \| "failed" \| "cancelled"`	Current status of this resource
`total_count`	`integer`	Total number of items across all pages `≥ 1`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/batch/submit \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"items": [{"image": "sample", "ops": [{"op": "resize"}]}]}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/batch/submit",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'items': [{'image': 'sample', 'ops': [{'op': 'resize'}]}]},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/batch/submit",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"items": [{"image": "sample", "ops": [{"op": "resize"}]}]}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/batch/submit",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"items": [{"image": "sample", "ops": [{"op": "resize"}]}]}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"items": [{"image": "sample", "ops": [{"op": "resize"}]}]}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/batch/submit", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/batch/submit"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"items\": [{\"image\": \"sample\", \"ops\": [{\"op\": \"resize\"}]}]}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/batch/submit");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"items\": [{\"image\": \"sample\", \"ops\": [{\"op\": \"resize\"}]}]}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/batch/submit");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"items\": [{\"image\": \"sample\", \"ops\": [{\"op\": \"resize\"}]}]}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/batch/submit")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"items": [{"image": "sample", "ops": [{"op": "resize"}]}]}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/batch/submit")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"items": [{"image": "sample", "ops": [{"op": "resize"}]}]}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.17image.batch.status

GET /v1/image/batch/status/{id}

Query the progress of batch image processing tasks

Parameters

Name	Type	Required	Description
`id`	`string`	Required	batch processing task job id

Returns

ImageJob { id, status, count, done, failed, results? }

Name	Type	Description
`job_id`	`string`	Unique identifier for this async job `pattern: ^imgjob_[A-Za-z0-9]{20,}$`
`status`	`"queued" \| "in_progress" \| "completed" \| "failed" \| "cancelled"`	Current status of this resource
`items`	`object[]`	Array of result items in this page
`items[].index`	`integer`	- `≥ 0`
`items[].status`	`"queued" \| "in_progress" \| "completed" \| "failed"`	-
`items[].result`	`object \| null`	-
`items[].result.image_id`	`string`	Unique identifier for this image `pattern: ^pim_[A-Za-z0-9]{20,}$`
`items[].result.url`	`string`	URL for this resource or endpoint
`items[].result.format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Output or input format (e.g. json, csv, png)
`items[].result.width`	`integer`	Width of the image in pixels `≥ 1`
`items[].result.height`	`integer`	Height of the image in pixels `≥ 1`
`items[].result.size_bytes`	`integer`	Size of the resource in bytes `≥ 0`
`items[].result.sha256`	`string`	SHA-256 hash of the resource content `pattern: ^[a-f0-9]{64}$`
`items[].result.original_sha256`	`string \| null`	SHA-256 hash of the original image before processing
`items[].result.ops_applied`	`string[]`	List of image operations that were applied
`items[].result.cost_usd`	`number \| null`	Cost of this operation in USD `≥ 0`
`items[].result.created_at`	`string`	ISO 8601 timestamp when this resource was created `format: date-time`
`items[].error`	`string \| null`	Error code when this item failed.

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X GET https://api.infrai.cc/v1/image/batch/status/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY"

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/image/batch/status/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/batch/status/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/batch/status/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"fmt"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.infrai.cc/v1/image/batch/status/ID", nil)
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/batch/status/ID"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("GET"), "https://api.infrai.cc/v1/image/batch/status/ID");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/batch/status/ID");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "GET");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
]);
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/batch/status/ID")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Get.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .get("https://api.infrai.cc/v1/image/batch/status/ID")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

2.18image.batch.cancel

POST /v1/image/batch/cancel/{id}

Cancel batch image processing tasks

Parameters

Name	Type	Required	Description
`id`	`string`	Required	The batch task job id to be canceled
`idempotency_key`	`string`	Optional	Optional dedup key; identical retries return the same result.

Returns

ImageJob { id, status }

Name	Type	Description
`cancelled`	`boolean`	Whether the resource was successfully cancelled
`job_id`	`string \| null`	Unique identifier for this async job `pattern: ^imgjob_[A-Za-z0-9]{20,}$`

Example

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

curl -X POST https://api.infrai.cc/v1/image/batch/cancel/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"job_id": "sample"}'

python

# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/batch/cancel/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'job_id': 'sample'},
)
resp.raise_for_status()
print(resp.json())

javascript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/batch/cancel/ID",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"job_id": "sample"}),
  },
);
console.log(await resp.json());

typescript

// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/batch/cancel/ID",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"job_id": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// Zero-install REST call — no SDK required (short-term the API is REST-only).
package main

import (
	"bytes"
	"fmt"
	"net/http"
	"os"
)

func main() {
	body := []byte(`{"job_id": "sample"}`)
	req, _ := http.NewRequest("POST", "https://api.infrai.cc/v1/image/batch/cancel/ID", bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("INFRAI_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()
	fmt.Println(resp.Status)
}

java

// Zero-install REST call — no SDK required (short-term the API is REST-only).
import java.net.URI;
import java.net.http.*;

HttpRequest req = HttpRequest.newBuilder()
    .uri(URI.create("https://api.infrai.cc/v1/image/batch/cancel/ID"))
    .header("Authorization", "Bearer " + System.getenv("INFRAI_API_KEY"))
    .header("Content-Type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\"job_id\": \"sample\"}"))
    .build();
HttpResponse<String> resp = HttpClient.newHttpClient()
    .send(req, HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());

csharp

// Zero-install REST call — no SDK required (short-term the API is REST-only).
using System;
using System.Net.Http;

var client = new HttpClient();
var req = new HttpRequestMessage(new HttpMethod("POST"), "https://api.infrai.cc/v1/image/batch/cancel/ID");
var key = Environment.GetEnvironmentVariable("INFRAI_API_KEY");
req.Headers.Add("Authorization", "Bearer " + key);
req.Content = new StringContent("{\"job_id\": \"sample\"}", System.Text.Encoding.UTF8, "application/json");
var resp = await client.SendAsync(req);
Console.WriteLine(await resp.Content.ReadAsStringAsync());

php

<?php
// Zero-install REST call — no SDK required (short-term the API is REST-only).
$ch = curl_init("https://api.infrai.cc/v1/image/batch/cancel/ID");
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer " . getenv("INFRAI_API_KEY"),
    "Content-Type: application/json",
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, "{\"job_id\": \"sample\"}");
$response = curl_exec($ch);
curl_close($ch);
echo $response;

ruby

# Zero-install REST call — no SDK required (short-term the API is REST-only).
require "net/http"
require "uri"

uri = URI("https://api.infrai.cc/v1/image/batch/cancel/ID")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri)
req["Authorization"] = "Bearer #{ENV['INFRAI_API_KEY']}"
req["Content-Type"] = "application/json"
req.body = '{"job_id": "sample"}'
res = http.request(req)
puts res.body

rust

// Zero-install REST call — no SDK required (short-term the API is REST-only). (uses the reqwest + tokio crates)
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let resp = reqwest::Client::new()
        .post("https://api.infrai.cc/v1/image/batch/cancel/ID")
        .header("Authorization", format!("Bearer {}", env::var("INFRAI_API_KEY")?))
        .header("Content-Type", "application/json")
        .body(r#"{"job_id": "sample"}"#)
        .send()
        .await?;
    println!("{}", resp.text().await?);
    Ok(())
}

3. All capabilities

Every routed capability in this module — the complete public REST contract. The methods above are the guided walkthrough; this index is the full reference.

image.background_removePOST /v1/image/background_remove

Transform an EXISTING image by AI-removing its background. To GENERATE images with AI use ai.image.

Parameters (3)

Name	Type	Required	Description
`image`	`object`	Required	Image data or reference for processing
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output or input format (e.g. json, csv, png)
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

image.batch.cancelPOST /v1/image/batch/cancel/{id}

Cancel a batch image-processing job by job ID; idempotent write.

Parameters (3)

Name	Type	Required	Description
`id`	`string`	Required	Path parameter.
`job_id`	`string`	Required	Id of the image batch job to cancel.
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

image.batch.statusGET /v1/image/batch/status/{id}

Get the progress and results of a batch image-processing job by job ID.

Parameters (1)

Name	Type	Required	Description
`id`	`string`	Required	Path parameter.

image.batch.submitPOST /v1/image/batch/submit

Submit a batch image-processing job and get a job handle, with optional webhook callback.

Parameters (4)

Name	Type	Required	Description
`items`	`object[]`	Required	Array of result items in this page `≥ 1 item`
`webhook_url`	`string \| null`	Optional	Optional completion callback; Infrai signs deliveries. `format: uri`
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry
`store`	`boolean`	Optional	Opt in to RETAIN the produced asset/record in Infrai's own store (default false = stateless passthrough: process, return inline, keep nothing). When true, Infrai persists the asset, bills a self-hosted storage line item and applies a retention TTL — and only then do the *.list/get/delete read caps see it. `default: false`

image.compressPOST /v1/image/compress

Transform an EXISTING image by compressing it to a target quality or byte size, optionally re-encoding. To GENERATE images with AI use ai.image.

Parameters (6)

Name	Type	Required	Description
`image`	`object`	Required	Image data or reference for processing
`quality`	`integer \| null`	Optional	Encoder quality 1-100; mutually informative with target_bytes. `1–100`
`target_bytes`	`integer \| null`	Optional	Compress to <= this byte budget via quality binary search. `≥ 1`
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output or input format (e.g. json, csv, png)
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry
`store`	`boolean`	Optional	Opt in to RETAIN the produced asset/record in Infrai's own store (default false = stateless passthrough: process, return inline, keep nothing). When true, Infrai persists the asset, bills a self-hosted storage line item and applies a retention TTL — and only then do the *.list/get/delete read caps see it. `default: false`

image.convertPOST /v1/image/convert

Transform an EXISTING image by re-encoding it to another format (jpeg/png/webp/avif). To GENERATE images with AI use ai.image.

Parameters (4)

Name	Type	Required	Description
`image`	`object`	Required	Image data or reference for processing
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Required	Output or input format (e.g. json, csv, png)
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry
`store`	`boolean`	Optional	Opt in to RETAIN the produced asset/record in Infrai's own store (default false = stateless passthrough: process, return inline, keep nothing). When true, Infrai persists the asset, bills a self-hosted storage line item and applies a retention TTL — and only then do the *.list/get/delete read caps see it. `default: false`

image.cropPOST /v1/image/crop

Transform an EXISTING image by cropping it to an x/y/w/h rectangle. To GENERATE images with AI use ai.image.

Parameters (8)

Name	Type	Required	Description
`image`	`object`	Required	Image data or reference for processing
`x`	`integer`	Required	X coordinate for crop origin `≥ 0`
`y`	`integer`	Required	Y coordinate for crop origin `≥ 0`
`width`	`integer`	Required	Width of the image in pixels `≥ 1`
`height`	`integer`	Required	Height of the image in pixels `≥ 1`
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output or input format (e.g. json, csv, png)
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry
`store`	`boolean`	Optional	Opt in to RETAIN the produced asset/record in Infrai's own store (default false = stateless passthrough: process, return inline, keep nothing). When true, Infrai persists the asset, bills a self-hosted storage line item and applies a retention TTL — and only then do the *.list/get/delete read caps see it. `default: false`

image.deleteDELETE /v1/image/delete/{id}

Delete a stored image asset by ID; idempotent write.

Parameters (1)

Name	Type	Required	Description
`id`	`string`	Required	Path parameter.

image.getGET /v1/image/get/{id}

Get the metadata of one stored image asset (URL, MIME type, dimensions, byte size) by ID.

Parameters (1)

Name	Type	Required	Description
`id`	`string`	Required	Path parameter.

image.metadataPOST /v1/image/metadata

Inspect an EXISTING image's metadata (dimensions, format, EXIF) without modifying it; read-only.

Parameters (1)

Name	Type	Required	Description
`image`	`object`	Required	Image data or reference for processing

image.moderatePOST /v1/image/moderate

Classify an image for unsafe content (adult/violence/etc.) returning a flagged verdict plus per-category flags/scores. Real vendor dispatch: Google Vision SafeSearch, Aliyun Green image scan. service_markup applies.

Parameters (2)

Name	Type	Required	Description
`image`	`string`	Required	Image as data URI, URL, or base64.
`vendor`	`"google" \| "aliyun"`	Optional	Optional vendor pin.

image.ocrPOST /v1/image/ocr

Extract text from an image (distinct from pdf.ocr) returning full text plus per-line blocks. Real vendor dispatch: Aliyun OCR, Baidu OCR, AWS Textract; self_hosted tesseract honestly degrades to a 503 when the binary is absent (no synthetic text).

Parameters (3)

Name	Type	Required	Description
`image`	`string`	Required	Image as data URI, URL, or base64.
`language`	`string`	Optional	Optional language hint (e.g. eng, chi_sim).
`vendor`	`"aliyun" \| "baidu" \| "aws" \| "self_hosted"`	Optional	Optional vendor pin.

image.processPOST /v1/image/process

Transform an EXISTING image through a chained pipeline of ops, re-encoded once at the end. To GENERATE images with AI use ai.image.

Parameters (5)

Name	Type	Required	Description
`image`	`object`	Required	The source image, as either inline bytes (url/base64) or a stable asset reference (image_id).
`ops`	`object[]`	Required	Ordered list of image operations to apply `1–20 items`
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output or input format (e.g. json, csv, png)
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry
`store`	`boolean`	Optional	Opt in to RETAIN the produced asset/record in Infrai's own store (default false = stateless passthrough: process, return inline, keep nothing). When true, Infrai persists the asset, bills a self-hosted storage line item and applies a retention TTL — and only then do the *.list/get/delete read caps see it. `default: false`

image.resizePOST /v1/image/resize

Transform an EXISTING image by resizing it with a fit mode and optional upscaling/format. To GENERATE images with AI use ai.image.

Parameters (8)

Name	Type	Required	Description
`image`	`object`	Required	Image data or reference for processing
`width`	`integer \| null`	Optional	Width of the image in pixels `≥ 1`
`height`	`integer \| null`	Optional	Height of the image in pixels `≥ 1`
`fit`	`"cover" \| "contain" \| "fill" \| "inside" \| "outside"`	Optional	Fit mode for resizing (cover, contain, fill, inside, outside)
`enlarge`	`boolean`	Optional	Allow upscaling beyond source dimensions; false (default) never upscales. `default: false`
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output or input format (e.g. json, csv, png)
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry
`store`	`boolean`	Optional	Opt in to RETAIN the produced asset/record in Infrai's own store (default false = stateless passthrough: process, return inline, keep nothing). When true, Infrai persists the asset, bills a self-hosted storage line item and applies a retention TTL — and only then do the *.list/get/delete read caps see it. `default: false`

image.rotatePOST /v1/image/rotate

Transform an EXISTING image by rotating it, optionally auto-correcting orientation from EXIF. To GENERATE images with AI use ai.image.

Parameters (5)

Name	Type	Required	Description
`image`	`object`	Required	Image data or reference for processing
`degrees`	`number`	Required	Clockwise rotation in degrees.
`auto_orient`	`boolean`	Optional	Apply EXIF orientation correction before rotating. `default: true`
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output or input format (e.g. json, csv, png)
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

image.smart_cropPOST /v1/image/smart_crop

Transform an EXISTING image with saliency-aware cropping to an aspect ratio, optionally targeting faces or subject. To GENERATE images with AI use ai.image.

Parameters (5)

Name	Type	Required	Description
`image`	`object`	Required	Image data or reference for processing
`aspect`	`string`	Required	Target aspect ratio, e.g. '1:1', '16:9'.
`target`	`string \| null`	Optional	Saliency target hint, e.g. 'face', 'auto'.
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output or input format (e.g. json, csv, png)
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

image.tagPOST /v1/image/tag

Detect labels/objects in an image returning label + confidence pairs. Real vendor dispatch: Google Vision LABEL_DETECTION, AWS Rekognition DetectLabels. service_markup applies.

Parameters (3)

Name	Type	Required	Description
`image`	`string`	Required	Image as data URI, URL, or base64.
`max_tags`	`integer`	Optional	Maximum number of tags to return `≥ 1default: 10`
`vendor`	`"google" \| "aws"`	Optional	Optional vendor pin.

image.transformation.createPOST /v1/image/transformation/create

Parameters (3)

Name	Type	Required	Description
`name`	`string`	Required	Human-readable name for this resource `1–128 chars`
`transform`	`object`	Required	Image transformation specification
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

image.transformation.listGET /v1/image/transformation/list

Page through the registered named image-transformation templates.

No request parameters.

image.uploadPOST /v1/image/upload

Upload an image and get an asset with an ID and URL for later processing.

Parameters (3)

Name	Type	Required	Description
`file`	`string`	Required	base64-encoded bytes (multipart is mapped to this field at the transport layer).
`filename`	`string \| null`	Optional	Filename for the uploaded image
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

image.watermarkPOST /v1/image/watermark

Transform an EXISTING image by overlaying a text or image watermark with position and opacity. To GENERATE images with AI use ai.image.

Parameters (7)

Name	Type	Required	Description
`image`	`object`	Required	Image data or reference for processing
`text`	`string \| null`	Optional	Text watermark content.
`watermark_image`	`object \| null`	Optional	Image watermark source (same ref shape as `image`); null when text is used.
`position`	`"top_left" \| "top" \| "top_right" \| "left" \| "center" \| "right" \| "bottom_left" \| "bottom" \| "bottom_right"`	Optional	Position for the watermark (e.g. top-left, center) `default: "bottom_right"`
`opacity`	`number`	Optional	Watermark opacity (0.0 to 1.0) `0–1default: 1`
`format`	`"auto" \| "webp" \| "avif" \| "jpeg" \| "png" \| "heic"`	Optional	Output or input format (e.g. json, csv, png)
`idempotency_key`	`string \| null`	Optional	Client-provided idempotency key; prevents duplicate execution on retry

4. End-to-end example

A production-style walkthrough of this module: configure once, then run the flow. It exercises most of the module's APIs.

A copy-paste-runnable single-file Python program (stdlib only, no SDK): set your INFRAI_API_KEY, run it, and walk this module's core flow with REAL billed calls — later steps reuse real fields returned by earlier ones. The 12-line helper is the entire integration.

python

#!/usr/bin/env python3
"""Infrai · image-process — runnable real-app example (single file, zero deps).

Copy this file, set your key, run it: every step is a REAL call to
api.infrai.cc, billed at the real (tiny) per-call price, printing the
live JSON response. Get a key at https://infrai.cc/login (Google/
GitHub sign-in grants $2 free credit); add funds at
https://infrai.cc/billing. No SDK — the 12-line helper below is the
entire integration."""
import json
import os
from urllib import error, request

KEY = os.environ.get("INFRAI_API_KEY") or "ifr_..."  # <- your key
BASE = "https://api.infrai.cc"


# Same raw HTTPS POST/GET as every per-method example on this page —
# wrapped once for reuse. There is nothing else to it: no SDK.
def infrai(method, path, body=None):
    req = request.Request(
        BASE + path, method=method,
        data=json.dumps(body).encode() if body is not None else None,
        headers={"Authorization": f"Bearer {KEY}",
                 "Content-Type": "application/json"})
    try:
        with request.urlopen(req, timeout=60) as r:
            return json.loads(r.read())
    except error.HTTPError as e:
        return json.loads(e.read())


def show(label, resp):
    print(f"\n== {label} ==")
    print(json.dumps(resp, indent=2, ensure_ascii=False))
    return resp


# 1) image.process — POST /v1/image/process · Transform an EXISTING image through a chained pipeline of ops, re-encoded once at the end. To GENERATE images with AI use ai.image.  # NOTE: non-trivial real cost
r1 = show("image.process", infrai("POST", "/v1/image/process", {"image":"sample","ops":[{"op":"resize"}]}))

# 2) image.metadata — POST /v1/image/metadata · Inspect an EXISTING image's metadata (dimensions, format, EXIF) without modifying it; read-only.
r2 = show("image.metadata", infrai("POST", "/v1/image/metadata", {"image":"sample"}))

One-time prep (each example is assumed to be complete):

bash

# No SDK to install — every call is a plain HTTPS request.
# Get a project key by signing in at https://infrai.cc/login (Google/GitHub gives
# you $2 free credit; email sign-in starts at $0). On 402 INSUFFICIENT_CREDIT, add
# funds at https://infrai.cc/billing (or POST /v1/account/topup and open the
# returned checkout_url).
export INFRAI_API_KEY="ifr_..."

bash

# 1) Auth: every call is a raw HTTPS request to the Infrai gateway carrying
#    only your project key. No SDK, no install.
#    Get your key: sign in with Google/GitHub at https://infrai.cc/login for a
#    project key + $2 free credit (email sign-in starts at $0). On 402
#    INSUFFICIENT_CREDIT, add funds at https://infrai.cc/billing (or POST
#    /v1/account/topup and open the returned checkout_url).
export INFRAI_API_KEY="ifr_..."   # from https://infrai.cc/login


# 2) image.process
curl -X POST https://api.infrai.cc/v1/image/process \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": "sample", "ops": [{"op": "resize"}]}'

# 3) image.metadata
curl -X POST https://api.infrai.cc/v1/image/metadata \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": "sample"}'

# 4) image.upload
curl -X POST https://api.infrai.cc/v1/image/upload \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"file": "sample"}'

# 5) image.get
curl -X GET https://api.infrai.cc/v1/image/get/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY"

# 6) image.delete
curl -X DELETE https://api.infrai.cc/v1/image/delete/ID \
  -H "Authorization: Bearer $INFRAI_API_KEY"

# 7) image.resize
curl -X POST https://api.infrai.cc/v1/image/resize \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": "sample"}'

# 8) image.crop
curl -X POST https://api.infrai.cc/v1/image/crop \
  -H "Authorization: Bearer $INFRAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"image": "sample", "x": 1, "y": 1, "width": 1, "height": 1}'

python

# 1) Auth: every call is a raw HTTPS request carrying only your project key.
#    No SDK to install — just the `requests` library.
import os, requests

BASE = "https://api.infrai.cc"
HEADERS = {
    "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    "Content-Type": "application/json",
}


# 2) image.process
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/process",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': 'sample', 'ops': [{'op': 'resize'}]},
)
resp.raise_for_status()
print(resp.json())

# 3) image.metadata
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/metadata",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': 'sample'},
)
resp.raise_for_status()
print(resp.json())

# 4) image.upload
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/upload",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'file': 'sample'},
)
resp.raise_for_status()
print(resp.json())

# 5) image.get
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.get(
    "https://api.infrai.cc/v1/image/get/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

# 6) image.delete
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.delete(
    "https://api.infrai.cc/v1/image/delete/ID",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
)
resp.raise_for_status()
print(resp.json())

# 7) image.resize
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/resize",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': 'sample'},
)
resp.raise_for_status()
print(resp.json())

# 8) image.crop
# Zero-install REST call — no SDK required (short-term the API is REST-only).
import os, requests

resp = requests.post(
    "https://api.infrai.cc/v1/image/crop",
    headers={
        "Authorization": f"Bearer {os.environ['INFRAI_API_KEY']}",
    },
    json={'image': 'sample', 'x': 1, 'y': 1, 'width': 1, 'height': 1},
)
resp.raise_for_status()
print(resp.json())

javascript

// 1) Auth: every call is a raw HTTPS request carrying only your project key.
//    No SDK to install — just the built-in fetch().
const BASE = "https://api.infrai.cc";
const HEADERS = {
  "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
  "Content-Type": "application/json",
};


// 2) image.process
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/process",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample", "ops": [{"op": "resize"}]}),
  },
);
console.log(await resp.json());

// 3) image.metadata
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/metadata",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample"}),
  },
);
console.log(await resp.json());

// 4) image.upload
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/upload",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"file": "sample"}),
  },
);
console.log(await resp.json());

// 5) image.get
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/get/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

// 6) image.delete
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/delete/ID",
  {
    method: "DELETE",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
console.log(await resp.json());

// 7) image.resize
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/resize",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample"}),
  },
);
console.log(await resp.json());

// 8) image.crop
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/crop",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample", "x": 1, "y": 1, "width": 1, "height": 1}),
  },
);
console.log(await resp.json());

typescript

// 1) Auth: every call is a raw HTTPS request carrying only your project key.
//    No SDK to install — just the built-in fetch(), typed.
const BASE = "https://api.infrai.cc";
const HEADERS: Record<string, string> = {
  "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
  "Content-Type": "application/json",
};


// 2) image.process
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/process",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample", "ops": [{"op": "resize"}]}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 3) image.metadata
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/metadata",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 4) image.upload
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/upload",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"file": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 5) image.get
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/get/ID",
  {
    method: "GET",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 6) image.delete
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/delete/ID",
  {
    method: "DELETE",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
    },
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 7) image.resize
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/resize",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample"}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

// 8) image.crop
// Zero-install REST call — no SDK required (short-term the API is REST-only).
const resp = await fetch(
  "https://api.infrai.cc/v1/image/crop",
  {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.INFRAI_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"image": "sample", "x": 1, "y": 1, "width": 1, "height": 1}),
  },
);
if (!resp.ok) throw new Error(`infrai ${resp.status}`);
const data: unknown = await resp.json();
console.log(data);

5. Developer guides

Move from endpoint details to complete workflows, production patterns and troubleshooting guides verified against the live API.

Image Processing developer guides