Create Images with AI

Generate high-quality images from text descriptions using state-of-the-art AI image generation models. Perfect for creative projects, marketing content, prototyping, and visual storytelling.

Overview

AI image generation allows you to:

Create original artwork from text descriptions
Generate marketing visuals for campaigns and content
Prototype designs quickly and efficiently
Visualize concepts that are hard to describe
Produce variations of existing ideas

Text-to-Image

Generate images from detailed text prompts

Style Control

Create images in specific artistic styles

High Resolution

Generate images up to 2048x2048 pixels

Multiple Models

Choose from DALL-E, Flux, Stable Diffusion, and more

Quick Start

import requests
import base64
from PIL import Image
import io

def generate_image(prompt, model="google/gemini-2.5-flash-image", size="1024x1024"):
    """Generate an image from a text prompt"""
    
    response = requests.post(
        "https://api.anyapi.ai/v1/images/generations",
        headers={
            "Authorization": "Bearer your_api_key",
            "Content-Type": "application/json"
        },
        json={
            "model": model,
            "prompt": prompt,
            "size": size,
            "quality": "hd",
            "n": 1
        }
    )
    
    result = response.json()
    image_url = result["data"][0]["url"]
    
    # Download and save the image
    image_response = requests.get(image_url)
    image = Image.open(io.BytesIO(image_response.content))
    
    return image, image_url

# Usage examples
image, url = generate_image(
    "A serene mountain landscape at sunset with a crystal clear lake reflecting the mountains and sky"
)

# Save the image
image.save("mountain_landscape.png")
print(f"Image generated and saved! URL: {url}")

# Generate with different model
image2, url2 = generate_image(
    "A futuristic cityscape with flying cars and neon lights",
    model="flux-pro",
    size="1792x1024"
)
image2.save("futuristic_city.png")

async function generateImage(prompt, model = 'google/gemini-2.5-flash-image', size = '1024x1024') {
  const response = await fetch('https://api.anyapi.ai/v1/images/generations', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer your_api_key',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: model,
      prompt: prompt,
      size: size,
      quality: 'hd',
      n: 1
    })
  });

  const result = await response.json();
  return result.data[0].url;
}

// Usage
generateImage('A magical forest with glowing mushrooms and fairy lights')
  .then(imageUrl => {
    console.log('Image generated:', imageUrl);
    
    // Display in HTML
    const img = document.createElement('img');
    img.src = imageUrl;
    img.style.maxWidth = '100%';
    document.body.appendChild(img);
  });

// Generate multiple variations
async function generateVariations(basePrompt, variations) {
  const images = [];
  
  for (const variation of variations) {
    const fullPrompt = `${basePrompt}, ${variation}`;
    const imageUrl = await generateImage(fullPrompt);
    images.push({ prompt: fullPrompt, url: imageUrl });
  }
  
  return images;
}

// Example usage
const variations = [
  'in watercolor style',
  'in digital art style', 
  'in photorealistic style',
  'in minimalist style'
];

generateVariations('A cute robot character', variations)
  .then(images => {
    images.forEach(img => {
      console.log(`${img.prompt}: ${img.url}`);
    });
  });

Advanced Image Generation

Creative Prompt Engineering

class ImagePromptGenerator:
    def __init__(self, api_key):
        self.api_key = api_key
        
    def enhance_prompt(self, basic_prompt):
        """Enhance a basic prompt with detailed descriptions"""
        
        enhancement_request = f"""
        Enhance this basic image prompt with rich, detailed descriptions:
        "{basic_prompt}"
        
        Add details about:
        - Visual style and artistic technique
        - Lighting and atmosphere
        - Colors and composition
        - Camera angle and perspective
        - Mood and emotion
        - Technical photography details
        
        Create a detailed prompt that will generate a stunning image.
        Keep it under 400 characters for optimal results.
        """
        
        response = requests.post(
            "https://api.anyapi.ai/v1/chat/completions",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            },
            json={
                "model": "openai/gpt-4o-mini",
                "messages": [
                    {
                        "role": "system",
                        "content": "You are an expert at writing image generation prompts. Create detailed, visual descriptions that will produce amazing images."
                    },
                    {"role": "user", "content": enhancement_request}
                ],
                "temperature": 0.8
            }
        )
        
        return response.json()["choices"][0]["message"]["content"]
    
    def generate_with_enhanced_prompt(self, basic_prompt, model="google/gemini-2.5-flash-image"):
        """Generate image with AI-enhanced prompt"""
        
        enhanced_prompt = self.enhance_prompt(basic_prompt)
        print(f"Enhanced prompt: {enhanced_prompt}")
        
        response = requests.post(
            "https://api.anyapi.ai/v1/images/generations",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            },
            json={
                "model": model,
                "prompt": enhanced_prompt,
                "size": "1024x1024",
                "quality": "hd"
            }
        )
        
        result = response.json()
        return result["data"][0]["url"], enhanced_prompt

