Fal.ai ⚡

Ultra-fast generative AI models for images, video, and more.

🎨

What you can do: Lightning-fast image generation (SDXL, FLUX), LoRA training, image-to-image, inpainting, face swap, virtual try-on, video generation, and more - all optimized for speed.

Setup

Add your Fal.ai API key in the ProtectMyAPI Dashboard.

Image Generation

FLUX Schnell (Fast)

let fal = ProtectMyAPI.falService()
 
let result = try await fal.generateFluxSchnell(
    prompt: "A majestic lion in a savanna at sunset, photorealistic",
    options: FalFluxOptions(
        imageSize: .landscape_16_9,
        numImages: 1,
        enableSafetyChecker: true
    )
)
 
for image in result.images {
    print("Image URL: \(image.url)")
    print("Size: \(image.width)x\(image.height)")
}

val fal = ProtectMyAPIAI.falService()
 
val result = fal.generateFluxSchnell(
    prompt = "A majestic lion in a savanna at sunset, photorealistic",
    options = FalFluxOptions(
        imageSize = ImageSize.LANDSCAPE_16_9,
        numImages = 1,
        enableSafetyChecker = true
    )
)
 
result.images.forEach { image ->
    println("Image URL: ${image.url}")
    println("Size: ${image.width}x${image.height}")
}

final fal = ProtectMyAPIAI.falService();
 
final result = await fal.generateFluxSchnell(
  prompt: "A majestic lion in a savanna at sunset, photorealistic",
  options: FalFluxOptions(
    imageSize: ImageSize.landscape_16_9,
    numImages: 1,
    enableSafetyChecker: true,
  ),
);
 
for (final image in result.images) {
  print("Image URL: ${image.url}");
  print("Size: ${image.width}x${image.height}");
}

FLUX Pro (Higher Quality)

let result = try await fal.generateFluxPro(
    prompt: "Professional product photography of a luxury perfume bottle",
    options: FalFluxProOptions(
        imageSize: .square,
        numImages: 1,
        safetyTolerance: 2,
        guidanceScale: 3.5
    )
)

val result = fal.generateFluxPro(
    prompt = "Professional product photography of a luxury perfume bottle",
    options = FalFluxProOptions(
        imageSize = ImageSize.SQUARE,
        numImages = 1,
        safetyTolerance = 2,
        guidanceScale = 3.5
    )
)

final result = await fal.generateFluxPro(
  prompt: "Professional product photography of a luxury perfume bottle",
  options: FalFluxProOptions(
    imageSize: ImageSize.square,
    numImages: 1,
    safetyTolerance: 2,
    guidanceScale: 3.5,
  ),
);

SDXL Generation

let result = try await fal.generateSDXL(
    prompt: "Cyberpunk city street at night, neon lights, rain, cinematic",
    negativePrompt: "blurry, low quality, distorted",
    options: FalSDXLOptions(
        imageSize: .landscape_16_9,
        numImages: 1,
        numInferenceSteps: 30,
        guidanceScale: 7.5,
        scheduler: .dpmPlusPlusSDE,
        seed: 42 // For reproducibility
    )
)

val result = fal.generateSDXL(
    prompt = "Cyberpunk city street at night, neon lights, rain, cinematic",
    negativePrompt = "blurry, low quality, distorted",
    options = FalSDXLOptions(
        imageSize = ImageSize.LANDSCAPE_16_9,
        numImages = 1,
        numInferenceSteps = 30,
        guidanceScale = 7.5,
        scheduler = Scheduler.DPM_PLUS_PLUS_SDE,
        seed = 42
    )
)

final result = await fal.generateSDXL(
  prompt: "Cyberpunk city street at night, neon lights, rain, cinematic",
  negativePrompt: "blurry, low quality, distorted",
  options: FalSDXLOptions(
    imageSize: ImageSize.landscape_16_9,
    numImages: 1,
    numInferenceSteps: 30,
    guidanceScale: 7.5,
    scheduler: Scheduler.dpmPlusPlusSde,
    seed: 42,
  ),
);

Image-to-Image

Transform existing images:

let result = try await fal.imageToImage(
    imageUrl: "https://example.com/photo.jpg",
    prompt: "Transform into anime style",
    options: FalImg2ImgOptions(
        strength: 0.75, // 0.0 = keep original, 1.0 = full transformation
        numInferenceSteps: 30,
        guidanceScale: 7.5
    )
)

