Josiahsiegel Claude Plugin Marketplace Fal Image To Image

Quick Reference

When to Use This Skill

Use for image editing and transformation:

• Style transfer while preserving structure
• Inpainting to edit specific regions
• ControlNet for guided generation
• Upscaling low-resolution images
• Removing backgrounds
• Restoring faces in old photos

Related skills:

• For text-to-image: see fal-text-to-image
• For image-to-video: see fal-image-to-video
• For model selection: see fal-model-guide

fal.ai Image-to-Image Models

Complete reference for all image transformation, editing, and enhancement models on fal.ai.

FLUX Image-to-Image

Basic Image-to-Image

Endpoint: fal-ai/flux/dev/image-to-image Best For: Style transfer, image transformation

Transform existing images while preserving structure.

import { fal } from "@fal-ai/client";

const result = await fal.subscribe("fal-ai/flux/dev/image-to-image", {
  input: {
    prompt: "Transform into a watercolor painting style",
    image_url: "https://example.com/photo.jpg",
    strength: 0.75,  // 0-1, how much to transform
    num_inference_steps: 28,
    guidance_scale: 3.5,
    seed: 42
  }
});

console.log(result.images[0].url);

import fal_client

result = fal_client.subscribe(
    "fal-ai/flux/dev/image-to-image",
    arguments={
        "prompt": "Transform into a watercolor painting style",
        "image_url": "https://example.com/photo.jpg",
        "strength": 0.75,
        "num_inference_steps": 28,
        "guidance_scale": 3.5
    }
)
print(result["images"][0]["url"])

Strength Parameter:

• 0.0: No change (original image)
• 0.3-0.5: Subtle changes, style hints
• 0.5-0.7: Moderate transformation
• 0.7-0.9: Strong transformation, some original preserved
• 1.0: Complete regeneration (ignores original)

FLUX Pro Image-to-Image

Endpoint: fal-ai/flux-pro/v1/image-to-image Best For: Production quality transformations

const result = await fal.subscribe("fal-ai/flux-pro/v1/image-to-image", {
  input: {
    prompt: "Professional headshot, studio lighting",
    image_url: "https://example.com/casual-photo.jpg",
    strength: 0.6,
    guidance_scale: 3.5
  }
});

ControlNet Models

FLUX ControlNet

Endpoint: fal-ai/flux-controlnet Best For: Precise structural control

const result = await fal.subscribe("fal-ai/flux-controlnet", {
  input: {
    prompt: "A modern house with large windows",
    control_image_url: "https://example.com/architecture-sketch.png",
    controlnet_conditioning_scale: 0.8,
    num_inference_steps: 28,
    guidance_scale: 3.5
  }
});

FLUX ControlNet Union

Endpoint: fal-ai/flux-controlnet-union Best For: Multiple control types in one model

Supports: canny, depth, pose, tile, blur, gray, low_quality

const result = await fal.subscribe("fal-ai/flux-controlnet-union", {
  input: {
    prompt: "A beautiful woman in a red dress",
    control_image_url: "https://example.com/pose-reference.png",
    control_type: "pose",
    controlnet_conditioning_scale: 0.7,
    num_inference_steps: 28
  }
});

Control Types:

• canny: Edge detection guidance
• depth: Depth map guidance
• pose: Human pose guidance
• tile: Detail enhancement
• blur: Blur-based control
• gray: Grayscale structure
• low_quality: Quality enhancement

SDXL ControlNet

Endpoint: fal-ai/fast-sdxl/controlnet Best For: SDXL with structural control

const result = await fal.subscribe("fal-ai/fast-sdxl/controlnet", {
  input: {
    prompt: "A futuristic cityscape",
    negative_prompt: "blurry, low quality",
    control_image_url: "https://example.com/depth-map.png",
    controlnet_type: "depth",
    controlnet_conditioning_scale: 0.8
  }
});

Canny Edge Detection

Endpoint: fal-ai/flux-controlnet-canny Best For: Edge-based generation

const result = await fal.subscribe("fal-ai/flux-controlnet-canny", {
  input: {
    prompt: "A detailed architectural drawing",
    control_image_url: "https://example.com/building-photo.jpg",
    controlnet_conditioning_scale: 0.9
  }
});

Depth-Based Control

Endpoint: fal-ai/flux-controlnet-depth Best For: 3D-aware generation

const result = await fal.subscribe("fal-ai/flux-controlnet-depth", {
  input: {
    prompt: "A mystical forest scene",
    control_image_url: "https://example.com/depth-map.png",
    controlnet_conditioning_scale: 0.7
  }
});

Inpainting Models

FLUX Inpainting

Endpoint: fal-ai/flux/dev/inpainting Best For: Editing specific regions

