fal-ai/flux-2/klein/4b/base

Text-to-image generation with FLUX.2 [klein] 4B Base from Black Forest Labs. Enhanced realism, crisper text generation, and native editing capabilities.

Inference

Commercial use

Streaming

Schema

LLMs

Playground API

About

Text-to-image with FLUX.2 [klein] 4B base model. Uses classifier-free guidance.

1. Calling the API#

Install the client#

The client provides a convenient way to interact with the model API.

npm install --save @fal-ai/client

Migrate to @fal-ai/client

The @fal-ai/serverless-client package has been deprecated in favor of @fal-ai/client. Please check the migration guide for more information.

Setup your API Key#

Set FAL_KEY as an environment variable in your runtime.

export FAL_KEY="YOUR_API_KEY"

Submit a request#

The client API handles the API submit protocol. It will handle the request status updates and return the result when the request is completed.

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

const result = await fal.subscribe("fal-ai/flux-2/klein/4b/base", {
  input: {
    prompt: "Japanese zen garden at first light, perfect rake lines in gravel, koi pond with morning mist, temple bell in background, meditation ready"
  },
  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);

Streaming#

This model supports streaming requests. You can stream data directly to the model and get the result in real-time.

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

const stream = await fal.stream("fal-ai/flux-2/klein/4b/base", {
  input: {
    prompt: "Japanese zen garden at first light, perfect rake lines in gravel, koi pond with morning mist, temple bell in background, meditation ready"
  }
});

for await (const event of stream) {
  console.log(event);
}

const result = await stream.done();

2. Authentication#

The API uses an API Key for authentication. It is recommended you set the FAL_KEY environment variable in your runtime when possible.

API Key#

In case your app is running in an environment where you cannot set environment variables, you can set the API Key manually as a client configuration.

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

fal.config({
  credentials: "YOUR_FAL_KEY"
});

Protect your API Key

When running code on the client-side (e.g. in a browser, mobile app or GUI applications), make sure to not expose your FAL_KEY. Instead, use a server-side proxy to make requests to the API. For more information, check out our server-side integration guide.

3. Queue#

Long-running requests

For long-running requests, such as training jobs or models with slower inference times, it is recommended to check the Queue status and rely on Webhooks instead of blocking while waiting for the result.

Submit a request#

The client API provides a convenient way to submit requests to the model.

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

const { request_id } = await fal.queue.submit("fal-ai/flux-2/klein/4b/base", {
  input: {
    prompt: "Japanese zen garden at first light, perfect rake lines in gravel, koi pond with morning mist, temple bell in background, meditation ready"
  },
  webhookUrl: "https://optional.webhook.url/for/results",
});

Fetch request status#

You can fetch the status of a request to check if it is completed or still in progress.

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

const status = await fal.queue.status("fal-ai/flux-2/klein/4b/base", {
  requestId: "764cabcf-b745-4b3e-ae38-1200304cf45b",
  logs: true,
});

Get the result#

Once the request is completed, you can fetch the result. See the Output Schema for the expected result format.

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

const result = await fal.queue.result("fal-ai/flux-2/klein/4b/base", {
  requestId: "764cabcf-b745-4b3e-ae38-1200304cf45b"
});
console.log(result.data);
console.log(result.requestId);

4. Files#

Some attributes in the API accept file URLs as input. Whenever that's the case you can pass your own URL or a Base64 data URI.

Data URI (base64)#

You can pass a Base64 data URI as a file input. The API will handle the file decoding for you. Keep in mind that for large files, this alternative although convenient can impact the request performance.

Hosted files (URL)#

You can also pass your own URLs as long as they are publicly accessible. Be aware that some hosts might block cross-site requests, rate-limit, or consider the request as a bot.

Uploading files#

We provide a convenient file storage that allows you to upload files and use them in your requests. You can upload files using the client API and use the returned URL in your requests.

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

const file = new File(["Hello, World!"], "hello.txt", { type: "text/plain" });
const url = await fal.storage.upload(file);

Auto uploads

The client will auto-upload the file for you if you pass a binary object (e.g. File, Data).

Read more about file handling in our file upload guide.

5. Schema#

Input#

prompt string* required

The prompt to generate an image from.

negative_prompt string

Negative prompt for classifier-free guidance. Describes what to avoid in the image. Default value: ""

guidance_scale float

Guidance scale for classifier-free guidance. Default value: 5

seed integer

The seed to use for the generation. If not provided, a random seed will be used.

num_inference_steps integer

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

image_size ImageSize | Enum

The size of the image to generate. Default value: landscape_4_3

Possible enum values: square_hd, square, portrait_4_3, portrait_16_9, landscape_4_3, landscape_16_9

Note: For custom image sizes, you can pass the width and height as an object:

"image_size": {
  "width": 1280,
  "height": 720
}

num_images integer

The number of images to generate. Default value: 1

acceleration AccelerationEnum

The acceleration level to use for image generation. Default value: "regular"

Possible enum values: none, regular, high

sync_mode boolean

If True, the media will be returned as a data URI. Output is not stored when this is True.

enable_safety_checker boolean

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

output_format OutputFormatEnum

The format of the generated image. Default value: "png"

Possible enum values: jpeg, png, webp

enable_cns boolean

Enable Colored Noise Sampling (CNS), a stochastic SDE sampler. Off by default; when enabled the cns_* parameters below take effect.

cns_s_churn float

How much stochastic (colored) noise is injected after each step. 0 = CNS off, i.e. pure deterministic flow-matching (identical to normal klein); higher = more stochasticity. Turn this first; the other CNS parameters only matter when s_churn > 0. Default value: 0.5

cns_gamma_source CNSGammaSourceEnum

Where the per-frequency progress signal gamma(f, t) comes from. 'approximation' is self-contained but uniform across bands, so the frequency shaping comes entirely from the alpha-tilt parameters. 'matrix' uses the precomputed per-band gamma for true spectral-bias-aware coloring (more noise to genuinely under-resolved bands). Default value: "matrix"

Possible enum values: matrix, approximation

cns_power_gamma float

Exponent on the residual (1 - gamma). Higher concentrates noise more aggressively on unresolved bands; lower is gentler and flatter. No effect under 'approximation', where gamma is uniform. Default value: 0.75

cns_gamma_divider float

Divides gamma first, weakening the coloring (pushing it toward uniform white noise). Paper uses 1.73 for distilled/unguided and 25.0 for CFG/base, so raise this for the /base (CFG) endpoints. Default value: 1.73

cns_alpha_tilt_start float

Frequency tilt at the start of sampling, interpolated toward the end value over steps. Positive boosts high frequencies (fine texture/detail); negative boosts low frequencies (structure). Default value: 0.15

cns_alpha_tilt_end float

Frequency tilt at the end of sampling. Positive boosts high frequencies (fine texture/detail); negative boosts low frequencies (structure). The default favors low-frequency structure at the end. Default value: -0.5

cns_alpha_use_fnorm boolean

Use a smooth, frequency-position-weighted tilt (exp(alpha * f)) instead of a flat (1 + alpha) multiplier. Default value: true

cns_alpha_exp_interp boolean

Use an exponential (vs linear) curve for the start-to-end tilt transition across sampling steps. Default value: true

cns_alpha_exp_sharpness float

How sharp the exponential tilt-interpolation curve is. Only used when exponential interpolation is enabled. Default value: 0.75

cns_num_freq_bins integer

How many radial frequency bands the spectrum is split into. More bands = finer-grained coloring. Default value: 32

cns_energy_scale float

Global multiplier on the injected colored noise after variance normalisation. <1 slightly damps the kick, >1 amplifies it (paper: 0.98 unguided, 0.998 guided). Default value: 0.98

{
  "prompt": "Japanese zen garden at first light, perfect rake lines in gravel, koi pond with morning mist, temple bell in background, meditation ready",
  "guidance_scale": 5,
  "num_inference_steps": 28,
  "image_size": "landscape_4_3",
  "num_images": 1,
  "acceleration": "regular",
  "enable_safety_checker": true,
  "output_format": "png",
  "cns_s_churn": 0.5,
  "cns_gamma_source": "matrix",
  "cns_power_gamma": 0.75,
  "cns_gamma_divider": 1.73,
  "cns_alpha_tilt_start": 0.15,
  "cns_alpha_tilt_end": -0.5,
  "cns_alpha_use_fnorm": true,
  "cns_alpha_exp_interp": true,
  "cns_alpha_exp_sharpness": 0.75,
  "cns_num_freq_bins": 32,
  "cns_energy_scale": 0.98
}

Output#

images list<ImageFile>* required

The generated images

timings Timings* required

seed 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.

has_nsfw_concepts list<boolean>* required

Whether the generated images contain NSFW concepts.

prompt string* required

The prompt used for generating the image.

{
  "images": [
    {
      "url": "https://v3b.fal.media/files/b/0a8a69c2/5IoN78I6tZ8ZH69SB3PhW.png"
    }
  ],
  "prompt": ""
}

Other types#

ImageFile#

url string* required

The URL where the file can be downloaded from.

content_type string

The mime type of the file.

file_name string

The name of the file. It will be auto-generated if not provided.

file_size integer

The size of the file in bytes.

width integer

The width of the image

height integer

The height of the image

ImageSize#

width integer

The width of the generated image. Default value: 512

height integer

The height of the generated image. Default value: 512

RawImage#

width integer* required

height integer* required

content_type string

Default value: "image/jpeg"

content string* required

fal-ai/flux-2/klein/4b/base

Table of contents

1. Calling the API

2. Authentication

3. Queue

4. Files

5. Schema

About

1. Calling the API#

Install the client#

Migrate to @fal-ai/client

Setup your API Key#

Submit a request#

Streaming#

2. Authentication#

API Key#

Protect your API Key

3. Queue#

Long-running requests

Submit a request#

Fetch request status#

Get the result#

4. Files#

Data URI (base64)#

Hosted files (URL)#

Uploading files#

Auto uploads

5. Schema#

Input#

Output#

Other types#

ImageFile#

ImageSize#

RawImage#

Related Models