val result = fal.imageToImage(
    imageUrl = "https://example.com/photo.jpg",
    prompt = "Transform into anime style",
    options = FalImg2ImgOptions(
        strength = 0.75,
        numInferenceSteps = 30,
        guidanceScale = 7.5
    )
)

final result = await fal.imageToImage(
  imageUrl: "https://example.com/photo.jpg",
  prompt: "Transform into anime style",
  options: FalImg2ImgOptions(
    strength: 0.75,
    numInferenceSteps: 30,
    guidanceScale: 7.5,
  ),
);

Inpainting

Edit specific parts of an image:

let result = try await fal.inpaint(
    imageUrl: "https://example.com/photo.jpg",
    maskUrl: "https://example.com/mask.png", // White = edit, Black = keep
    prompt: "A red sports car",
    options: FalInpaintOptions(
        numInferenceSteps: 30,
        guidanceScale: 7.5
    )
)

val result = fal.inpaint(
    imageUrl = "https://example.com/photo.jpg",
    maskUrl = "https://example.com/mask.png",
    prompt = "A red sports car",
    options = FalInpaintOptions(
        numInferenceSteps = 30,
        guidanceScale = 7.5
    )
)

final result = await fal.inpaint(
  imageUrl: "https://example.com/photo.jpg",
  maskUrl: "https://example.com/mask.png",
  prompt: "A red sports car",
  options: FalInpaintOptions(
    numInferenceSteps: 30,
    guidanceScale: 7.5,
  ),
);

LoRA Training

Train custom models on your images:

// Start LoRA training
let training = try await fal.trainLoRA(
    request: FalLoRATrainingRequest(
        imagesDataUrl: "https://example.com/training-images.zip",
        triggerWord: "mystyle", // Word to trigger your style
        steps: 1000,
        resolution: 512,
        learningRate: 0.0001,
        isStyle: true // true for style, false for subject
    )
)
 
print("Training ID: \(training.requestId)")
 
// Check training status
let status = try await fal.getTrainingStatus(requestId: training.requestId)
print("Status: \(status.status)")
 
// Use your trained LoRA
let result = try await fal.generateWithLoRA(
    prompt: "A portrait in mystyle",
    loraUrl: status.outputUrl!, // URL to trained LoRA weights
    loraScale: 0.8
)

val training = fal.trainLoRA(
    request = FalLoRATrainingRequest(
        imagesDataUrl = "https://example.com/training-images.zip",
        triggerWord = "mystyle",
        steps = 1000,
        resolution = 512,
        learningRate = 0.0001,
        isStyle = true
    )
)
 
println("Training ID: ${training.requestId}")
 
val status = fal.getTrainingStatus(requestId = training.requestId)
println("Status: ${status.status}")
 
val result = fal.generateWithLoRA(
    prompt = "A portrait in mystyle",
    loraUrl = status.outputUrl!!,
    loraScale = 0.8
)

final training = await fal.trainLoRA(
  request: FalLoRATrainingRequest(
    imagesDataUrl: "https://example.com/training-images.zip",
    triggerWord: "mystyle",
    steps: 1000,
    resolution: 512,
    learningRate: 0.0001,
    isStyle: true,
  ),
);
 
print("Training ID: ${training.requestId}");
 
final status = await fal.getTrainingStatus(requestId: training.requestId);
print("Status: ${status.status}");
 
final result = await fal.generateWithLoRA(
  prompt: "A portrait in mystyle",
  loraUrl: status.outputUrl!,
  loraScale: 0.8,
);

Virtual Try-On

Try clothing on a person:

let result = try await fal.virtualTryOn(
    personImageUrl: "https://example.com/person.jpg",
    garmentImageUrl: "https://example.com/shirt.jpg",
    options: FalTryOnOptions(
        category: .upperBody, // upperBody, lowerBody, fullBody
        numImages: 1
    )
)
 
for image in result.images {
    print("Try-on result: \(image.url)")
}

val result = fal.virtualTryOn(
    personImageUrl = "https://example.com/person.jpg",
    garmentImageUrl = "https://example.com/shirt.jpg",
    options = FalTryOnOptions(
        category = GarmentCategory.UPPER_BODY,
        numImages = 1
    )
)
 
result.images.forEach { image ->
    println("Try-on result: ${image.url}")
}

final result = await fal.virtualTryOn(
  personImageUrl: "https://example.com/person.jpg",
  garmentImageUrl: "https://example.com/shirt.jpg",
  options: FalTryOnOptions(
    category: GarmentCategory.upperBody,
    numImages: 1,
  ),
);
 