const result = await fal.subscribe("fal-ai/flux/dev/inpainting", {
  input: {
    prompt: "A golden retriever",
    image_url: "https://example.com/photo-with-pet.jpg",
    mask_url: "https://example.com/mask.png",  // White = edit area
    num_inference_steps: 28,
    guidance_scale: 3.5
  }
});

result = fal_client.subscribe(
    "fal-ai/flux/dev/inpainting",
    arguments={
        "prompt": "A golden retriever",
        "image_url": "https://example.com/photo.jpg",
        "mask_url": "https://example.com/mask.png"
    }
)

Mask Format:

• White pixels (255, 255, 255): Areas to edit/regenerate
• Black pixels (0, 0, 0): Areas to preserve

FLUX Pro Fill

Endpoint: fal-ai/flux-pro/v1/fill Best For: High-quality inpainting and outpainting

const result = await fal.subscribe("fal-ai/flux-pro/v1/fill", {
  input: {
    prompt: "Seamless continuation of the landscape",
    image_url: "https://example.com/partial-image.jpg",
    mask_url: "https://example.com/outpaint-mask.png"
  }
});

SDXL Inpainting

Endpoint: fal-ai/fast-sdxl/inpainting Best For: SDXL-based region editing

const result = await fal.subscribe("fal-ai/fast-sdxl/inpainting", {
  input: {
    prompt: "A beautiful flower arrangement",
    negative_prompt: "ugly, distorted",
    image_url: "https://example.com/vase.jpg",
    mask_url: "https://example.com/vase-mask.png"
  }
});

Upscaling Models

ESRGAN 4x

Endpoint: fal-ai/esrgan Best For: Classic 4x upscaling

const result = await fal.subscribe("fal-ai/esrgan", {
  input: {
    image_url: "https://example.com/low-res-image.jpg",
    scale: 4  // 2 or 4
  }
});

// Result is 4x the original resolution
console.log(result.image.url);

result = fal_client.subscribe(
    "fal-ai/esrgan",
    arguments={
        "image_url": "https://example.com/low-res.jpg",
        "scale": 4
    }
)
print(result["image"]["url"])

Clarity Upscaler

Endpoint: fal-ai/clarity-upscaler Best For: AI-enhanced upscaling with detail generation

const result = await fal.subscribe("fal-ai/clarity-upscaler", {
  input: {
    image_url: "https://example.com/image.jpg",
    scale_factor: 2,  // 1-4
    prompt: "high quality, detailed, sharp",
    creativity: 0.3,  // 0-1, how much to add
    resemblance: 0.8  // 0-1, similarity to original
  }
});

Parameters:

• scale_factor: 1-4, upscale multiplier
• creativity: 0-1, how much AI can "imagine" details
• resemblance: 0-1, how closely to match original
• prompt: Optional guidance for detail generation

Real-ESRGAN

Endpoint: fal-ai/real-esrgan Best For: General-purpose upscaling

const result = await fal.subscribe("fal-ai/real-esrgan", {
  input: {
    image_url: "https://example.com/image.jpg",
    scale: 4,
    face_enhance: true  // Enhance faces
  }
});

Creative Upscaler

Endpoint: fal-ai/creative-upscaler Best For: Artistic upscaling with regeneration

const result = await fal.subscribe("fal-ai/creative-upscaler", {
  input: {
    image_url: "https://example.com/image.jpg",
    scale: 2,
    prompt: "highly detailed, photorealistic"
  }
});

Background Removal

BiRefNet

Endpoint: fal-ai/birefnet Best For: High-quality background removal

const result = await fal.subscribe("fal-ai/birefnet", {
  input: {
    image_url: "https://example.com/product-photo.jpg"
  }
});

// Returns image with transparent background
console.log(result.image.url);

result = fal_client.subscribe(
    "fal-ai/birefnet",
    arguments={
        "image_url": "https://example.com/photo.jpg"
    }
)
# PNG with transparent background
print(result["image"]["url"])

RemBG

Endpoint: fal-ai/rembg Best For: Fast background removal

const result = await fal.subscribe("fal-ai/rembg", {
  input: {
    image_url: "https://example.com/image.jpg"
  }
});

Background Removal (BRIA)

Endpoint: fal-ai/bria/background-removal Best For: Commercial-grade background removal

const result = await fal.subscribe("fal-ai/bria/background-removal", {
  input: {
    image_url: "https://example.com/image.jpg"
  }
});

Face Enhancement

GFPGAN

Endpoint: fal-ai/gfpgan Best For: Face restoration

const result = await fal.subscribe("fal-ai/gfpgan", {
  input: {
    image_url: "https://example.com/old-photo.jpg",
    version: "1.4",  // or "1.3"
    scale: 2
  }
});

