DEV Community

ImaginePro
ImaginePro

Posted on

Complete Beginner's Guide to use Midjourney API to Create AI Images with Python

Are you a Python beginner who wants to create stunning AI-generated images using Midjourney's powerful AI models? Look no further! This comprehensive guide will walk you through everything you need to know about using Midjourney's capabilities through ImaginePro's unofficial API, from installation to advanced features.

What is Midjourney and ImaginePro?

Midjourney is one of the most powerful AI image generation platforms, known for its exceptional artistic quality and creative capabilities. However, Midjourney doesn't provide official APIs for developers.

ImaginePro bridges this gap by offering an unofficial API that gives you programmatic access to Midjourney's image generation capabilities. With the ImaginePro Python SDK, you can:

  • 🎨 Generate high-quality Midjourney-style images from text descriptions
  • ⚡ Upscale images while maintaining Midjourney's quality standards
  • 🔄 Create variants of existing images
  • 🎯 Modify specific areas of images (inpainting)
  • 📡 Receive real-time progress updates
  • 🔗 Integrate Midjourney capabilities into your applications via webhooks

Prerequisites

Before we start, make sure you have:

  1. Python 3.7+ installed on your system
  2. An ImaginePro API key (get one from platform.imaginepro.ai) - This gives you access to Midjourney's capabilities
  3. Basic Python knowledge (variables, functions, imports)
  4. Understanding: This guide uses ImaginePro's unofficial API to access Midjourney's image generation features

Installation

Getting started is super easy! Open your terminal and run:

pip install imaginepro
Enter fullscreen mode Exit fullscreen mode

That's it! The SDK is now ready to use.

Your First Midjourney-Style Image Generation

Let's start with a simple example that will generate your first Midjourney-style AI image:

import os
from imaginepro import ImagineProSDK, ImagineProSDKOptions

# Step 1: Set up your API key
# Replace 'your-api-key-here' with your actual API key
API_KEY = "your-api-key-here"

# Step 2: Initialize the SDK
sdk = ImagineProSDK(ImagineProSDKOptions(
    api_key=API_KEY,
    base_url="https://api.imaginepro.ai",  # Optional: default URL
    default_timeout=300,  # Optional: 5 minutes timeout
    fetch_interval=2,  # Optional: check status every 2 seconds
))

    # Step 3: Generate your first Midjourney-style image
    try:
        print("🚀 Starting Midjourney-style image generation...")

        # Create an image generation request using Midjourney's capabilities
        result = sdk.imagine({
            "prompt": "a cute cat playing with a ball of yarn in a sunny garden --ar 16:9 --v 6"
        })

        print(f"✅ Generation initiated! Message ID: {result['messageId']}")

        # Step 4: Wait for the image to be ready
        print("⏳ Waiting for Midjourney generation to complete...")
        final_result = sdk.fetch_message(result["messageId"])

        # Step 5: Display the result
        if final_result["status"] == "DONE":
            print(f"🎉 Midjourney-style image generated successfully!")
            print(f"📸 Image URL: {final_result['uri']}")
            print(f"📝 Prompt used: {final_result['prompt']}")
        else:
            print(f"❌ Generation failed: {final_result.get('error', 'Unknown error')}")

    except Exception as error:
        print(f"❌ Error: {error}")
Enter fullscreen mode Exit fullscreen mode

Save this code in a file (e.g., first_midjourney_image.py) and run it. You'll see your first Midjourney-style AI-generated image!

Understanding the Polling Process

One of the key features of the ImaginePro SDK is its polling mechanism for Midjourney image generation. Let's break down how it works:

What is Polling?

Polling means the SDK automatically checks the status of your Midjourney image generation until it's complete. Here's what happens:

  1. Submit Request: You send a prompt to generate a Midjourney-style image
  2. Get Message ID: The API returns a unique message ID
  3. Poll for Status: The SDK repeatedly checks if the Midjourney generation is ready
  4. Return Result: Once complete, you get the final image URL

Customizing Polling Behavior

You can control how the polling works:

# Example with custom polling settings
final_result = sdk.fetch_message(
    message_id=result["messageId"],
    interval=1,    # Check every 1 second (default: 2 seconds)
    timeout=600    # Wait up to 10 minutes (default: 30 minutes)
)
Enter fullscreen mode Exit fullscreen mode

Manual Polling (Advanced)

If you want more control, you can poll manually:

import time

