Flux Lora API

Flux Lora
Image To Image
Inpainting
Stream

Endpoint: POST https://fal.run/fal-ai/flux-lora Endpoint ID: fal-ai/flux-lora

Try it in the Playground

Run this model interactively with your own prompts.

Quick Start

import fal_client

def on_queue_update(update):
    if isinstance(update, fal_client.InProgress):
        for log in update.logs:
           print(log["message"])

result = fal_client.subscribe(
    "fal-ai/flux-lora",
    arguments={
        "prompt": "Extreme close-up of a single tiger eye, direct frontal view. Detailed iris and pupil. Sharp focus on eye texture and color. Natural lighting to capture authentic eye shine and depth. The word \"FLUX\" is painted over it in big, white brush strokes with visible texture."
    },
    with_logs=True,
    on_queue_update=on_queue_update,
)
print(result)

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

const result = await fal.subscribe("fal-ai/flux-lora", {
  input: {
      prompt: "Extreme close-up of a single tiger eye, direct frontal view. Detailed iris and pupil. Sharp focus on eye texture and color. Natural lighting to capture authentic eye shine and depth. The word \"FLUX\" is painted over it in big, white brush strokes with visible texture."
    },
  logs: true,
  onQueueUpdate: (update) => {
    if (update.status === "IN_PROGRESS") {
      update.logs.map((log) => log.message).forEach(console.log);
    }
  },
});
console.log(result.data);
console.log(result.requestId);

curl --request POST \
  --url https://fal.run/fal-ai/flux-lora \
  --header "Authorization: Key $FAL_KEY" \
  --header "Content-Type: application/json" \
  --data '{
  "prompt": "Extreme close-up of a single tiger eye, direct frontal view. Detailed iris and pupil. Sharp focus on eye texture and color. Natural lighting to capture authentic eye shine and depth. The word \"FLUX\" is painted over it in big, white brush strokes with visible texture."
}'

Examples

Gal gadot, wearing jacket and tie

Generated image: Gal gadot, wearing jacket and tie

a trtcrd of a person on a computer, on the computer you see a meme being made with an ancient looking trollface, “the shitposter” arcana, in the style of TOK a trtcrd, tarot style

Generated image: a trtcrd of a person on a computer, on the computer you see a meme being made wi

two warriors fighting, in the middle, white background

Generated image: two warriors fighting, in the middle, white background

Input Schema

string

required

The prompt to generate an image from.

ImageSize | Enum

default:"landscape_4_3"

The size of the generated image. Default value: landscape_4_3Possible values: square_hd, square, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9

integer

default:"28"

The number of inference steps to perform. Default value: 28Range: 1 to 50

integer

The same seed and the same prompt given to the same version of the model will output the same image every time.

list<LoraWeight>

default:""

The LoRAs to use for the image generation. You can use any number of LoRAs and they will be merged together to generate the final image.

float

default:"3.5"

The CFG (Classifier Free Guidance) scale is a measure of how close you want the model to stick to your prompt when looking for a related image to show you. Default value: 3.5Range: 0 to 35

boolean

default:"false"

If True, the media will be returned as a data URI and the output data won’t be available in the request history.

integer

default:"1"

The number of images to generate. This is always set to 1 for streaming output. Default value: 1Range: 1 to 4

boolean

default:"true"

If set to true, the safety checker will be enabled. Default value: true

OutputFormatEnum

default:"jpeg"

The format of the generated image. Default value: "jpeg"Possible values: jpeg, png

AccelerationEnum

default:"none"

Acceleration level for image generation. ‘regular’ balances speed and quality. Default value: "none"Possible values: none, regular

Output Schema

list<Image>

required

The generated image files info.

Timings

required

integer

required

Seed of the generated Image. It will be the same value of the one passed in the input or the randomly generated that was used in case none was passed.

list<boolean>

required

Whether the generated images contain NSFW concepts.

string

required

The prompt used for generating the image.

