Product photography studio with AI model training and marketing variations

If you're running an e-commerce business, product photography is both essential and expensive. You need consistent, professional images across multiple angles, lighting conditions, and marketing channels. Then you need variations: white backgrounds for the main catalogue, lifestyle shots for social media, close-ups for detail pages. The process is manual, time-consuming, and doesn't scale. You hire a photographer, wait for edits, brief them again for variations, and repeat..........

What if your product images could be generated, trained, refined, and distributed automatically? This is where combining AI-Boost (for training custom models on your products), PickorCraft (for intelligent image generation), and SellerPic-AI (for marketing-ready variations) becomes genuinely useful. Instead of a two-week turnaround per product, you can have a full suite of marketing assets in hours. The workflow runs in the background, triggered once you upload a raw product photo.

This is an advanced setup because you're chaining three specialist tools through an orchestration layer. If you're familiar with Zapier or n8n, you'll find this straightforward. If you're new to automation, expect to spend an afternoon reading API documentation. The payoff is real: consistent branding, faster time-to-market, and significantly lower photography costs.

The Automated Workflow

Choose Your Orchestration Tool

For this workflow, n8n is the best choice. It's self-hosted (more control), handles file uploads reliably, and integrates natively with all three tools without needing IFTTT workarounds. Zapier works but struggles with file handling across multiple services. Make works but requires more manual configuration. If you're comfortable with Python, Claude Code with the Anthropic API can orchestrate this, though you'll need your own server.

Overall Data Flow

The workflow operates in five distinct phases. A user (you, or an automated script) uploads a raw product image to a folder monitored by n8n. The image is sent to AI-Boost, which trains or updates a custom model based on your product category (say, "black shoes"). Once trained, PickorCraft uses that model to generate variants: the same shoe from different angles, in different lighting. SellerPic-AI then adds marketing context to each image, producing white-background versions, lifestyle mockups, and social media crops. Finally, all outputs are organized and pushed to your cloud storage or product management system.

Phase 1: File Monitoring and Intake

Set up an n8n workflow with a Folder Trigger node pointing to your product uploads directory. This could be Google Drive, Dropbox, or a local folder if you're self-hosting n8n.

Copy
Trigger: Folder Watch
- Path: /uploads/raw-products/
- Check interval: 5 minutes
- File types: .jpg, .png
- Output: file_path, file_name, file_size

When a file arrives, extract metadata and validate it. Add a simple Function node to check file size (must be at least 2 MB for quality model training) and format.

Copy// n8n Function node
const file = $input.first().json;

if (file.file_size < 2000000) {
  throw new Error('File too small for training. Minimum 2 MB required.');
}

if (!['jpg', 'png'].includes(file.file_name.split('.').pop().toLowerCase())) {
  throw new Error('Unsupported file format.');
}

return {
  file_path: file.file_path,
  file_name: file.file_name,
  product_id: file.file_name.split('_')[0], // assume naming: SKU_description.jpg
  timestamp: new Date().toISOString()
};

Phase 2: Send to AI-Boost for Model Training

AI-Boost takes product images and trains a custom model that learns the visual characteristics of your products. The API endpoint is /api/v1/models/train.

Copy
[POST](/tools/post) https://api.ai-boost.com/api/v1/models/train
Headers:
  Authorization: Bearer YOUR_AIBOOST_API_KEY
  Content-Type: application/json

Body:
{
  "model_name": "black-shoes-model-v2",
  "category": "footwear",
  "product_type": "closed-toe-shoes",
  "training_images": ["base64_encoded_image_or_url"],
  "training_iterations": 1000,
  "output_format": "checkpoint"
}

In n8n, add an HTTP Request node. You'll need to convert the uploaded image to base64 or a URL first.

Copy// n8n Function node to prepare image for AI-Boost
const file = $input.first().json;

// If using file path, read and encode to base64
// (assumes you're running on a system with file access)
const fs = require('fs');
const imageBuffer = fs.readFileSync(file.file_path);
const base64Image = imageBuffer.toString('base64');

return {
  model_name: `${file.product_id}-model-${Date.now()}`,
  category: 'footwear', // hardcode or extract from filename
  product_type: 'shoes',
  training_images: [`data:image/jpeg;base64,${base64Image}`],
  training_iterations: 1000,
  output_format: 'checkpoint'
};

Then the HTTP Request node calls AI-Boost:

Copy
HTTP Request Node Config:
- Method: POST
- URL: https://api.ai-boost.com/api/v1/models/train
- Headers: {Authorization: "Bearer YOUR_AIBOOST_API_KEY"}
- Body type: JSON
- Body: [output from Function node above]
- Return full response: true