# Usage
prompt_generator = ImagePromptGenerator("your_api_key")

# Basic prompt
basic_prompt = "a cat wearing a hat"

# Generate with enhancement
image_url, enhanced = prompt_generator.generate_with_enhanced_prompt(basic_prompt)
print(f"Generated image: {image_url}")
print(f"Enhanced prompt: {enhanced}")

Style Transfer and Artistic Techniques

class ArtisticImageGenerator:
    def __init__(self, api_key):
        self.api_key = api_key
        
        self.art_styles = {
            "impressionist": "in the style of Claude Monet, impressionist brushstrokes, soft colors, outdoor lighting",
            "surreal": "surrealist art style, dreamlike, impossible geometry, Salvador Dali inspired",
            "cyberpunk": "cyberpunk aesthetic, neon colors, dystopian future, high-tech low-life",
            "watercolor": "watercolor painting, soft edges, transparent colors, artistic brushstrokes",
            "oil_painting": "classical oil painting, rich textures, realistic details, museum quality",
            "anime": "anime art style, vibrant colors, expressive characters, Japanese animation",
            "pixel_art": "8-bit pixel art style, retro gaming aesthetic, limited color palette",
            "photorealistic": "photorealistic, high detail, professional photography, crisp focus",
            "minimalist": "minimalist design, clean lines, simple composition, negative space",
            "vintage": "vintage photography, aged colors, film grain, nostalgic mood"
        }
        
        self.camera_angles = {
            "portrait": "portrait orientation, close-up shot",
            "landscape": "landscape orientation, wide shot",
            "aerial": "aerial view, bird's eye perspective, drone photography",
            "macro": "macro photography, extreme close-up, detailed textures",
            "wide_angle": "wide-angle lens, expansive view, dramatic perspective",
            "telephoto": "telephoto lens, compressed perspective, shallow depth of field"
        }
    
    def generate_artistic_image(self, subject, style_key, camera_key=None, additional_details=""):
        """Generate image with specific artistic style"""
        
        style = self.art_styles.get(style_key, "")
        camera = self.camera_angles.get(camera_key, "") if camera_key else ""
        
        prompt = f"{subject}, {style}"
        if camera:
            prompt += f", {camera}"
        if additional_details:
            prompt += f", {additional_details}"
        
        response = requests.post(
            "https://api.anyapi.ai/v1/images/generations",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            },
            json={
                "model": "google/gemini-2.5-flash-image",
                "prompt": prompt,
                "size": "1024x1024",
                "quality": "hd"
            }
        )
        
        result = response.json()
        return result["data"][0]["url"], prompt
    
    def create_style_variations(self, subject, styles_list):
        """Create multiple style variations of the same subject"""
        
        variations = []
        
        for style in styles_list:
            try:
                image_url, full_prompt = self.generate_artistic_image(subject, style)
                variations.append({
                    "style": style,
                    "url": image_url,
                    "prompt": full_prompt
                })
                print(f"Generated {style} version: {image_url}")
            except Exception as e:
                print(f"Failed to generate {style} version: {e}")
        
        return variations

# Usage
art_generator = ArtisticImageGenerator("your_api_key")

# Generate single artistic image
subject = "a majestic eagle soaring over snow-capped mountains"
image_url, prompt = art_generator.generate_artistic_image(
    subject, 
    "impressionist", 
    "landscape",
    "golden hour lighting, dramatic clouds"
)

print(f"Impressionist eagle: {image_url}")

# Generate style variations
styles = ["photorealistic", "watercolor", "cyberpunk", "anime", "oil_painting"]
variations = art_generator.create_style_variations(
    "a wise old wizard reading a glowing book",
    styles
)

for var in variations:
    print(f"{var['style']}: {var['url']}")

Product and Marketing Image Generation