# Get the initial message ID
result = sdk.imagine({"prompt": "a beautiful sunset over mountains --ar 16:9 --v 6"})
message_id = result["messageId"]

# Manual polling loop
while True:
    # Check the current status
    status = sdk.fetch_message_once(message_id)

    print(f"Status: {status['status']}, Progress: {status['progress']}%")

    # Check if generation is complete
    if status['status'] == 'DONE':
        print(f"🎉 Midjourney image ready: {status['uri']}")
        break
    elif status['status'] == 'FAIL':
        print(f"❌ Generation failed: {status.get('error', 'Unknown error')}")
        break

    # Wait before checking again
    time.sleep(2)
Enter fullscreen mode Exit fullscreen mode

Core Features Explained

1. Basic Midjourney Image Generation

The imagine method is your main tool for creating Midjourney-style images:

# Simple Midjourney image generation
result = sdk.imagine({
    "prompt": "a futuristic city at night with neon lights --ar 16:9 --v 6"
})

# Advanced Midjourney image generation with parameters
result = sdk.imagine({
    "prompt": "a majestic dragon flying over a castle, epic fantasy art --ar 16:9 --v 6 --q 2",
    "negative_prompt": "blurry, low quality, distorted",
    "width": 1024,
    "height": 768,
    "steps": 50,
    "cfg_scale": 7.5,
    "style": "photorealistic"
})
Enter fullscreen mode Exit fullscreen mode

Parameters Explained:

  • prompt: What you want to see in the image (supports Midjourney parameters like --ar 16:9, --v 6, --q 2)
  • negative_prompt: What you DON'T want to see
  • width/height: Image dimensions (in pixels)
  • steps: Generation quality (higher = better but slower)
  • cfg_scale: How closely to follow your prompt (1-20)
  • style: Artistic style (e.g., "photorealistic", "artistic")

2. Image Upscaling

Make your images higher resolution:

# Upscale the first image in a set (U1 button)
upscale_result = sdk.upscale({
    "message_id": "your-message-id",
    "index": 1  # Corresponds to U1 button
})

# Wait for upscaling to complete
final_upscale = sdk.fetch_message(upscale_result["messageId"])
print(f"Upscaled image: {final_upscale['uri']}")
Enter fullscreen mode Exit fullscreen mode

3. Creating Image Variants

Generate different versions of the same image:

# Create a variant of the first image (V1 button)
variant_result = sdk.variant({
    "message_id": "your-message-id",
    "index": 1  # Corresponds to V1 button
})

# Wait for variant generation
final_variant = sdk.fetch_message(variant_result["messageId"])
print(f"Variant image: {final_variant['uri']}")
Enter fullscreen mode Exit fullscreen mode

4. Regenerating Images (Reroll)

Try again with the same prompt:

# Regenerate the image with the same prompt
reroll_result = sdk.reroll({
    "message_id": "your-message-id"
})

# Wait for regeneration
final_reroll = sdk.fetch_message(reroll_result["messageId"])
print(f"Rerolled image: {final_reroll['uri']}")
Enter fullscreen mode Exit fullscreen mode

5. Inpainting (Advanced)

Modify specific areas of an image:

# Inpaint a specific region
inpaint_result = sdk.inpainting({
    "message_id": "your-message-id",
    "mask": "your-mask-data",  # Create mask at https://mask.imaginepro.ai/
    "prompt": "a beautiful flower garden"
})

# Wait for inpainting
final_inpaint = sdk.fetch_message(inpaint_result["messageId"])
print(f"Inpainted image: {final_inpaint['uri']}")
Enter fullscreen mode Exit fullscreen mode

Working with Message Responses

Every operation returns a MessageResponse with useful information:

# Example of a complete message response
message_response = {
    "messageId": "abc123def456",
    "prompt": "a cute cat playing with yarn",
    "uri": "https://cdn.imaginepro.ai/generated-image.jpg",
    "progress": 100,
    "status": "DONE",  # Can be: PROCESSING, QUEUED, DONE, FAIL
    "createdAt": "2024-01-15T10:30:00Z",
    "updatedAt": "2024-01-15T10:32:00Z",
    "buttons": ["U1", "V1", "V2", "V3", "V4"],  # Available actions
    "ref": "my-custom-reference",
    "error": None  # Will contain error message if status is FAIL
}
Enter fullscreen mode Exit fullscreen mode

Webhook Integration

For production applications, you can use webhooks to receive notifications:

