API v2 — Live

Image Generation API

Generate AI product photography with one REST call. Upload a product photo — get studio scenes, lifestyle shots, and on-model imagery back. No templates to design.

$0.029 per image $49/mo minimums elsewhere
generate.py
import requests

# Generate 6 AI scene photos for a saved product
job = requests.post(
    "https://pixelpanda.ai/api/v2/generate/scenes",
    headers={"Authorization": "Bearer pk_live_xxx"},
    json={"product_uuid": "prod_abc123", "num_scenes": 6}
).json()

# {"job_id": "...", "status": "pending",
#  "poll_url": "/api/v2/jobs/...", "credits_reserved": 6}

One API key, the whole image pipeline

Upload a product once, get a UUID, and reuse it across every generation call. Async jobs with polling or webhooks.

POST /api/v2/products Upload a product image, get a reusable UUID free
POST /api/v2/generate/scenes Contextual scene photography — studio, lifestyle, seasonal 1 credit/image
POST /api/v2/generate/product-photo An AI avatar holds or uses your product 1 credit/image
POST /api/v2/generate/tryon Virtual try-on — an AI model wears your clothing product 1 credit/image
POST /api/v2/upscale AI upscaling — 2x, 4x, or 8x 1-2 credits
POST /api/v2/enhance Multi-method AI enhancement, returns variants 1 credit
GET /api/v2/jobs/{job_id} Poll job status and collect generated image URLs free

Upload once, generate forever

The full workflow — save a product, generate scenes, collect results. Copy-paste and run.

import requests, base64, time

API = "https://pixelpanda.ai/api/v2"
HEADERS = {"Authorization": "Bearer pk_live_your_api_key"}

# 1. Upload a product image — returns a reusable UUID
with open("product.jpg", "rb") as f:
    b64 = base64.b64encode(f.read()).decode()

product = requests.post(f"{API}/products", headers=HEADERS, json={
    "image": b64, "filename": "product.jpg"
}).json()

# 2. Generate 6 AI scene images (async — returns a job)
job = requests.post(f"{API}/generate/scenes", headers=HEADERS, json={
    "product_uuid": product["uuid"],
    "num_scenes": 6
}).json()

# 3. Poll until done (or pass webhook_url in step 2 instead)
while True:
    status = requests.get(
        f"https://pixelpanda.ai{job['poll_url']}", headers=HEADERS
    ).json()
    if status["status"] in ("completed", "failed"):
        break
    time.sleep(5)

print(status)  # image URLs for all generated scenes
const fs = require('fs');

const API = 'https://pixelpanda.ai/api/v2';
const HEADERS = {
    'Authorization': 'Bearer pk_live_your_api_key',
    'Content-Type': 'application/json'
};

// 1. Upload a product image — returns a reusable UUID
const b64 = fs.readFileSync('product.jpg').toString('base64');

const product = await (await fetch(`${API}/products`, {
    method: 'POST', headers: HEADERS,
    body: JSON.stringify({ image: b64, filename: 'product.jpg' })
})).json();

// 2. Generate scenes — pass a webhook_url and skip polling
const job = await (await fetch(`${API}/generate/scenes`, {
    method: 'POST', headers: HEADERS,
    body: JSON.stringify({
        product_uuid: product.uuid,
        num_scenes: 6,
        webhook_url: 'https://yourapp.com/webhooks/pixelpanda'
    })
})).json();