class MarketingImageGenerator:
    def __init__(self, api_key):
        self.api_key = api_key
    
    def generate_product_mockup(self, product_description, setting="modern studio"):
        """Generate product mockup images"""
        
        mockup_prompts = {
            "modern_studio": "professional product photography, clean white background, studio lighting, high-end commercial style",
            "lifestyle": "lifestyle photography, natural setting, people using the product, authentic atmosphere",
            "minimalist": "minimalist product shot, simple background, clean aesthetic, negative space",
            "luxury": "luxury product photography, elegant setting, premium materials, sophisticated lighting"
        }
        
        style = mockup_prompts.get(setting, mockup_prompts["modern_studio"])
        
        prompt = f"{product_description}, {style}, product photography, high resolution, commercial quality"
        
        response = requests.post(
            "https://api.anyapi.ai/v1/images/generations",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            },
            json={
                "model": "google/gemini-2.5-flash-image",
                "prompt": prompt,
                "size": "1024x1024",
                "quality": "hd"
            }
        )
        
        result = response.json()
        return result["data"][0]["url"]
    
    def generate_social_media_content(self, theme, platform="instagram"):
        """Generate social media optimized images"""
        
        platform_specs = {
            "instagram": {
                "size": "1024x1024",
                "style": "Instagram-ready, vibrant colors, eye-catching composition, social media optimized"
            },
            "facebook": {
                "size": "1200x630", 
                "style": "Facebook cover style, wide composition, engaging visual"
            },
            "twitter": {
                "size": "1200x675",
                "style": "Twitter header style, clean design, professional look"
            },
            "linkedin": {
                "size": "1128x640",
                "style": "LinkedIn professional style, business appropriate, sophisticated"
            }
        }
        
        spec = platform_specs.get(platform, platform_specs["instagram"])
        
        prompt = f"{theme}, {spec['style']}, high quality, social media ready"
        
        response = requests.post(
            "https://api.anyapi.ai/v1/images/generations",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            },
            json={
                "model": "google/gemini-2.5-flash-image",
                "prompt": prompt,
                "size": spec["size"],
                "quality": "hd"
            }
        )
        
        result = response.json()
        return result["data"][0]["url"]
    
    def generate_marketing_campaign(self, campaign_theme, variations=3):
        """Generate a complete marketing campaign with multiple image variations"""
        
        campaign_angles = [
            "hero shot, dramatic lighting, premium feel",
            "lifestyle approach, people enjoying the product/service, authentic",
            "close-up detail shot, texture and quality focus",
            "wide environmental shot, context and scale",
            "creative artistic interpretation, abstract elements"
        ]
        
        campaign_images = []
        
        for i in range(variations):
            angle = campaign_angles[i % len(campaign_angles)]
            
            prompt = f"{campaign_theme}, {angle}, marketing photography, professional quality, brand-focused"
            
            response = requests.post(
                "https://api.anyapi.ai/v1/images/generations",
                headers={
                    "Authorization": f"Bearer {self.api_key}",
                    "Content-Type": "application/json"
                },
                json={
                    "model": "google/gemini-2.5-flash-image",
                    "prompt": prompt,
                    "size": "1024x1024",
                    "quality": "hd"
                }
            )
            
            result = response.json()
            campaign_images.append({
                "angle": angle,
                "url": result["data"][0]["url"],
                "prompt": prompt
            })
        
        return campaign_images

# Usage
marketing_gen = MarketingImageGenerator("your_api_key")

# Product mockup
product_url = marketing_gen.generate_product_mockup(
    "sleek wireless headphones with noise cancellation",
    "luxury"
)
print(f"Product mockup: {product_url}")

# Social media content
social_url = marketing_gen.generate_social_media_content(
    "celebrating innovation in technology",
    "instagram"
)
print(f"Social media image: {social_url}")

# Marketing campaign
campaign = marketing_gen.generate_marketing_campaign(
    "eco-friendly sustainable fashion brand launch",
    3
)

for img in campaign:
    print(f"{img['angle']}: {img['url']}")

Creative Workflow Automation

