Image Generation

Run diffusion models for batch image generation and editing with Parasail.

Parasail supports batch image generation and editing for diffusion models such as OmniGen and Qwen-Image-Edit. Prompts are submitted as JSONL files—one prompt per line—through either the OpenAI-compatible Batch API or the Parasail Batch helper library, which wraps the OpenAI client.

Input and output images are encoded as raw Base64 (not Data URLs like data:image/png;base64,..., just the raw Base64 image data). Batch results are returned as JSONL with Base64-encoded output images. Batch submission files have a 1000 MB limit; see Batch file format for the full limits.

Minimal example

The quickest way to generate an image is the batch helper library, which builds the JSONL request file and submits it for you:

from openai_batch import Batch

with Batch() as batch:
    batch.add_to_batch(
        model="Shitao/OmniGen-v1",
        prompt="A serene mountain lake at sunrise, photorealistic",
        size="1024x1024",
        response_format="b64_json",
    )
    result, output_path, error_path = batch.submit_wait_download()

For editing, pass one or more Base64-encoded input images and reference them in the prompt:

import base64

with open("person.jpg", "rb") as f:
    img = base64.b64encode(f.read()).decode("utf-8")

batch.add_to_batch(
    model="Shitao/OmniGen-v1",
    prompt="A man in a black shirt is reading a book. The man is the right man in <img><|image_1|></img>.",
    size="1024x1024",
    image=[img],
    response_format="b64_json",
)

Supported parameters

Parameter	Description
model	For example Shitao/OmniGen-v1 or Qwen/Qwen-Image-Edit
prompt	The prompt to guide generation. Reference input images inline as <img><|image_1|></img>
size	Formatted as WxH in pixels, for example 1024x1024
image	A list of Base64-encoded JPGs or PNGs (used for editing)
response_format	Currently only b64_json is supported

Advanced: process a directory of images

The script below uses the batch helper library to process every image in an input directory and save the generated results to an output directory. The batch library has many additional features for building processing pipelines—see the Batch quickstart, which also shows how to monitor batch jobs in Parasail's UI.

To run it:

pip3 install openai-batch
PARASAIL_API_KEY=<YOUR-API-KEY> python3 test_omnigen_batch.py

#test_omnigen_batch.py

#pip install openai-batch
from openai_batch import Batch, providers
from PIL import Image
import os
import base64
import json
import io
from pathlib import Path


def extract_and_save_images(input_file: str, output_dir: str):
    """Extract base64 encoded images from batch output and save as JPG files."""
    Path(output_dir).mkdir(parents=True, exist_ok=True)
    counter = 1
    with open(input_file, "r", encoding="utf-8") as f:
        for line in f:
            try:
                data = json.loads(line.strip())
                b64_data = data["response"]["body"]["data"][0]["b64_json"]
                image_bytes = base64.b64decode(b64_data)
                image = Image.open(io.BytesIO(image_bytes))
                output_path = os.path.join(output_dir, f"image-{counter}.jpg")
                image.convert("RGB").save(output_path, format="JPEG")
                print(f"Saved {output_path}")
                counter += 1
            except Exception as e:
                print(f"Error processing line {counter}: {e}")
                counter += 1
                continue


# Input and output directories
input_images_dir = Path("omnigen_input_images")
output_images_dir = Path("omnigen_output_images")

# Batch files
output_file = Path("output.jsonl")
error_file = Path("error.jsonl")
submission_file = Path("batch_submission.jsonl")

# Get all image files from input directory
image_extensions = {".jpg", ".jpeg", ".png"}
image_files = [
    f
    for f in input_images_dir.iterdir()
    if f.is_file() and f.suffix.lower() in image_extensions
]

if not image_files:
    print(f"No image files found in {input_images_dir}")
    print(f"Supported extensions: {', '.join(image_extensions)}")
    exit(1)

print(f"Found {len(image_files)} images to process")

# Create a batch with transfusion request
with Batch(
    submission_input_file=submission_file,
    output_file=output_file,
    error_file=error_file,
) as batch_obj:
    # Process each image and add to batch
    for image_path in image_files:
        print(f"Processing: {image_path.name}")

        # Read and encode the image as base64
        with open(image_path, "rb") as img_file:
            image_data = img_file.read()
            base64_image = base64.b64encode(image_data).decode("utf-8")

        # Add transfusion request to the batch
        batch_obj.add_to_batch(
            model="Shitao/OmniGen-v1",
            prompt="A man in a black shirt is reading a book. The man is the right man in <img><|image_1|></img>.",
            size="1024x1024",
            image=[base64_image],
            response_format="b64_json",
        )

    print(f"\nSubmitting batch with {len(image_files)} requests...")

    # Submit, wait for completion, and download results
    result, output_path, error_path = batch_obj.submit_wait_download()

    # Verify the batch completed successfully
    assert result.status == "completed", f"Batch failed with status: {result.status}"

# Verify output file exists
assert output_file.exists(), "Output file not created for transfusion"

# Extract and save generated images
extract_and_save_images(str(output_file), str(output_images_dir))

Next steps

• Batch quickstart—batch helper library fundamentals

• Batch image understanding—batch image processing reference

• Batch API reference—OpenAI-compatible API spec

• Batch file format—JSONL input format and limits