for (final image in result.images) {
  print("Try-on result: ${image.url}");
}

Face Swap

let result = try await fal.faceSwap(
    sourceImageUrl: "https://example.com/face.jpg", // Face to use
    targetImageUrl: "https://example.com/target.jpg" // Image to swap into
)
 
print("Result: \(result.image.url)")

val result = fal.faceSwap(
    sourceImageUrl = "https://example.com/face.jpg",
    targetImageUrl = "https://example.com/target.jpg"
)
 
println("Result: ${result.image.url}")

final result = await fal.faceSwap(
  sourceImageUrl: "https://example.com/face.jpg",
  targetImageUrl: "https://example.com/target.jpg",
);
 
print("Result: ${result.image.url}");

Upscaling

Enhance image resolution:

let result = try await fal.upscale(
    imageUrl: "https://example.com/low-res.jpg",
    options: FalUpscaleOptions(
        scale: 4, // 2x or 4x
        faceEnhance: true // Enhance faces
    )
)
 
print("Upscaled: \(result.image.url)")
print("New size: \(result.image.width)x\(result.image.height)")

val result = fal.upscale(
    imageUrl = "https://example.com/low-res.jpg",
    options = FalUpscaleOptions(
        scale = 4,
        faceEnhance = true
    )
)
 
println("Upscaled: ${result.image.url}")
println("New size: ${result.image.width}x${result.image.height}")

final result = await fal.upscale(
  imageUrl: "https://example.com/low-res.jpg",
  options: FalUpscaleOptions(
    scale: 4,
    faceEnhance: true,
  ),
);
 
print("Upscaled: ${result.image.url}");
print("New size: ${result.image.width}x${result.image.height}");

Background Removal

let result = try await fal.removeBackground(
    imageUrl: "https://example.com/photo.jpg"
)
 
print("Transparent image: \(result.image.url)")

val result = fal.removeBackground(
    imageUrl = "https://example.com/photo.jpg"
)
 
println("Transparent image: ${result.image.url}")

final result = await fal.removeBackground(
  imageUrl: "https://example.com/photo.jpg",
);
 
print("Transparent image: ${result.image.url}");

ControlNet

Guide generation with control images:

let result = try await fal.generateWithControlNet(
    prompt: "A futuristic city",
    controlImageUrl: "https://example.com/depth-map.png",
    controlType: .depth, // canny, depth, pose, etc.
    options: FalControlNetOptions(
        controlScale: 0.8,
        numInferenceSteps: 30
    )
)

val result = fal.generateWithControlNet(
    prompt = "A futuristic city",
    controlImageUrl = "https://example.com/depth-map.png",
    controlType = ControlType.DEPTH,
    options = FalControlNetOptions(
        controlScale = 0.8,
        numInferenceSteps = 30
    )
)

final result = await fal.generateWithControlNet(
  prompt: "A futuristic city",
  controlImageUrl: "https://example.com/depth-map.png",
  controlType: ControlType.depth,
  options: FalControlNetOptions(
    controlScale: 0.8,
    numInferenceSteps: 30,
  ),
);

Available Models

FLUX Models

Model	Description	Speed
`flux-schnell`	Fast generation	⚡ Ultra-fast
`flux-dev`	Development quality	Medium
`flux-pro`	Highest quality	Slower
`flux-pro-1.1`	Latest pro version	Slower

SDXL Models

Model	Description
`fast-sdxl`	Optimized SDXL
`sdxl-lightning`	4-step SDXL
`stable-cascade`	Würstchen architecture

Utility Models

Model	Description
`rembg`	Background removal
`esrgan`	Image upscaling
`face-swap`	Face swapping
`idt-vton`	Virtual try-on

Image Sizes

Size	Resolution	Ratio
`.square`	1024x1024	1:1
`.squareHD`	1536x1536	1:1
`.portrait_4_3`	896x1152	3:4
`.portrait_16_9`	768x1344	9:16
`.landscape_4_3`	1152x896	4:3
`.landscape_16_9`	1344x768	16:9

Pricing

Fal.ai charges per request based on the model:

FLUX Schnell: ~$0.003/image
FLUX Pro: ~$0.05/image
SDXL: ~$0.01/image
LoRA Training: ~$0.50/1000 steps

Check their pricing page for current rates.

DeepL Open-Meteo