Input Example

{
  "prompt": "Extreme close-up of a single tiger eye, direct frontal view. Detailed iris and pupil. Sharp focus on eye texture and color. Natural lighting to capture authentic eye shine and depth. The word \"FLUX\" is painted over it in big, white brush strokes with visible texture.",
  "image_size": "landscape_4_3",
  "num_inference_steps": 28,
  "guidance_scale": 3.5,
  "sync_mode": false,
  "num_images": 1,
  "enable_safety_checker": true,
  "output_format": "jpeg",
  "acceleration": "none"
}

Output Example

{
  "images": [
    {
      "url": "",
      "content_type": "image/jpeg"
    }
  ],
  "prompt": ""
}

Endpoint: POST https://fal.run/fal-ai/flux-lora/image-to-image Endpoint ID: fal-ai/flux-lora/image-to-image

Try it in the Playground

Run this model interactively with your own prompts.

Quick Start

import fal_client

def on_queue_update(update):
    if isinstance(update, fal_client.InProgress):
        for log in update.logs:
           print(log["message"])

result = fal_client.subscribe(
    "fal-ai/flux-lora/image-to-image",
    arguments={
        "prompt": "A photo of a lion sitting on a stone bench",
        "image_url": "https://storage.googleapis.com/falserverless/example_inputs/dog.png"
    },
    with_logs=True,
    on_queue_update=on_queue_update,
)
print(result)

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

const result = await fal.subscribe("fal-ai/flux-lora/image-to-image", {
  input: {
      prompt: "A photo of a lion sitting on a stone bench",
      image_url: "https://storage.googleapis.com/falserverless/example_inputs/dog.png"
    },
  logs: true,
  onQueueUpdate: (update) => {
    if (update.status === "IN_PROGRESS") {
      update.logs.map((log) => log.message).forEach(console.log);
    }
  },
});
console.log(result.data);
console.log(result.requestId);

curl --request POST \
  --url https://fal.run/fal-ai/flux-lora/image-to-image \
  --header "Authorization: Key $FAL_KEY" \
  --header "Content-Type: application/json" \
  --data '{
  "prompt": "A photo of a lion sitting on a stone bench",
  "image_url": "https://storage.googleapis.com/falserverless/example_inputs/dog.png"
}'

Examples

Gal gadot looking at the camera

Generated image: Gal gadot looking at the camera

Bald man giving conference talk

Generated image: Bald man giving conference talk

eh_style, The image showcases a tiger

Generated image: eh_style, The image showcases a tiger

Input Schema

string

required

The prompt to generate an image from.

ImageSize | Enum

The size of the generated image.Possible values: square_hd, square, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9

integer

default:"28"

The number of inference steps to perform. Default value: 28Range: 1 to 50

integer

The same seed and the same prompt given to the same version of the model will output the same image every time.

list<LoraWeight>

default:""

The LoRAs to use for the image generation. You can use any number of LoRAs and they will be merged together to generate the final image.

float

default:"3.5"

The CFG (Classifier Free Guidance) scale is a measure of how close you want the model to stick to your prompt when looking for a related image to show you. Default value: 3.5Range: 0 to 35

boolean

default:"false"

If True, the media will be returned as a data URI and the output data won’t be available in the request history.

integer

default:"1"

The number of images to generate. This is always set to 1 for streaming output. Default value: 1Range: 1 to 4

boolean

default:"true"

If set to true, the safety checker will be enabled. Default value: true

OutputFormatEnum

default:"jpeg"

The format of the generated image. Default value: "jpeg"Possible values: jpeg, png

AccelerationEnum

default:"none"

Acceleration level for image generation. ‘regular’ balances speed and quality. Default value: "none"Possible values: none, regular

string

required

URL of image to use for inpainting. or img2img

float

default:"0.85"

The strength to use for inpainting/image-to-image. Only used if the image_url is provided. 1.0 is completely remakes the image while 0.0 preserves the original. Default value: 0.85Range: 0.01 to 1