class CreativeWorkflow:
    def __init__(self, api_key):
        self.api_key = api_key
        self.project_history = []
    
    def brainstorm_concepts(self, project_brief):
        """Generate multiple creative concepts for a project"""
        
        brainstorm_prompt = f"""
        Given this creative brief: "{project_brief}"
        
        Generate 5 diverse creative concepts with:
        1. A catchy concept name
        2. Visual description for image generation
        3. Target mood/emotion
        4. Color palette suggestion
        5. Key visual elements
        
        Make each concept unique and creative.
        """
        
        response = requests.post(
            "https://api.anyapi.ai/v1/chat/completions",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            },
            json={
                "model": "openai/gpt-4o",
                "messages": [
                    {
                        "role": "system",
                        "content": "You are a creative director generating innovative visual concepts."
                    },
                    {"role": "user", "content": brainstorm_prompt}
                ],
                "temperature": 0.8
            }
        )
        
        return response.json()["choices"][0]["message"]["content"]
    
    def concept_to_image(self, concept_description):
        """Convert a concept description to an actual image"""
        
        # Extract visual elements for prompt
        image_prompt = f"{concept_description}, high quality, creative design, professional artwork"
        
        response = requests.post(
            "https://api.anyapi.ai/v1/images/generations",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            },
            json={
                "model": "google/gemini-2.5-flash-image",
                "prompt": image_prompt,
                "size": "1024x1024",
                "quality": "hd"
            }
        )
        
        result = response.json()
        return result["data"][0]["url"]
    
    def create_mood_board(self, theme, num_images=6):
        """Create a mood board with multiple related images"""
        
        mood_variations = [
            f"{theme}, inspirational mood",
            f"{theme}, dramatic lighting",
            f"{theme}, soft and dreamy",
            f"{theme}, bold and vibrant", 
            f"{theme}, minimalist approach",
            f"{theme}, textured and detailed"
        ]
        
        mood_board = []
        
        for i, variation in enumerate(mood_variations[:num_images]):
            try:
                image_url = self.concept_to_image(variation)
                mood_board.append({
                    "concept": variation,
                    "url": image_url
                })
                print(f"Generated mood board image {i+1}: {image_url}")
            except Exception as e:
                print(f"Failed to generate mood board image {i+1}: {e}")
        
        return mood_board
    
    def iterate_design(self, base_concept, feedback):
        """Iterate on a design based on feedback"""
        
        iteration_prompt = f"""
        Original concept: {base_concept}
        Feedback received: {feedback}
        
        Create an improved version that addresses the feedback while maintaining the core concept.
        Provide a detailed visual description for image generation.
        """
        
        response = requests.post(
            "https://api.anyapi.ai/v1/chat/completions",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            },
            json={
                "model": "openai/gpt-4o",
                "messages": [
                    {
                        "role": "system",
                        "content": "You are a designer iterating on concepts based on feedback."
                    },
                    {"role": "user", "content": iteration_prompt}
                ],
                "temperature": 0.6
            }
        )
        
        improved_concept = response.json()["choices"][0]["message"]["content"]
        improved_image = self.concept_to_image(improved_concept)
        
        return improved_image, improved_concept

# Usage
workflow = CreativeWorkflow("your_api_key")

# Project brainstorming
brief = "Design visuals for a new eco-friendly coffee shop that appeals to young professionals"
concepts = workflow.brainstorm_concepts(brief)
print("Generated concepts:")
print(concepts)

# Create mood board
mood_board = workflow.create_mood_board("sustainable coffee culture", 4)
print("\nMood board created:")
for item in mood_board:
    print(f"{item['concept']}: {item['url']}")

# Design iteration
base_concept = "modern coffee shop interior with living walls and natural lighting"
feedback = "Make it feel more cozy and less corporate, add warm colors"
improved_url, improved_concept = workflow.iterate_design(base_concept, feedback)

print(f"\nImproved design: {improved_url}")
print(f"Improved concept: {improved_concept}")

Model Selection Guide

Model Comparison

Model	Strengths	Best For	Style
DALL-E 3	Prompt adherence, quality	General purpose, concepts	Balanced, realistic
Flux Pro	Photorealism, details	Commercial, professional	Photographic
Stable Diffusion XL	Customization, speed	Experimentation, artistic	Artistic, flexible
Midjourney	Artistic style, creativity	Creative projects, art	Stylized, artistic

Choosing the Right Model

def recommend_model(use_case, style_preference, quality_needs):
    """Recommend the best model for specific needs"""
    
    recommendations = {
        ("marketing", "photorealistic", "high"): "flux-pro",
        ("marketing", "artistic", "high"): "google/gemini-2.5-flash-image", 
        ("creative", "artistic", "high"): "midjourney-v6",
        ("prototype", "any", "medium"): "stable-diffusion-xl",
        ("social_media", "vibrant", "medium"): "google/gemini-2.5-flash-image",
        ("product", "photorealistic", "high"): "flux-pro",
        ("concept_art", "artistic", "high"): "midjourney-v6",
        ("quick_test", "any", "low"): "stable-diffusion-turbo"
    }
    
    key = (use_case, style_preference, quality_needs)
    return recommendations.get(key, "google/gemini-2.5-flash-image")  # Default to DALL-E 3

