Imference API – Documentation

Reference for the public endpoints used to generate and retrieve images with your api_key.

Looking for the pricing & quick start page? Go back to index →

GET /credits/balance

Returns the remaining credits for the authenticated user.

curl -X GET \
  'https://imference.com/credits/balance' \
  -H 'Authorization: Bearer <API_KEY>'

package main

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

func main() {
  req, err := http.NewRequest("GET", "https://imference.com/credits/balance", nil)
  if err != nil {
    panic(err)
  }

  req.Header.Set("Authorization", "Bearer <API_KEY>")

  res, err := http.DefaultClient.Do(req)
  if err != nil {
    panic(err)
  }
  defer res.Body.Close()

  body, _ := io.ReadAll(res.Body)
  fmt.Println(string(body))
}

import requests

url = "https://imference.com/credits/balance"
headers = {
    "Authorization": "Bearer <API_KEY>",
}

response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const apiKey = "<API_KEY>";

fetch("https://imference.com/credits/balance", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${apiKey}`,
  },
})
  .then((res) => res.json())
  .then((data) => console.log(data))
  .catch(console.error);

const apiKey: string = "<API_KEY>";

async function getBalance() {
  const res = await fetch("https://imference.com/credits/balance", {
    method: "GET",
    headers: {
      Authorization: `Bearer ${apiKey}`,
    },
  });

  if (!res.ok) {
    throw new Error(`HTTP ${res.status}`);
  }

  const data = await res.json();
  console.log(data);
}

getBalance().catch(console.error);

Live response Uses your saved API key

POST /image/generate

Queue a new image generation for a given model and text description.

Model (code from index table)

Prompt

curl -X POST \
  'https://imference.com/image/generate' \
  -H 'Authorization: Bearer <API_KEY>' \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "illustrious-hassuka-xl",
    "prompt": "A cat astronaut floating in space"
  }'

package main

import (
  "bytes"
  "encoding/json"
  "fmt"
  "io"
  "net/http"
)

func main() {
  body := map[string]string{
    "model":  "illustrious-hassuka-xl",
    "prompt": 
      "A cat astronaut floating in space",
  }

  payload, _ := json.Marshal(body)

  req, err := http.NewRequest(
      "POST", 
      "https://imference.com/image/generate", 
      bytes.NewReader(payload),
    )
  if err != nil {
    panic(err)
  }

  req.Header.Set("Authorization", "Bearer <API_KEY>")
  req.Header.Set("Content-Type", "application/json")

  res, err := http.DefaultClient.Do(req)
  if err != nil {
    panic(err)
  }
  defer res.Body.Close()

  b, _ := io.ReadAll(res.Body)
  fmt.Println(string(b))
}

import requests

url = "https://imference.com/image/generate"
headers = {
    "Authorization": "Bearer <API_KEY>",
    "Content-Type": "application/json",
}
json_data = {
    "model": "illustrious-hassuka-xl",
    "prompt": "A cat astronaut floating in space",
}

response = requests.post(url, headers=headers, json=json_data)
print(response.status_code, response.json())

const apiKey = "<API_KEY>";

const payload = {
  model: "illustrious-hassuka-xl",
  prompt: "A cat astronaut floating in space",
};

fetch("https://imference.com/image/generate", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
})
  .then((res) => res.json())
  .then((data) => console.log("request_id:", data.request_id))
  .catch(console.error);

interface GeneratePayload {
  model: string;
  prompt: string;
}

const apiKey: string = "<API_KEY>";

async function generateImage() {
  const payload: GeneratePayload = {
    model: "illustrious-hassuka-xl",
    prompt: "A cat astronaut floating in space",
  };

  const res = await fetch("https://imference.com/image/generate", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${apiKey}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(payload),
  });

  const data = await res.json();
  console.log("request_id:", data.request_id);
}

generateImage().catch(console.error);

Live response The response contains a request_id.

GET /image/status

Look up the status of an image generation by its request_id.

Request ID (from /image/generate response)

curl -X GET \
  'https://imference.com/image/status?request_id=<REQUEST_ID>' \
  -H 'Authorization: Bearer <API_KEY>'

package main

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

func main() {
  requestID := "<REQUEST_ID>"
  url := "https://imference.com/image/status?request_id=" + requestID

  req, _ := http.NewRequest("GET", url, nil)
  req.Header.Set("Authorization", "Bearer <API_KEY>")

  res, err := http.DefaultClient.Do(req)
  if err != nil {
    panic(err)
  }
  defer res.Body.Close()

  body, _ := io.ReadAll(res.Body)
  fmt.Println(string(body))
}

import requests

request_id = "<REQUEST_ID>"
url = f"https://imference.com/image/status?request_id={request_id}"
headers = {"Authorization": "Bearer <API_KEY>"}

response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const apiKey = "<API_KEY>";
const requestId = "<REQUEST_ID>";

fetch(`https://imference.com/image/status?request_id=${requestId}`, {
  method: "GET",
  headers: {
    Authorization: `Bearer ${apiKey}`,
  },
})
  .then((res) => res.json())
  .then((data) => console.log(data))
  .catch(console.error);

const apiKey: string = "<API_KEY>";
const requestId: string = "<REQUEST_ID>";

async function getStatus() {
  const res = await fetch(
    `https://imference.com/image/status?request_id=${requestId}`,
    {
      method: "GET",
      headers: {
        Authorization: `Bearer ${apiKey}`,
      },
    },
  );

  const data = await res.json();
  console.log(data);
}

getStatus().catch(console.error);

Live response Returns image metadata and URL if ready; 404 if not found/not ready.

GET /image/all

Retrieve all images generated for the authenticated API key.

curl -X GET \
  'https://imference.com/image/all' \
  -H 'Authorization: Bearer <API_KEY>'

package main

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

func main() {
  req, _ := http.NewRequest("GET", "https://imference.com/image/all", nil)
  req.Header.Set("Authorization", "Bearer <API_KEY>")

  res, err := http.DefaultClient.Do(req)
  if err != nil {
    panic(err)
  }
  defer res.Body.Close()

  body, _ := io.ReadAll(res.Body)
  fmt.Println(string(body))
}

import requests

url = "https://imference.com/image/all"
headers = {"Authorization": "Bearer <API_KEY>"}

response = requests.get(url, headers=headers)
print(response.status_code, response.json())

const apiKey = "<API_KEY>";

fetch("https://imference.com/image/all", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${apiKey}`,
  },
})
  .then((res) => res.json())
  .then((data) => console.log(data))
  .catch(console.error);

const apiKey: string = "<API_KEY>";

async function getAllImages() {
  const res = await fetch("https://imference.com/image/all", {
    method: "GET",
    headers: {
      Authorization: `Bearer ${apiKey}`,
    },
  });

  const data = await res.json();
  console.log(data);
}

getAllImages().catch(console.error);

Live response Returns an array of image objects with URLs, formats, seeds, and timestamps.

Imference API – Documentation

Authentication & Base URL

Endpoints