Output Schema

list<Image>

required

The generated image files info.

Timings

required

integer

required

Seed of the generated Image. It will be the same value of the one passed in the input or the randomly generated that was used in case none was passed.

list<boolean>

required

Whether the generated images contain NSFW concepts.

string

required

The prompt used for generating the image.

Input Example

{
  "prompt": "A photo of a lion sitting on a stone bench",
  "num_inference_steps": 28,
  "guidance_scale": 3.5,
  "sync_mode": false,
  "num_images": 1,
  "enable_safety_checker": true,
  "output_format": "jpeg",
  "acceleration": "none",
  "image_url": "https://storage.googleapis.com/falserverless/example_inputs/dog.png",
  "strength": 0.85
}

Output Example

{
  "images": [
    {
      "url": "",
      "content_type": "image/jpeg"
    }
  ],
  "prompt": ""
}

Endpoint: POST https://fal.run/fal-ai/flux-lora/inpainting Endpoint ID: fal-ai/flux-lora/inpainting

Try it in the Playground

Run this model interactively with your own prompts.

Quick Start

import fal_client

def on_queue_update(update):
    if isinstance(update, fal_client.InProgress):
        for log in update.logs:
           print(log["message"])

result = fal_client.subscribe(
    "fal-ai/flux-lora/inpainting",
    arguments={
        "prompt": "A photo of a lion sitting on a stone bench",
        "image_url": "https://storage.googleapis.com/falserverless/example_inputs/dog.png",
        "mask_url": "https://storage.googleapis.com/falserverless/example_inputs/dog_mask.png"
    },
    with_logs=True,
    on_queue_update=on_queue_update,
)
print(result)

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

const result = await fal.subscribe("fal-ai/flux-lora/inpainting", {
  input: {
      prompt: "A photo of a lion sitting on a stone bench",
      image_url: "https://storage.googleapis.com/falserverless/example_inputs/dog.png",
      mask_url: "https://storage.googleapis.com/falserverless/example_inputs/dog_mask.png"
    },
  logs: true,
  onQueueUpdate: (update) => {
    if (update.status === "IN_PROGRESS") {
      update.logs.map((log) => log.message).forEach(console.log);
    }
  },
});
console.log(result.data);
console.log(result.requestId);

curl --request POST \
  --url https://fal.run/fal-ai/flux-lora/inpainting \
  --header "Authorization: Key $FAL_KEY" \
  --header "Content-Type: application/json" \
  --data '{
  "prompt": "A photo of a lion sitting on a stone bench",
  "image_url": "https://storage.googleapis.com/falserverless/example_inputs/dog.png",
  "mask_url": "https://storage.googleapis.com/falserverless/example_inputs/dog_mask.png"
}'

Input Schema

string

required

The prompt to generate an image from.

ImageSize | Enum

The size of the generated image.Possible values: square_hd, square, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9

integer

default:"28"

The number of inference steps to perform. Default value: 28Range: 1 to 50

integer

The same seed and the same prompt given to the same version of the model will output the same image every time.

list<LoraWeight>

default:""

The LoRAs to use for the image generation. You can use any number of LoRAs and they will be merged together to generate the final image.

float

default:"3.5"

The CFG (Classifier Free Guidance) scale is a measure of how close you want the model to stick to your prompt when looking for a related image to show you. Default value: 3.5Range: 0 to 35

boolean

default:"false"

If True, the media will be returned as a data URI and the output data won’t be available in the request history.

integer

default:"1"

The number of images to generate. This is always set to 1 for streaming output. Default value: 1Range: 1 to 4

boolean

default:"true"

If set to true, the safety checker will be enabled. Default value: true

OutputFormatEnum

default:"jpeg"

The format of the generated image. Default value: "jpeg"Possible values: jpeg, png

AccelerationEnum

default:"none"

