Image API (Image Generation)

The Image API provides powerful AI image generation, editing, and analysis capabilities, supporting text-to-image generation, image variation creation, image editing, and more.

Endpoint


POST https://aiapi.services/v1/images/generations

Authentication

All requests must include your API key in the HTTP header:


Authorization: Bearer YOUR_API_KEY

Supported Models

Imagen 4.0 Series

imagen-4.0-ultra-generate-001 - Imagen 4.0 Ultra, highest quality image generation
imagen-4.0-generate-001 - Imagen 4.0 standard version, high-quality image generation
imagen-4.0-fast-generate-001 - Imagen 4.0 fast version, optimized generation speed

Imagen 3.0 Series

imagen-3.0-generate-002 - Imagen 3.0 standard version (v2), mature and stable image generation
imagen-3.0-fast-generate-001 - Imagen 3.0 fast version, rapid image generation

See Available Models for complete model list.

Request Parameters

Required Parameters

Parameter	Type	Description
`prompt`	string	Image description text, describing the image you want to generate in detail
`model`	string	Model ID to use, e.g., `imagen-4.0-generate-001`

Optional Parameters

Parameter	Type	Default	Description
`n`	integer	1	Number of images to generate (1-10)
`size`	string	`1024x1024`	Image size, supports `256x256`, `512x512`, `1024x1024`, `1024x1792`, `1792x1024`
`quality`	string	`standard`	Image quality: `standard` or `hd`
`style`	string	`vivid`	Image style: `vivid` or `natural`
`response_format`	string	`url`	Return format: `url` or `b64_json`
`user`	string	-	Unique identifier for end user

Code Examples

cURL


curl https://aiapi.services/v1/images/generations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "imagen-4.0-generate-001",
    "prompt": "A cute orange cat sitting on a windowsill watching the rain outside, watercolor style",
    "n": 1,
    "size": "1024x1024",
    "quality": "hd"
  }'

Python


import requests
 
response = requests.post(
  'https://aiapi.services/v1/images/generations',
  headers={
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  json={
    'model': 'imagen-4.0-generate-001',
    'prompt': 'A cute orange cat sitting on a windowsill watching the rain outside, watercolor style',
    'n': 1,
    'size': '1024x1024',
    'quality': 'hd'
  }
)
 
data = response.json()
image_url = data['data'][0]['url']
print(f'Image URL: {image_url}')
 
# Download image
import urllib.request
urllib.request.urlretrieve(image_url, 'generated_image.png')
print('Image saved as generated_image.png')

JavaScript


const response = await fetch('https://aiapi.services/v1/images/generations', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    model: 'imagen-4.0-generate-001',
    prompt: 'A cute orange cat sitting on a windowsill watching the rain outside, watercolor style',
    n: 1,
    size: '1024x1024',
    quality: 'hd'
  })
});
 
const data = await response.json();
console.log('Image URL:', data.data[0].url);

Go


package main
 
import (
  "bytes"
  "encoding/json"
  "fmt"
  "io"
  "net/http"
)
 
func main() {
  url := "https://aiapi.services/v1/images/generations"
 
  payload := map[string]interface{}{
    "model": "imagen-4.0-generate-001",
    "prompt": "A cute orange cat sitting on a windowsill watching the rain outside, watercolor style",
    "n": 1,
    "size": "1024x1024",
    "quality": "hd",
  }
 
  jsonData, _ := json.Marshal(payload)
 
  req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
  req.Header.Set("Authorization", "Bearer YOUR_API_KEY")
  req.Header.Set("Content-Type", "application/json")
 
  client := &http.Client{}
  resp, _ := client.Do(req)
  defer resp.Body.Close()
 
  body, _ := io.ReadAll(resp.Body)
  fmt.Println(string(body))
}

Rust


use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION, CONTENT_TYPE};
use serde_json::json;
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();
 
    let mut headers = HeaderMap::new();
    headers.insert(AUTHORIZATION, HeaderValue::from_static("Bearer YOUR_API_KEY"));
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
 
    let payload = json!({
        "model": "imagen-4.0-generate-001",
        "prompt": "A cute orange cat sitting on a windowsill watching the rain outside, watercolor style",
        "n": 1,
        "size": "1024x1024",
        "quality": "hd"
    });
 
    let response = client
        .post("https://aiapi.services/v1/images/generations")
        .headers(headers)
        .json(&payload)
        .send()
        .await?;
 
    let data: serde_json::Value = response.json().await?;
    println!("Image URL: {}", data["data"][0]["url"]);
 
    Ok(())
}

PHP


<?php
 
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://aiapi.services/v1/images/generations");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    "Authorization: Bearer YOUR_API_KEY",
    "Content-Type: application/json"
]);
 
$data = [
    "model" => "imagen-4.0-generate-001",
    "prompt" => "A cute orange cat sitting on a windowsill watching the rain outside, watercolor style",
    "n" => 1,
    "size" => "1024x1024",
    "quality" => "hd"
];
 
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
 
$response = curl_exec($ch);
curl_close($ch);
 
$result = json_decode($response, true);
$image_url = $result['data'][0]['url'];
echo "Image URL: " . $image_url . "\n";
 
// Download image
file_put_contents('generated_image.png', file_get_contents($image_url));
echo "Image saved as generated_image.png\n";
?>

Ruby


require 'net/http'
require 'json'
require 'open-uri'
 
uri = URI('https://aiapi.services/v1/images/generations')
request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer YOUR_API_KEY'
request['Content-Type'] = 'application/json'
 
request.body = {
  model: 'imagen-4.0-generate-001',
  prompt: 'A cute orange cat sitting on a windowsill watching the rain outside, watercolor style',
  n: 1,
  size: '1024x1024',
  quality: 'hd'
}.to_json
 
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end
 
data = JSON.parse(response.body)
image_url = data['data'][0]['url']
puts "Image URL: #{image_url}"
 
# Download image
File.write('generated_image.png', URI.open(image_url).read)
puts "Image saved as generated_image.png"

Response Format

Standard Response


{
  "created": 1702548600,
  "data": [
    {
      "url": "https://oaidalleapiprodscus.blob.core.windows.net/private/...",
      "revised_prompt": "A watercolor painting depicting an adorable orange cat sitting on a windowsill, gazing at the rain outside. Raindrops form beautiful patterns on the glass..."
    }
  ]
}

Base64 Response (response_format: “b64_json”)


{
  "created": 1702548600,
  "data": [
    {
      "b64_json": "iVBORw0KGgoAAAANSUhEUgAA...",
      "revised_prompt": "A watercolor painting..."
    }
  ]
}

Response Field Descriptions

Field	Type	Description
`created`	integer	Creation timestamp
`data`	array	Array of generated images
`data[].url`	string	Image URL (valid for 24 hours)
`data[].b64_json`	string	Base64-encoded image data
`data[].revised_prompt`	string	Model-optimized prompt

Authentication - Learn how to get and use API keys
Available Models - View all supported models and pricing
Usage Query - Query API usage and quota
Embeddings API - Text embedding vector generation
Audio API - Speech recognition and text-to-speech