Flux Depth Dev

flux-depth-dev

Flux Depth Dev Model provides developers with tools to manipulate and analyze depth in images creatively

Partner Model

Fast Inference

REST API

Try in Console API Docs Examples

Model Information

Response Time~10 sec

StatusActive

Version

0.0.1

Updatedabout 11 hours ago

Live Demo

Average runtime: ~10 seconds

Input

Configure model parameters

Prompt

Prompt for generated image

A tropical beach

Control Image

Image used to control the generation. The depth map will be automatically generated.

File upload is currently disabled

JPEGPNGJPGWEBP

Guidance

Guidance for generated image

output_format

An enumeration.

megapixels

An enumeration.

Output

View generated results

Result

Preview, share or download your results with a single click.

Each execution costs $0.028 With $1 you can run this model about 35 times.

API Reference

View Full Documentation

Prerequisites

Create an API Key from the Eachlabs Console
Install the required dependencies for your chosen language (e.g., requests for Python)

API Integration Steps

1. Create a Prediction

Send a POST request to create a new prediction. This will return a prediction ID that you'll use to check the result. The request should include your model inputs and API key.

import requests
import time

API_KEY = "YOUR_API_KEY"  # Replace with your API key
HEADERS = {
    "X-API-Key": API_KEY,
    "Content-Type": "application/json"
}

def create_prediction():
    response = requests.post(
        "https://api.eachlabs.ai/v1/prediction/",
        headers=HEADERS,
        json={
            "model": "flux-depth-dev",
            "version": "0.0.1",
            "input": {
  "seed": null,
  "prompt": "your prompt here",
  "guidance": "10",
  "megapixels": "1",
  "num_outputs": "1",
  "control_image": "your_file.image/jpeg",
  "output_format": "webp",
  "output_quality": "80",
  "num_inference_steps": "28",
  "disable_safety_checker": false
}
        }
    )
    prediction = response.json()
    
    if prediction["status"] != "success":
        raise Exception(f"Prediction failed: {prediction}")
    
    return prediction["predictionID"]

2. Get Prediction Result

Poll the prediction endpoint with the prediction ID until the result is ready. The API uses long-polling, so you'll need to repeatedly check until you receive a success status.

def get_prediction(prediction_id):
    while True:
        result = requests.get(
            f"https://api.eachlabs.ai/v1/prediction/{prediction_id}",
            headers=HEADERS
        ).json()
        
        if result["status"] == "success":
            return result
        elif result["status"] == "error":
            raise Exception(f"Prediction failed: {result}")
        
        time.sleep(1)  # Wait before polling again

3. Complete Example

Here's a complete example that puts it all together, including error handling and result processing. This shows how to create a prediction and wait for the result in a production environment.

try:
    # Create prediction
    prediction_id = create_prediction()
    print(f"Prediction created: {prediction_id}")
    
    # Get result
    result = get_prediction(prediction_id)
    print(f"Output URL: {result['output']}")
    print(f"Processing time: {result['metrics']['predict_time']}s")
except Exception as e:
    print(f"Error: {e}")

Additional Information

The API uses a two-step process: create prediction and poll for results
Response time: ~10 seconds
Rate limit: 60 requests/minute
Concurrent requests: 10 maximum
Use long-polling to check prediction status until completion

Overview

Flux Depth Dev leverages state-of-the-art algorithms to generate highly realistic and creative visuals. By combining textual descriptions with optional image inputs, it adapts to a wide range of use cases, from artistic endeavors to professional applications.

Technical Specifications

Generative Framework: Utilizes a robust architecture optimized for image-guided generation.

High Customizability: Offers adjustable parameters like resolution, guidance scale, and output format to meet diverse requirements.

Key Considerations

Higher resolution or multiple outputs significantly increase processing time.

Disabling the safety checker should only be done with caution, as it may generate unexpected results.

Extremely high values for guidance may limit the model's creative flexibility.

Legal Information

By using this model, you agree to:

Black Forest Labs API agreement
Black Forest Labs Terms of Service

Tips & Tricks

Optimal guidance Values: Start with 7-10 for a balanced blend of creativity and adherence.

Seed Control: Randomize for exploration, then fix a seed for consistency.

Megapixels for Print: Choose higher values for projects needing physical prints.

Clarity in Prompts: Be concise and vivid when describing your desired output. Avoid ambiguous language.

Configuring steps: Start with moderate values like 20 and adjust upward for more intricate outputs.

Safety Checker: For experimental designs, disabling the safety checker may enable unrestricted creativity but review outputs for suitability.

Capabilities

Photo-realistic imagery.

Abstract designs and creative compositions.

Personalized visuals through image blending.

High-resolution outputs for print-quality projects.

What can I use for?

Creating concept art and storyboards.

Generating unique visual assets for marketing and branding.

Experimenting with artistic styles for personal or professional projects.

Things to be aware of

Control the Degree of Guidance:

Adjusting how much influence the model should give to the provided prompt can drastically alter the output. With higher guidance values, the model will focus more on the prompt details, producing more accurate depth maps based on the input description. Lower guidance values may yield softer, more interpretative results. Testing different levels of guidance will help find the perfect balance between control and creativity.

Quality vs. Speed Trade-off:

If time is a factor, consider adjusting the quality of the output. Lower quality may produce faster results, while higher quality settings lead to more refined and detailed outputs but require more time to process. Experiment with different quality settings to find the optimal speed and accuracy for your needs.

Resolution and Detail:

Experimenting with different resolution settings will allow you to control the level of detail in the depth map. Higher resolution outputs (larger megapixel settings) will generate more detailed depth maps but will also take more time. Try testing different resolutions to balance processing time and quality.

Use Control Images for Better Accuracy:

If you're working with a particular scene or environment, uploading a reference or control image can greatly improve the accuracy of the depth map. The model will be able to better understand the context and generate depth information that aligns with the control image.

Adjusting Inference Steps for Detail:

The number of inference steps plays a crucial role in determining how detailed the output will be. Increasing the number of inference steps typically results in a more refined depth map, while lower steps may produce faster but less detailed outputs. Experiment with this setting to find the ideal balance between speed and quality.