Acceleration level for image generation. ‘regular’ balances speed and quality. Default value: "none"Possible values: none, regular

string

required

URL of image to use for inpainting. or img2img

float

default:"0.85"

string

required

The mask to area to Inpaint in.

Output Schema

list<Image>

required

The generated image files info.

Timings

required

integer

required

Seed of the generated Image. It will be the same value of the one passed in the input or the randomly generated that was used in case none was passed.

list<boolean>

required

Whether the generated images contain NSFW concepts.

string

required

The prompt used for generating the image.

Input Example

{
  "prompt": "A photo of a lion sitting on a stone bench",
  "num_inference_steps": 28,
  "guidance_scale": 3.5,
  "sync_mode": false,
  "num_images": 1,
  "enable_safety_checker": true,
  "output_format": "jpeg",
  "acceleration": "none",
  "image_url": "https://storage.googleapis.com/falserverless/example_inputs/dog.png",
  "strength": 0.85,
  "mask_url": "https://storage.googleapis.com/falserverless/example_inputs/dog_mask.png"
}

Output Example

{
  "images": [
    {
      "url": "",
      "content_type": "image/jpeg"
    }
  ],
  "prompt": ""
}

Endpoint: POST https://fal.run/fal-ai/flux-lora/stream Endpoint ID: fal-ai/flux-lora/stream

Try it in the Playground

Run this model interactively with your own prompts.

Quick Start

import fal_client

def on_queue_update(update):
    if isinstance(update, fal_client.InProgress):
        for log in update.logs:
           print(log["message"])

result = fal_client.subscribe(
    "fal-ai/flux-lora/stream",
    arguments={
        "prompt": "Extreme close-up of a single tiger eye, direct frontal view. Detailed iris and pupil. Sharp focus on eye texture and color. Natural lighting to capture authentic eye shine and depth. The word \"FLUX\" is painted over it in big, white brush strokes with visible texture."
    },
    with_logs=True,
    on_queue_update=on_queue_update,
)
print(result)

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

const result = await fal.subscribe("fal-ai/flux-lora/stream", {
  input: {
      prompt: "Extreme close-up of a single tiger eye, direct frontal view. Detailed iris and pupil. Sharp focus on eye texture and color. Natural lighting to capture authentic eye shine and depth. The word \"FLUX\" is painted over it in big, white brush strokes with visible texture."
    },
  logs: true,
  onQueueUpdate: (update) => {
    if (update.status === "IN_PROGRESS") {
      update.logs.map((log) => log.message).forEach(console.log);
    }
  },
});
console.log(result.data);
console.log(result.requestId);

curl --request POST \
  --url https://fal.run/fal-ai/flux-lora/stream \
  --header "Authorization: Key $FAL_KEY" \
  --header "Content-Type: application/json" \
  --data '{
  "prompt": "Extreme close-up of a single tiger eye, direct frontal view. Detailed iris and pupil. Sharp focus on eye texture and color. Natural lighting to capture authentic eye shine and depth. The word \"FLUX\" is painted over it in big, white brush strokes with visible texture."
}'

Input Schema

string

required

The prompt to generate an image from.

ImageSize | Enum

default:"landscape_4_3"

The size of the generated image. Default value: landscape_4_3Possible values: square_hd, square, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9

integer

default:"28"

The number of inference steps to perform. Default value: 28Range: 1 to 50

integer

The same seed and the same prompt given to the same version of the model will output the same image every time.

list<LoraWeight>

default:""

The LoRAs to use for the image generation. You can use any number of LoRAs and they will be merged together to generate the final image.

float

default:"3.5"

The CFG (Classifier Free Guidance) scale is a measure of how close you want the model to stick to your prompt when looking for a related image to show you. Default value: 3.5Range: 0 to 35

boolean

default:"false"

If True, the media will be returned as a data URI and the output data won’t be available in the request history.

integer

default:"1"

The number of images to generate. This is always set to 1 for streaming output. Default value: 1Range: 1 to 4