AI-Boost responds with a training job ID and status. Store this for polling:

Copy{
  "job_id": "train-job-abc12345",
  "model_id": "model-xyz789",
  "status": "training",
  "estimated_completion": "2024-01-15T14:30:00Z"
}

Phase 3: Poll for Training Completion

Add a Loop node that polls the /api/v1/models/status endpoint every 30 seconds until the model training is complete. This prevents downstream steps from running before the model is ready.

Copy
GET https://api.ai-boost.com/api/v1/models/status?job_id=train-job-abc12345
Headers:
  Authorization: Bearer YOUR_AIBOOST_API_KEY

Configure the loop to check every 30 seconds for up to 20 minutes (40 iterations). Once status is "ready", exit the loop and pass the model_id forward.

Phase 4: Generate Variations with PickorCraft

With the trained model, PickorCraft generates product images from different angles and in different contexts. The endpoint is /api/v1/generate.

Copy
POST https://api.pickcraft.io/api/v1/generate
Headers:
  Authorization: Bearer YOUR_PICKCRAFT_API_KEY
  Content-Type: application/json

Body:
{
  "model_id": "model-xyz789",
  "prompts": [
    "shoe from front-left angle, studio lighting",
    "shoe from back-right angle, studio lighting",
    "shoe detail shot of sole",
    "shoe on white background, centered"
  ],
  "image_count": 4,
  "resolution": "1024x1024",
  "batch_size": 4,
  "return_urls": true
}

In n8n, add another HTTP Request node:

Copy// Function node to build PickorCraft request
const aiBoostResponse = $input.first().json;

return {
  model_id: aiBoostResponse.model_id,
  prompts: [
    'product photography, front view, white background, professional studio lighting',
    'product photography, 45-degree angle, white background, professional studio lighting',
    'product photography, detail shot, macro, white background, professional studio lighting',
    'product photography, lifestyle setting, natural lighting, on neutral surface'
  ],
  image_count: 4,
  resolution: '1024x1024',
  batch_size: 4,
  return_urls: true
};

PickorCraft returns an array of generated image URLs:

Copy{
  "generation_id": "gen-def456",
  "images": [
    "https://storage.pickcraft.io/gen-def456/image-001.png",
    "https://storage.pickcraft.io/gen-def456/image-002.png",
    "https://storage.pickcraft.io/gen-def456/image-003.png",
    "https://storage.pickcraft.io/gen-def456/image-004.png"
  ],
  "completion_time_ms": 12500,
  "model_used": "model-xyz789"
}

Phase 5: Process Variations with SellerPic-AI

SellerPic-AI takes generated images and creates marketing-ready variations: white backgrounds, cropped for social media, optimized for different platforms. It has batch processing, so you can send all four images at once.

Copy
POST https://api.sellerpic.ai/api/v1/batch-process
Headers:
  Authorization: Bearer YOUR_SELLERPIC_API_KEY
  Content-Type: application/json

Body:
{
  "images": [
    "https://storage.pickcraft.io/gen-def456/image-001.png",
    "https://storage.pickcraft.io/gen-def456/image-002.png",
    "https://storage.pickcraft.io/gen-def456/image-003.png",
    "https://storage.pickcraft.io/gen-def456/image-004.png"
  ],
  "operations": [
    {
      "operation": "background_removal",
      "target_background": "white",
      "padding": "5%"
    },
    {
      "operation": "resize",
      "target_sizes": ["1200x1200", "600x600", "300x300"]
    },
    {
      "operation": "crop_for_platform",
      "platforms": ["instagram_square", "pinterest", "facebook"]
    }
  ],
  "return_format": "json_with_urls"
}

In n8n:

Copy// Function node to build SellerPic-AI request
const pickorcraftResponse = $input.first().json;

return {
  images: pickorcraftResponse.images,
  operations: [
    {
      operation: 'background_removal',
      target_background: 'white',
      padding: '5%'
    },
    {
      operation: 'resize',
      target_sizes: ['1200x1200', '600x600', '300x300']
    },
    {
      operation: 'crop_for_platform',
      platforms: ['instagram_square', 'pinterest', 'facebook']
    }
  ],
  return_format: 'json_with_urls'
};

SellerPic-AI responds with organized outputs:

Copy{
  "batch_id": "batch-ghi789",
  "processed_images": [
    {
      "original_url": "https://storage.pickcraft.io/gen-def456/image-001.png",
      "variants": {
        "white_background_1200": "https://storage.sellerpic.ai/batch-ghi789/001-wb-1200.png",
        "white_background_600": "https://storage.sellerpic.ai/batch-ghi789/001-wb-600.png",
        "white_background_300": "https://storage.sellerpic.ai/batch-ghi789/001-wb-300.png",
        "instagram_square": "https://storage.sellerpic.ai/batch-ghi789/001-ig-square.png",
        "pinterest": "https://storage.sellerpic.ai/batch-ghi789/001-pinterest.png",
        "facebook": "https://storage.sellerpic.ai/batch-ghi789/001-facebook.png"
      }
    }
  ],
  "completion_time_ms": 8200
}

Phase 6: Store and Organize

Finally, download all processed images and organize them into your product management system or cloud storage. Add an n8n node that structures the output:

Copy// Function node to organize final output
const sellerpicResponse = $input.first().json;
const originalFile = $input.item(0).json; // from initial upload

const organized = {
  product_id: originalFile.product_id,
  generation_timestamp: new Date().toISOString(),
  source_image: originalFile.file_path,
  ai_boost_model_id: 'from-earlier-step',
  pickcraft_generation_id: 'from-earlier-step',
  sellerpic_batch_id: sellerpicResponse.batch_id,
  assets: sellerpicResponse.processed_images[0].variants, // grab first variant set
  total_files: Object.keys(sellerpicResponse.processed_images[0].variants).length
};

return organized;

Then use a Google Drive or AWS S3 node to save this JSON metadata and download all image URLs into a folder structure:

Copy
/product-assets/{product_id}/
  ├── metadata.json
  ├── white-background-1200.png
  ├── white-background-600.png
  ├── instagram-square.png
  ├── pinterest.png
  └── facebook.png

The Manual Alternative

If you prefer more control at each stage, you can run this workflow in parts. Upload an image to AI-Boost directly through their web interface, wait for the model to train, then manually request PickorCraft generations using a simple Python script:

Copyimport requests

PICKCRAFT_API_KEY = 'your-key'
PICKCRAFT_URL = 'https://api.pickcraft.io/api/v1/generate'

headers = {
    'Authorization': f'Bearer {PICKCRAFT_API_KEY}',
    'Content-Type': 'application/json'
}

payload = {
    'model_id': 'model-xyz789',
    'prompts': [
        'shoe from front angle',
        'shoe from side angle'
    ],
    'image_count': 2,
    'resolution': '1024x1024'
}

response = requests.post(PICKCRAFT_URL, json=payload, headers=headers)
print(response.json())

You then take those generated images, upload them to SellerPic-AI through their dashboard, and download the variations. This approach gives you a chance to review quality at each step but requires manual oversight. It's suitable if you're testing the workflow for the first time or if product quality varies significantly and needs human judgment.

Pro Tips

Monitor Rate Limits Carefully

AI-Boost limits training jobs to three concurrent models. If you upload multiple products simultaneously, n8n will queue them. Set up a Webhook Response node with status 202 (Accepted) so your system acknowledges the upload before processing begins. This prevents timeout errors on the client side.

Handle Failures with Conditional Branching

Add error handling at each HTTP Request node. If AI-Boost training fails after 20 minutes, send yourself a Slack notification instead of silently failing:

Copy
If AI-Boost status !== "ready" after timeout:
  → Send Slack message to #product-team
  → Log failure to a Google Sheet
  → Do NOT proceed to PickorCraft

Download Generated Images Immediately

PickorCraft and SellerPic-AI store generated images for 30 days. Don't rely on their URLs being permanent. Use n8n's HTTP File Download node to save copies to your own storage the moment they're generated.

Batch Multiple Products Per Run

Instead of triggering the workflow once per upload, batch process every four hours. Collect all new uploads and run them together. This reduces API calls and spreads your quota more efficiently. Modify the Folder Trigger node to collect files for a 4-hour period before processing.

Track Costs with Metadata

Store the cost of each generation. AI-Boost charges per training iteration, PickorCraft per image, SellerPic-AI per batch. Add a Function node at the end that calculates total spend and logs it to a spreadsheet. This gives you visibility into your per-product cost over time.

Cost Breakdown

If you're processing 100 products per month, each with four variations and three sizes, you're generating around 1,200 images. PickorCraft's Standard plan (5,000 images) covers this comfortably. If you exceed 5,000, expect an additional £60 to £100 per month. AI-Boost pro plan covers 20 trainings; for higher volume, negotiate a custom contract.

This workflow is genuinely advanced because it requires three separate API integrations, file handling, and polling for async operations. The benefit is that once it's running, you don't touch it again. Upload a product photo on Monday morning, check your assets folder Wednesday. That's worth the setup time.