# Usage
model = recommend_model("marketing", "photorealistic", "high")
print(f"Recommended model: {model}")

Best Practices

Prompt Engineering Tips

Be specific and descriptive
- ❌ “a dog”
- ✅ “a golden retriever puppy playing in a sunny meadow with wildflowers”
Include style and quality modifiers
- “professional photography”
- “high resolution”
- “studio lighting”
- “award-winning”
Specify composition and framing
- “wide shot”, “close-up”, “aerial view”
- “rule of thirds composition”
- “shallow depth of field”
Add mood and atmosphere
- “warm and inviting”
- “dramatic and moody”
- “bright and cheerful”

Quality Optimization

quality_modifiers = {
    "photography": [
        "professional photography",
        "high resolution",
        "sharp focus",
        "perfect lighting",
        "DSLR camera",
        "award-winning"
    ],
    "artwork": [
        "masterpiece",
        "highly detailed",
        "intricate",
        "beautiful",
        "stunning",
        "gallery quality"
    ],
    "commercial": [
        "commercial photography",
        "product shot",
        "clean background",
        "professional lighting",
        "marketing ready"
    ]
}

def enhance_prompt_quality(base_prompt, category="photography"):
    """Add quality modifiers to improve image generation"""
    modifiers = quality_modifiers.get(category, quality_modifiers["photography"])
    selected_modifiers = ", ".join(modifiers[:3])  # Use top 3 modifiers
    
    return f"{base_prompt}, {selected_modifiers}"

# Usage
enhanced = enhance_prompt_quality(
    "a modern kitchen with marble countertops", 
    "commercial"
)
print(enhanced)
# Output: "a modern kitchen with marble countertops, commercial photography, product shot, clean background"

Common Use Cases

Marketing & Advertising

Social media content, campaign visuals, product mockups

Creative Projects

Concept art, illustrations, artistic exploration

Product Design

Prototyping, visualization, design iteration

Content Creation

Blog images, thumbnails, visual storytelling

E-commerce

Product photography, lifestyle shots, catalog images

Real Estate

Property visualization, staging concepts, renovation ideas

Fashion & Style

Clothing designs, lookbooks, trend visualization

Architecture

Building concepts, interior design, space planning

Troubleshooting Common Issues

Content Policy Violations

Issue: Image generation rejected
Solution: Revise prompts to avoid restricted content
Prevention: Review content guidelines

Poor Quality Results

Issue: Blurry or low-quality images
Solution: Add quality modifiers, use HD setting
Example: Add “high resolution, professional photography”

Prompt Interpretation Errors

Issue: AI misunderstands the prompt
Solution: Be more specific, add context
Example: “red car” → “bright red sports car, side view, professional photography”

Getting Started

Quick Start

Generate your first AI image

API Reference

Explore image generation models

Capabilities

Learn about vision capabilities

SDKs

Use our official libraries

​Create Images with AI

​Overview

Text-to-Image

Style Control

High Resolution

Multiple Models

​Quick Start

​Advanced Image Generation

​Creative Prompt Engineering

​Style Transfer and Artistic Techniques

​Product and Marketing Image Generation

​Creative Workflow Automation

​Model Selection Guide

​Model Comparison

​Choosing the Right Model

​Best Practices

​Prompt Engineering Tips

​Quality Optimization

​Common Use Cases

Marketing & Advertising

Creative Projects

Product Design

Content Creation

E-commerce

Real Estate

Fashion & Style

Architecture

​Troubleshooting Common Issues

​Content Policy Violations

​Poor Quality Results

​Prompt Interpretation Errors

​Getting Started

Quick Start

API Reference

Capabilities

SDKs

Create Images with AI

Overview

Quick Start

Advanced Image Generation

Creative Prompt Engineering

Style Transfer and Artistic Techniques

Product and Marketing Image Generation

Creative Workflow Automation

Model Selection Guide

Model Comparison

Choosing the Right Model

Best Practices

Prompt Engineering Tips

Quality Optimization

Common Use Cases

Troubleshooting Common Issues

Content Policy Violations

Poor Quality Results

Prompt Interpretation Errors

Getting Started