boolean

default:"true"

If set to true, the safety checker will be enabled. Default value: true

OutputFormatEnum

default:"jpeg"

The format of the generated image. Default value: "jpeg"Possible values: jpeg, png

AccelerationEnum

default:"none"

Acceleration level for image generation. ‘regular’ balances speed and quality. Default value: "none"Possible values: none, regular

Output Schema

list<Image>

required

The generated image files info.

Timings

required

integer

required

Seed of the generated Image. It will be the same value of the one passed in the input or the randomly generated that was used in case none was passed.

list<boolean>

required

Whether the generated images contain NSFW concepts.

string

required

The prompt used for generating the image.

Input Example

{
  "prompt": "Extreme close-up of a single tiger eye, direct frontal view. Detailed iris and pupil. Sharp focus on eye texture and color. Natural lighting to capture authentic eye shine and depth. The word \"FLUX\" is painted over it in big, white brush strokes with visible texture.",
  "image_size": "landscape_4_3",
  "num_inference_steps": 28,
  "guidance_scale": 3.5,
  "sync_mode": false,
  "num_images": 1,
  "enable_safety_checker": true,
  "output_format": "jpeg",
  "acceleration": "none"
}

Output Example

{
  "images": [
    {
      "url": "",
      "content_type": "image/jpeg"
    }
  ],
  "prompt": ""
}

FLUX.1 [dev] with LoRAs - High-Performance Text-to-Image Generation

Transform your text descriptions into stunning images with FLUX.1 [dev] with LoRA support, enabling rapid and high-quality image generation using pre-trained LoRA adaptations for personalization, specific styles, brand identities, and product-specific outputs.

Overview

FLUX.1 [dev] with LoRAs is a super fast endpoint powered by a 12 billion parameter flow transformer architecture that delivers exceptional image generation capabilities with LoRA support. Whether you’re creating personalized content, generating marketing assets with specific styles, or exploring creative ideas with custom adaptations, FLUX LoRA provides the perfect balance of speed, quality, and customization.

Key Features

Experience industry-leading capabilities designed for both personal and commercial projects:

Advanced LoRA Integration

Transform your vision with precise control over image generation through pre-trained LoRA adaptations. Apply custom styles, brand identities, and personalized elements seamlessly.

Lightning-Fast Generation

Generate high-quality images in seconds with our optimized inference pipeline, leveraging the power of the FLUX.1 [dev] model architecture.

Commercial-Ready Output

All generated images are cleared for commercial use, making FLUX LoRA ideal for professional creative workflows and business applications.

Getting Started

Getting started with FLUX LoRA is straightforward. Here’s how to begin:

Install the SDK Choose your preferred language:

# For JavaScript/TypeScript
npm install --save @fal-ai/client

# For Python
pip install fal-client

Configure Authentication

import { fal } from '@fal-ai/client'

fal.config({
  credentials: 'YOUR_FAL_KEY'
})

Generate Your First Image

const result = await fal.subscribe('fal-ai/flux-lora', {
  input: {
    prompt: 'A serene landscape at sunset, painted in watercolor style',
    loras: [
      {
        path: 'https://example.com/watercolor-style-lora.safetensors',
        scale: 1.0
      }
    ]
  }
})

Best Practices

Maximize your results with these proven approaches:

Prompt Engineering

Write detailed, specific prompts that describe both content and style. For example, instead of “a cat,” try “a Persian cat sitting in a sunlit window, painted in soft watercolor style.”

LoRA Configuration

Use appropriate LoRA scales (typically 0.5-1.5) to balance style application
Combine multiple LoRAs for complex styling effects
Test different LoRA combinations for unique results

Parameter Optimization

Start with default parameters and adjust based on your needs. The model is optimized for rapid generation while maintaining high quality output.

Technical Specifications

Model Architecture

12 billion parameter FLUX.1 [dev] model
Flow transformer architecture
LoRA adaptation support
Support for multiple image dimensions
Commercial use licensing