# Generate image with webhook
result = sdk.imagine({
    "prompt": "a magical forest scene",
    "ref": "forest-generation-001",  # Custom reference ID
    "webhook_override": "https://your-server.com/webhook"  # Your webhook URL
})
Enter fullscreen mode Exit fullscreen mode

When the image is ready, ImaginePro will send a POST request to your webhook URL with the complete result.

Error Handling Best Practices

Always handle errors gracefully:

try:
    # Generate image
    result = sdk.imagine({"prompt": "a beautiful landscape"})

    # Wait for completion
    final_result = sdk.fetch_message(result["messageId"])

    if final_result["status"] == "DONE":
        print(f"✅ Success: {final_result['uri']}")
    else:
        print(f"❌ Failed: {final_result.get('error', 'Unknown error')}")

except TimeoutError:
    print("⏰ Generation timed out. Try again later.")
except Exception as e:
    print(f"❌ Unexpected error: {e}")
Enter fullscreen mode Exit fullscreen mode

Complete Example: Image Generation Workflow

Here's a complete example that demonstrates a typical workflow:

import os
from imaginepro import ImagineProSDK, ImagineProSDKOptions

def generate_and_process_image():
    # Initialize SDK
    sdk = ImagineProSDK(ImagineProSDKOptions(
        api_key="your-api-key-here",
        default_timeout=600,  # 10 minutes
        fetch_interval=1      # Check every second
    ))

    try:
        # Step 1: Generate initial Midjourney-style image
        print("🎨 Generating initial Midjourney-style image...")
        initial_result = sdk.imagine({
            "prompt": "a serene lake with mountains in the background at sunset, landscape photography --ar 16:9 --v 6",
            "width": 1024,
            "height": 768
        })

        # Step 2: Wait for completion
        print("⏳ Waiting for generation...")
        final_initial = sdk.fetch_message(initial_result["messageId"])

        if final_initial["status"] != "DONE":
            print(f"❌ Initial generation failed: {final_initial.get('error')}")
            return

        print(f"✅ Initial image ready: {final_initial['uri']}")

        # Step 3: Create a variant
        print("🔄 Creating a variant...")
        variant_result = sdk.variant({
            "message_id": final_initial["messageId"],
            "index": 1
        })

        final_variant = sdk.fetch_message(variant_result["messageId"])

        if final_variant["status"] == "DONE":
            print(f"✅ Variant ready: {final_variant['uri']}")

        # Step 4: Upscale the best image
        print("📈 Upscaling the variant...")
        upscale_result = sdk.upscale({
            "message_id": final_variant["messageId"],
            "index": 1
        })

        final_upscale = sdk.fetch_message(upscale_result["messageId"])

        if final_upscale["status"] == "DONE":
            print(f"✅ Final upscaled image: {final_upscale['uri']}")
            print("🎉 Workflow completed successfully!")

    except Exception as e:
        print(f"❌ Error in workflow: {e}")

# Run the workflow
if __name__ == "__main__":
    generate_and_process_image()
Enter fullscreen mode Exit fullscreen mode

Tips for Beginners

  1. Start Simple: Begin with basic prompts before adding Midjourney parameters
  2. Learn Midjourney Syntax: Use parameters like --ar 16:9 (aspect ratio), --v 6 (version), --q 2 (quality)
  3. Be Patient: Midjourney image generation can take 30 seconds to several minutes
  4. Use Descriptive Prompts: The more detailed your prompt, the better the Midjourney result
  5. Experiment: Try different Midjourney styles, settings, and prompts
  6. Handle Errors: Always wrap your code in try-catch blocks
  7. Monitor Progress: Use the polling features to track Midjourney generation status

Common Issues and Solutions

Issue: "Timeout exceeded"

Solution: Increase the timeout value or check your internet connection

Issue: "Invalid API key"

Solution: Verify your API key is correct and has sufficient credits

Issue: "Generation failed"

Solution: Try a different prompt or check the error message for details

Issue: "Rate limit exceeded"

Solution: Wait a few minutes before making another request

Next Steps

Now that you've mastered the basics, you can:

  1. Build a Web Application: Create a Flask or FastAPI app with image generation
  2. Batch Processing: Generate multiple images in sequence
  3. Image Editing Pipeline: Combine generation with upscaling and variants
  4. Integration: Add AI image generation to your existing projects

Resources

Happy coding! 🚀

This guide covers using Midjourney's capabilities through ImaginePro's unofficial API. For the latest updates, check the official documentation.

Top comments (0)