CodeFormer

Endpoint: fal-ai/codeformer Best For: Advanced face restoration

const result = await fal.subscribe("fal-ai/codeformer", {
  input: {
    image_url: "https://example.com/damaged-photo.jpg",
    fidelity: 0.7  // 0-1, balance quality vs fidelity
  }
});

IP-Adapter (Style Transfer)

FLUX IP-Adapter

Endpoint: fal-ai/flux-ip-adapter Best For: Style reference from image

const result = await fal.subscribe("fal-ai/flux-ip-adapter", {
  input: {
    prompt: "A modern living room",
    image_url: "https://example.com/style-reference.jpg",
    ip_adapter_scale: 0.7,  // 0-1, style strength
    num_inference_steps: 28
  }
});

IP-Adapter Face ID

Endpoint: fal-ai/flux-ip-adapter-face-id Best For: Face consistency across generations

const result = await fal.subscribe("fal-ai/flux-ip-adapter-face-id", {
  input: {
    prompt: "A portrait in renaissance style",
    face_image_url: "https://example.com/face-reference.jpg",
    ip_adapter_scale: 0.8
  }
});

Image-to-Image Parameter Reference

Common Parameters

interface ImageToImageInput {
  prompt: string;
  image_url: string;

  // Transformation strength
  strength?: number;  // 0-1, how much to change

  // Generation parameters
  num_inference_steps?: number;
  guidance_scale?: number;
  seed?: number;

  // Output
  output_format?: "jpeg" | "png";
}

ControlNet Parameters

interface ControlNetInput {
  prompt: string;
  control_image_url: string;
  control_type?: "canny" | "depth" | "pose" | "tile" | "blur" | "gray";
  controlnet_conditioning_scale?: number;  // 0-1

  num_inference_steps?: number;
  guidance_scale?: number;
  seed?: number;
}

Inpainting Parameters

interface InpaintingInput {
  prompt: string;
  image_url: string;
  mask_url: string;  // White = edit, Black = preserve

  num_inference_steps?: number;
  guidance_scale?: number;
  seed?: number;
}

Upscaling Parameters

interface UpscalingInput {
  image_url: string;
  scale?: number;  // 2 or 4

  // For AI upscalers
  prompt?: string;
  creativity?: number;
  resemblance?: number;
}

Workflow Examples

Complete Product Photo Pipeline

// 1. Remove background
const bgRemoved = await fal.subscribe("fal-ai/birefnet", {
  input: { image_url: originalProductUrl }
});

// 2. Upscale
const upscaled = await fal.subscribe("fal-ai/clarity-upscaler", {
  input: {
    image_url: bgRemoved.image.url,
    scale_factor: 2,
    prompt: "product photography, studio lighting"
  }
});

// 3. Apply style transformation
const styled = await fal.subscribe("fal-ai/flux/dev/image-to-image", {
  input: {
    prompt: "Professional e-commerce product photo, white background, soft shadows",
    image_url: upscaled.image.url,
    strength: 0.3
  }
});

Face Restoration Pipeline

// 1. Upscale
const upscaled = await fal.subscribe("fal-ai/real-esrgan", {
  input: {
    image_url: oldPhotoUrl,
    scale: 4,
    face_enhance: false
  }
});

// 2. Restore faces
const restored = await fal.subscribe("fal-ai/codeformer", {
  input: {
    image_url: upscaled.image.url,
    fidelity: 0.7
  }
});

Style Transfer with Structure

// Use ControlNet to maintain structure while changing style
const result = await fal.subscribe("fal-ai/flux-controlnet-canny", {
  input: {
    prompt: "oil painting style, impressionist, vibrant colors",
    control_image_url: originalPhotoUrl,
    controlnet_conditioning_scale: 0.9
  }
});

Best Practices

Strength Guidelines

ControlNet Scale Guidelines

Mask Creation Tips

1. Clean edges: Use anti-aliased masks for smooth blending
2. Feathering: Slight blur on mask edges reduces artifacts
3. Coverage: Include slightly more area than needed
4. Format: PNG with white=edit, black=preserve

File Upload for Large Images

// Upload file first for large images
const file = await fetch("local-image.jpg").then(r => r.blob());
const uploadedUrl = await fal.storage.upload(
  new File([file], "image.jpg", { type: "image/jpeg" })
);

// Then use in transformation
const result = await fal.subscribe("fal-ai/flux/dev/image-to-image", {
  input: {
    prompt: "...",
    image_url: uploadedUrl,
    strength: 0.5
  }
});

Converted and distributed by TomeVault — claim your Tome and manage your conversions.