console.log(job.job_id, job.poll_url);
// Your webhook receives image URLs when generation completes
# 1. Upload a product image (base64) — returns a reusable UUID
curl -X POST https://pixelpanda.ai/api/v2/products \
  -H "Authorization: Bearer pk_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d "{\"image\": \"$(base64 -i product.jpg)\", \"filename\": \"product.jpg\"}"

# 2. Generate 6 AI scene images for that product
curl -X POST https://pixelpanda.ai/api/v2/generate/scenes \
  -H "Authorization: Bearer pk_live_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{"product_uuid": "prod_abc123", "num_scenes": 6}'

# 3. Poll the job for generated image URLs
curl https://pixelpanda.ai/api/v2/jobs/JOB_ID \
  -H "Authorization: Bearer pk_live_your_api_key"

AI generation, not template merges

Template APIs fill your data into fixed layouts. This API generates new photography — your product in scenes that never existed. Pay per image, no monthly minimum.

Bannerbear
~$49 /month min

Template-merge API. Renders your data into layouts you design first.

  • Template image & video rendering
  • Zapier ecosystem
  • No AI photo generation
  • Output looks templated
  • No background removal or upscaling
  • $49/mo minimum for API access
Placid
~$19 /month min

Template toolkit for no-code image, video, and PDF automation.

  • Template rendering
  • Zapier / Make / Airtable
  • No AI photo generation
  • Output looks templated
  • No image enhancement suite
  • Render quotas per plan

Comparing template tools? See our breakdowns: Bannerbear alternatives · Placid alternatives · Abyssale alternatives

Built for e-commerce pipelines

The product in the output is your product — pixel-faithful — with AI-generated everything else.

🏞️

Scene generation

Studio, lifestyle, and contextual scenes matched to your product category. Up to 12 scenes per call.

🧍

On-model imagery

AI avatars hold, use, or wear your product. Pick from a library of avatars or create your own via the API.

uuid

Asset library

Upload products and avatars once, reference them by UUID forever. No re-uploading per request.

202

Async + webhooks

Jobs return instantly with a poll URL. Or register a webhook and get notified when images are ready.

100

Batch processing

Up to 100 images per batch job, 30 outputs per generate call. Built for full-catalog runs.

v2/

Full image suite

Same key covers background removal, upscaling, and enhancement. One integration, all tools.

Common questions

An image generation API lets your application create images programmatically via HTTP requests. PixelPanda's API generates AI photography — product scenes, lifestyle shots, on-model imagery — from a single uploaded product photo. Unlike template-merge APIs (Bannerbear, Placid), it creates new photographic content rather than filling text and images into pre-designed layouts.
Generation costs 1 credit per image. At starter pricing that's $0.029 per image ($7.99/week for 280 credits, cancel anytime), dropping to ~$0.017 per image on larger plans. A $10 one-time pack (50 credits, no subscription) is the cheapest way to test. There's no monthly minimum like Bannerbear's ~$49/month.
Template APIs merge your data into layouts you design first — output always looks like a template. PixelPanda's API uses generative AI to create new photography: your product in a studio, on a beach, held by an AI model. If you need net-new visuals rather than data-filled banners, an AI generation API is the better fit. See our Bannerbear alternatives comparison for a full breakdown.
Text-to-image APIs generate images from a prompt but can't preserve YOUR product accurately. PixelPanda is image-to-image: you upload a real product photo and the AI keeps the product pixel-faithful while generating new scenes, backgrounds, and models around it — which is what e-commerce and marketing use cases require.
Product scene photography (studio, lifestyle, contextual backgrounds), on-model imagery via AI avatars (an avatar holding, using, or wearing your product), virtual try-on for clothing, plus image processing: background removal, 2x-8x AI upscaling, and multi-method enhancement. All through one API key.
Asynchronous. A generate call returns a job ID and poll URL immediately (HTTP 202). Poll /api/v2/jobs/{job_id} for results, or pass a webhook_url and we'll POST to your endpoint when the job completes. Typical jobs finish in under a minute.
Yes. Each generate call produces up to 30 images (scenes cap at 12), and the Batch API accepts up to 100 images per batch job. Upload a product once, get a UUID, and reuse it across unlimited generation calls without re-uploading.
The $10 one-time pack (50 credits, no subscription) is the lowest-commitment way to test the API — 50 generated images. Subscriptions start at $7.99/week for 280 credits, cancel anytime. Credits never expire and roll over.
Bearer token authentication. Include your API key in the Authorization header: "Authorization: Bearer pk_live_xxx". Generate keys from your PixelPanda dashboard under account settings.
It's a standard REST API — any language with an HTTP client works. We provide copy-paste examples for Python, JavaScript/Node.js, and cURL, plus language-specific tutorials. It also works from no-code tools that can make HTTP requests, like Zapier Webhooks, Make, and n8n.
$10 to test · no subscription

Start generating images today

50 credits for $10, one-time. One API key. Production-ready in minutes.