API Documentation

X-API-Key: <your-api-key>

Authorization: Bearer <your-jwt-token>

POST https://api.imagify.ca/api/images/generate

{
  "prompt": "A futuristic city at sunset",
  "size": "1024x1024",
  "style": "standard"
}

{
  "success": true,
  "image": {
    "id": "abc123def456...",
    "url": "https://cdn.imagify.ca/images/abc123def456.png",
    "prompt": "A futuristic city at sunset",
    "size": "1024x1024",
    "style": "standard",
    "createdAt": "2026-01-15T10:30:00Z"
  },
  "credits_remaining": 9
}

import requests
import json

API_KEY = "YOUR_API_KEY"
url = "https://api.imagify.ca/api/images/generate"

headers = {
    "X-API-Key": API_KEY,
    "Content-Type": "application/json"
}

data = {
    "prompt": "A futuristic city at sunset with neon lights",
    "size": "1024x1024",
    "style": "standard"
}

response = requests.post(url, headers=headers, json=data)
result = response.json()

if result.get("success"):
    image_url = result["image"]["url"]
    print(f"Image generated: {image_url}")
    
    # Download and save the image
    img_response = requests.get(image_url)
    with open("generated_image.png", "wb") as f:
        f.write(img_response.content)
    print("Image saved as generated_image.png")
else:
    print(f"Error: {result.get('error')}")

import aiohttp
import asyncio
import aiofiles

async def generate_image():
    API_KEY = "YOUR_API_KEY"
    url = "https://api.imagify.ca/api/images/generate"
    
    headers = {
        "X-API-Key": API_KEY,
        "Content-Type": "application/json"
    }
    
    data = {
        "prompt": "A futuristic city at sunset with neon lights",
        "size": "1024x1024",
        "style": "standard"
    }
    
    async with aiohttp.ClientSession() as session:
        async with session.post(url, headers=headers, json=data) as response:
            result = await response.json()
            
            if result.get("success"):
                image_url = result["image"]["url"]
                print(f"Image generated: {image_url}")
                
                # Download and save the image
                async with session.get(image_url) as img_response:
                    async with aiofiles.open("generated_image.png", "wb") as f:
                        await f.write(await img_response.read())
                print("Image saved as generated_image.png")
            else:
                print(f"Error: {result.get('error')}")

# Run the async function
asyncio.run(generate_image())

const axios = require('axios');
const fs = require('fs');
const https = require('https');

const API_KEY = 'YOUR_API_KEY';
const url = 'https://api.imagify.ca/api/images/generate';

axios.post(url, {
  prompt: 'A futuristic city at sunset with neon lights',
  size: '1024x1024',
  style: 'standard'
}, {
  headers: {
    'X-API-Key': API_KEY,
    'Content-Type': 'application/json'
  }
})
.then(response => {
  const imageUrl = response.data.image.url;
  console.log('Image generated:', imageUrl);
  
  // Download and save the image
  https.get(imageUrl, (res) => {
    const fileStream = fs.createWriteStream('generated_image.png');
    res.pipe(fileStream);
    fileStream.on('finish', () => {
      console.log('Image saved as generated_image.png');
    });
  });
})
.catch(error => {
  console.error('Error:', error.response?.data?.error || error.message);
});

const fs = require('fs');
const https = require('https');

const API_KEY = 'YOUR_API_KEY';
const url = 'https://api.imagify.ca/api/images/generate';

async function generateImage() {
  try {
    const response = await fetch(url, {
      method: 'POST',
      headers: {
        'X-API-Key': API_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        prompt: 'A futuristic city at sunset with neon lights',
        size: '1024x1024',
        style: 'standard'
      })
    });
    
    const result = await response.json();
    
    if (result.success) {
      const imageUrl = result.image.url;
      console.log('Image generated:', imageUrl);
      
      // Download and save the image
      https.get(imageUrl, (res) => {
        const fileStream = fs.createWriteStream('generated_image.png');
        res.pipe(fileStream);
        fileStream.on('finish', () => {
          console.log('Image saved as generated_image.png');
        });
      });
    } else {
      console.error('Error:', result.error);
    }
  } catch (error) {
    console.error('Error:', error.message);
  }
}

generateImage();

<?php
$apiKey = 'YOUR_API_KEY';
$url = 'https://api.imagify.ca/api/images/generate';

$data = [
    'prompt' => 'A futuristic city at sunset with neon lights',
    'size' => '1024x1024',
    'style' => 'standard'
];

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'X-API-Key: ' . $apiKey,
    'Content-Type: application/json'
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);

$result = json_decode($response, true);

if ($result && isset($result['success']) && $result['success']) {
    $imageUrl = $result['image']['url'];
    echo "Image generated: $imageUrl
";
    
    // Download and save the image
    $imageData = file_get_contents($imageUrl);
    file_put_contents('generated_image.png', $imageData);
    echo "Image saved as generated_image.png
";
} else {
    echo "Error: " . ($result['error'] ?? 'Unknown error') . "
";
}
?>

require 'net/http'
require 'json'
require 'uri'

api_key = 'YOUR_API_KEY'
url = URI('https://api.imagify.ca/api/images/generate')

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request['X-API-Key'] = api_key
request['Content-Type'] = 'application/json'
request.body = {
  prompt: 'A futuristic city at sunset with neon lights',
  size: '1024x1024',
  style: 'standard'
}.to_json

response = http.request(request)
result = JSON.parse(response.body)

if result['success']
  image_url = result['image']['url']
  puts "Image generated: #{image_url}"
  
  # Download and save the image
  image_uri = URI(image_url)
  image_response = Net::HTTP.get_response(image_uri)
  File.write('generated_image.png', image_response.body)
  puts "Image saved as generated_image.png"
else
  puts "Error: #{result['error']}"
end

package main

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

func main() {
    apiKey := "YOUR_API_KEY"
    url := "https://api.imagify.ca/api/images/generate"
    
    data := map[string]interface{}{
        "prompt": "A futuristic city at sunset with neon lights",
        "size":   "1024x1024",
        "style":  "standard",
    }
    
    jsonData, _ := json.Marshal(data)
    req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("X-API-Key", apiKey)
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    
    if success, ok := result["success"].(bool); ok && success {
        imageData := result["image"].(map[string]interface{})
        imageURL := imageData["url"].(string)
        fmt.Println("Image generated:", imageURL)
        
        // Download and save the image
        imgResp, _ := http.Get(imageURL)
        defer imgResp.Body.Close()
        
        file, _ := os.Create("generated_image.png")
        defer file.Close()
        
        io.Copy(file, imgResp.Body)
        fmt.Println("Image saved as generated_image.png")
    } else {
        fmt.Println("Error:", result["error"])
    }
}

// JavaScript - Batch generation with rate limit handling
async function generateBatch(prompts) {
  const results = [];
  const delay = 1000; // 1 second between requests to avoid rate limits
  
  for (const prompt of prompts) {
    try {
      const result = await generateImage(prompt);
      results.push(result);
      await new Promise(resolve => setTimeout(resolve, delay));
    } catch (error) {
      console.error(`Failed to generate: ${prompt}`, error);
      results.push({ error, prompt });
    }
  }
  
  return results;
}

GET https://api.imagify.ca/api/images/history?page=1&limit=20