Input Capabilities

Text prompts with detailed descriptions
Multiple LoRA model support
Negative prompts for content exclusion
Resolution control and customization

Performance

Super fast inference optimized for speed
Concurrent request handling
Reliable uptime and availability

API Reference

The FLUX LoRA API accepts the following core parameters:

interface FluxLoRAParameters {
  prompt: string;              // Your detailed text description
  loras?: Array<{             // LoRA models to apply
    path: string;             // URL to LoRA model file
    scale: number;            // Application strength (0-2)
  }>;
  negative_prompt?: string;    // Elements to avoid in generation
  width?: number;             // Output image width
  height?: number;            // Output image height
  num_inference_steps?: number; // Generation steps
  guidance_scale?: number;     // Prompt adherence strength
  seed?: number;              // For reproducible results
}

Pricing and Usage

Your request will cost $0.035 per megapixel. Images are billed by rounding up to the nearest megapixel. Our transparent, usage-based pricing scales with your needs:

Pay-per-use model based on image resolution
No subscription fees or minimum commitments
Commercial usage rights included
Competitive rates for high-volume usage

View detailed pricing or contact sales for enterprise solutions.

Support and Resources

Take advantage of our comprehensive support system:

Documentation

Access detailed guides and reference materials at our documentation portal at https://docs.fal.ai/

Community Support

Join our active developer community for tips, tricks, and troubleshooting help.

Professional Support

Enterprise users receive dedicated support channels and priority assistance. Ready to transform your creative workflow with FLUX LoRA? Sign up for an API key and start generating stunning, personalized images today. Visit our dashboard to begin your journey with one of the most powerful text-to-image models with LoRA support available.

FLUX.1 [dev] with LoRAs — Image Generation
FLUX.1 [dev] Inpainting with LoRAs — Image Generation

Limitations

image_size restricted to: square_hd, square, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9
num_inference_steps range: 1 to 50
guidance_scale range: 0 to 35
num_images range: 1 to 4
output_format restricted to: jpeg, png
acceleration restricted to: none, regular
Content moderation via safety checker
strength range: 0.01 to 1

Try it in the Playground

​Quick Start

​Examples

​Input Schema

​Output Schema

​Input Example

​Output Example

Try it in the Playground

​Quick Start

​Examples

​Input Schema

​Output Schema

​Input Example

​Output Example

Try it in the Playground

​Quick Start

​Input Schema

​Output Schema

​Input Example

​Output Example

Try it in the Playground

​Quick Start

​Input Schema

​Output Schema

​Input Example

​Output Example

​FLUX.1 [dev] with LoRAs - High-Performance Text-to-Image Generation

​Overview

​Key Features

​Advanced LoRA Integration

​Lightning-Fast Generation

​Commercial-Ready Output

​Getting Started

​Best Practices

​Prompt Engineering

​LoRA Configuration

​Parameter Optimization

​Technical Specifications

​Model Architecture

​Input Capabilities

​Performance

​API Reference

​Pricing and Usage

​Support and Resources

​Documentation

​Community Support

​Professional Support

​Related

​Limitations

Quick Start

Examples

Input Schema

Output Schema

Input Example

Output Example

Quick Start

Examples

Input Schema

Output Schema

Input Example

Output Example

Quick Start

Input Schema

Output Schema

Input Example

Output Example

Quick Start

Input Schema

Output Schema

Input Example

Output Example

FLUX.1 [dev] with LoRAs - High-Performance Text-to-Image Generation

Overview

Key Features

Advanced LoRA Integration

Lightning-Fast Generation

Commercial-Ready Output

Getting Started

Best Practices

Prompt Engineering

LoRA Configuration

Parameter Optimization

Technical Specifications

Model Architecture

Input Capabilities

Performance

API Reference

Pricing and Usage

Support and Resources

Documentation

Community Support

Professional Support

Related

Limitations