3 passos para concluir a integração da API do FLUX.2 Pro e Max: guia prático do modelo de geração de imagens mais potente da BFL

A série FLUX.2 da Black Forest Labs tornou-se um dos modelos de geração de imagem mais comentados de 2025. Como acessar rapidamente as APIs do FLUX.2 Pro e FLUX.2 Max é uma dúvida comum de muitos desenvolvedores e profissionais criativos. Este artigo fornecerá um guia completo de acesso para ajudar você a concluir a integração em apenas 5 minutos.

Valor Central: Ao ler este artigo, você dominará os métodos de chamada da API FLUX.2 Pro/Max, técnicas de configuração de parâmetros e entenderá como escolher a versão do modelo mais adequada para o seu projeto.

Visão Geral da Série FLUX.2

Antes de começar a integração, vamos conhecer as informações principais da série FLUX.2:

Matriz de Modelos FLUX.2

🎯 Sugestão de Acesso: Para a maioria dos cenários de produção, recomendamos acessar o FLUX.2 Pro através da plataforma APIYI (apiyi.com). Esta plataforma oferece uma interface unificada compatível com OpenAI, eliminando a necessidade de lidar com processos complexos de autenticação da API oficial.

Diferenças principais entre FLUX.2 Pro vs Max

Escolher o FLUX.2 Pro ou o Max? Essa é a pergunta que os desenvolvedores mais fazem. A tabela abaixo detalha as diferenças entre os dois:

Sugestões de Escolha

Quando escolher o FLUX.2 [pro]:

• Geração em lote de fotos de produtos para e-commerce
• Criação de conteúdo para redes sociais
• Produção em massa de materiais publicitários
• Projetos sensíveis ao custo
• Necessidade de saídas estáveis e consistentes

Quando escolher o FLUX.2 [max]:

• Criativos publicitários para marcas de luxo
• Imagens que precisam incluir informações atuais e fatos recentes
• Criação artística e design conceitual
• Reconstrução precisa de cenários complexos
• Uso profissional com exigência extrema de qualidade

Acesso Rápido à API FLUX.2

Método 1: Via interface unificada APIYI (Recomendado)

A plataforma APIYI já disponibilizou o FLUX.2 Pro e o FLUX.2 Max, com suporte para chamadas no formato compatível com OpenAI:

import requests

# Interface unificada APIYI
base_url = "https://api.apiyi.com/v1"

def generate_image_flux2(prompt, model="flux.2-pro", width=1024, height=1024):
    """
    Chama o FLUX.2 via APIYI para gerar imagens

    Args:
        prompt: comando da imagem
        model: flux.2-pro ou flux.2-max
        width: largura da imagem (múltiplo de 16, máx. 2048)
        height: altura da imagem (múltiplo de 16, máx. 2048)
    """
    headers = {
        "Authorization": "Bearer YOUR_APIYI_KEY",
        "Content-Type": "application/json"
    }

    data = {
        "model": model,
        "prompt": prompt,
        "size": f"{width}x{height}",
        "response_format": "url"
    }

    response = requests.post(
        f"{base_url}/images/generations",
        json=data,
        headers=headers
    )

    result = response.json()
    return result["data"][0]["url"]


# Exemplo de uso
image_url = generate_image_flux2(
    prompt="A professional product photo of a modern smartphone on marble surface, soft studio lighting, ultra detailed",
    model="flux.2-pro",
    width=1024,
    height=1024
)
print(f"Imagem gerada: {image_url}")

🚀 Começo rápido: Recomendamos usar a plataforma APIYI (apiyi.com) para acessar o FLUX.2 rapidamente. A plataforma oferece uma interface API pronta para uso, sem configurações complexas, e suporta chamadas diretas via SDK da OpenAI.

Método 2: API oficial da BFL

Caso precise usar diretamente a API oficial da Black Forest Labs:

import requests
import time

class FLUX2Client:
    """Cliente oficial da API FLUX.2"""

    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.bfl.ai/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

    def generate(self, prompt, model="flux-2-pro", **kwargs):
        """
        Gerar imagem

        Args:
            prompt: comando da imagem
            model: flux-2-pro, flux-2-max, flux-2-flex
            **kwargs: width, height, seed, output_format, safety_tolerance
        """
        endpoint = f"{self.base_url}/{model}"

        data = {
            "prompt": prompt,
            "width": kwargs.get("width", 1024),
            "height": kwargs.get("height", 1024),
            "output_format": kwargs.get("output_format", "png")
        }

        # Adicionar parâmetros opcionais
        if "seed" in kwargs:
            data["seed"] = kwargs["seed"]
        if "safety_tolerance" in kwargs:
            data["safety_tolerance"] = kwargs["safety_tolerance"]

        response = requests.post(endpoint, json=data, headers=self.headers)
        return response.json()

    def generate_with_flex(self, prompt, steps=50, guidance=4.5, **kwargs):
        """
        Gerar com FLUX.2 [flex] (suporta ajuste de parâmetros)

        Args:
            prompt: comando da imagem
            steps: passos de amostragem 1-50
            guidance: coeficiente de orientação 1.5-10
        """
        data = {
            "prompt": prompt,
            "steps": steps,
            "guidance": guidance,
            "width": kwargs.get("width", 1024),
            "height": kwargs.get("height", 1024)
        }

        response = requests.post(
            f"{self.base_url}/flux-2-flex",
            json=data,
            headers=self.headers
        )
        return response.json()


# Exemplo de uso
client = FLUX2Client("YOUR_BFL_API_KEY")

# Usando a versão Pro
result = client.generate(
    prompt="A serene Japanese garden with cherry blossoms",
    model="flux-2-pro",
    width=1536,
    height=1024
)
print(f"Resultado da geração Pro: {result}")

# Usando a versão Max (qualidade máxima)
result_max = client.generate(
    prompt="A futuristic cityscape at night, neon lights, cyberpunk style, ultra detailed",
    model="flux-2-max",
    width=2048,
    height=2048
)
print(f"Resultado da geração Max: {result_max}")

import asyncio
import aiohttp
from typing import List, Dict

class AsyncFLUX2Client:
    """Cliente assíncrono FLUX.2, suporta geração em lote"""

    def __init__(self, api_key: str, base_url: str = "https://api.apiyi.com/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

    async def generate_single(self, session: aiohttp.ClientSession,
                              prompt: str, model: str = "flux.2-pro",
                              width: int = 1024, height: int = 1024) -> Dict:
        """Gera uma única imagem de forma assíncrona"""
        data = {
            "model": model,
            "prompt": prompt,
            "size": f"{width}x{height}",
            "response_format": "url"
        }

        async with session.post(
            f"{self.base_url}/images/generations",
            json=data,
            headers=self.headers
        ) as response:
            return await response.json()

    async def generate_batch(self, prompts: List[str],
                             model: str = "flux.2-pro",
                             max_concurrent: int = 5) -> List[Dict]:
        """
        Gerar imagens em lote

        Args:
            prompts: lista de comandos
            model: versão do modelo
            max_concurrent: número máximo de concorrência
        """
        semaphore = asyncio.Semaphore(max_concurrent)

        async def limited_generate(session, prompt):
            async with semaphore:
                return await self.generate_single(session, prompt, model)

        async with aiohttp.ClientSession() as session:
            tasks = [limited_generate(session, p) for p in prompts]
            results = await asyncio.gather(*tasks, return_exceptions=True)

        return results


async def main():
    client = AsyncFLUX2Client("YOUR_APIYI_KEY")

    prompts = [
        "A modern minimalist living room with natural lighting",
        "A vintage coffee shop interior with warm tones",
        "A futuristic office space with holographic displays",
        "A cozy bookstore with wooden shelves",
        "A high-tech laboratory with blue lighting"
    ]

    print("Iniciando geração em lote...")
    results = await client.generate_batch(prompts, model="flux.2-pro")

    for i, result in enumerate(results):
        if isinstance(result, Exception):
            print(f"Falha na geração da imagem {i+1}: {result}")
        else:
            print(f"Imagem {i+1}: {result['data'][0]['url']}")


if __name__ == "__main__":
    asyncio.run(main())

Detalhamento dos Parâmetros Principais da API FLUX.2

{{SVG_TEXT_0

Recursos Avançados: Referência de Múltiplas Imagens e Edição de Imagem

O FLUX.2 suporta a entrada de até 10 imagens de referência, permitindo recursos avançados como transferência de estilo, consistência de personagens e muito mais:

import base64
import requests

def generate_with_references(prompt, reference_images, model="flux.2-pro"):
    """
    Geração usando imagens de referência

    Args:
        prompt: Descrição da imagem
        reference_images: Lista de URLs ou base64 de imagens de referência (máximo 10)
        model: Versão do modelo
    """
    headers = {
        "Authorization": "Bearer YOUR_APIYI_KEY",
        "Content-Type": "application/json"
    }

    # Processar imagens de referência
    images = []
    for img in reference_images[:10]:  # Máximo de 10 imagens
        if img.startswith("http"):
            images.append({"type": "url", "url": img})
        else:
            images.append({"type": "base64", "data": img})

    data = {
        "model": model,
        "prompt": prompt,
        "reference_images": images,
        "size": "1024x1024"
    }

    response = requests.post(
        "https://api.apiyi.com/v1/images/generations",
        json=data,
        headers=headers
    )

    return response.json()


# Exemplo de uso: Mantendo a consistência do personagem
result = generate_with_references(
    prompt="Same character in a coffee shop, reading a book, warm lighting",
    reference_images=[
        "https://example.com/character_ref1.jpg",
        "https://example.com/character_ref2.jpg"
    ],
    model="flux.2-max"
)

Recursos de Edição de Imagem

O FLUX.2 suporta edição de imagens baseada em linguagem natural:

def edit_image(source_image, edit_prompt, model="flux.2-pro"):
    """
    Editar imagem existente

    Args:
        source_image: URL ou base64 da imagem de origem
        edit_prompt: Comando de edição
        model: Versão do modelo
    """
    headers = {
        "Authorization": "Bearer YOUR_APIYI_KEY",
        "Content-Type": "application/json"
    }

    data = {
        "model": model,
        "prompt": edit_prompt,
        "image": source_image,
        "mode": "edit"
    }

    response = requests.post(
        "https://api.apiyi.com/v1/images/edits",
        json=data,
        headers=headers
    )

    return response.json()


# Exemplo de uso
result = edit_image(
    source_image="https://example.com/room.jpg",
    edit_prompt="Change the wall color to light blue, add plants near the window",
    model="flux.2-pro"
)

Melhores Práticas de Comandos (Prompts) no FLUX.2

O modelo de linguagem visual Mistral-3 24B do FLUX.2 possui uma forte capacidade de compreensão de comandos. Aqui estão algumas dicas para otimizá-los:

Template de Estrutura de Comando

[Descrição do Assunto] + [Definição de Estilo] + [Iluminação/Atmosfera] + [Requisitos de Detalhes] + [Modificadores de Qualidade]

Exemplos de Bons Comandos

Dicas de Controle de Cores

O FLUX.2 suporta controle preciso de cores via códigos hexadecimais:

# Use códigos de cores hex para garantir a precisão das cores da marca
prompt = """
A modern tech company logo mockup on business card,
primary color: #FF6B35 (orange),
secondary color: #1A1A2E (dark navy),
clean minimalist design, professional presentation
"""

Otimização de Custos e Melhores Práticas

Exemplo de Cálculo de Preços

Estratégias de Otimização de Custos

1. Otimização de Resolução: Escolha a resolução adequada de acordo com o uso real para evitar excessos.
2. Escolha do Modelo: Use o Pro para conteúdos em lote e o Max para conteúdos premium.
3. Iteração de Pré-visualização: Use o Flex com poucos steps para pré-visualizações rápidas e só gere a saída de alta qualidade quando estiver satisfeito.
4. Processamento em Lote: Utilize interfaces de lote assíncronas para aumentar a eficiência.

💰 Comparação de Custos: Ao acessar o FLUX.2 através da plataforma APIYI (apiyi.com), você pode obter formas de faturamento mais flexíveis. Para usuários com grande volume de chamadas mensais, a plataforma oferece descontos progressivos.

Perguntas Frequentes (FAQ)

result = generate_image(
    prompt="A red apple on wooden table",
    seed=12345  # Semente fixa
)

import time
from requests.exceptions import Timeout, RequestException

def generate_with_retry(prompt, max_retries=3):
    for attempt in range(max_retries):
        try:
            result = generate_image(prompt, timeout=60)
            return result
        except Timeout:
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)  # backoff exponencial
            continue
        except RequestException as e:
            print(f"Erro na requisição: {e}")
            break
    return None

Resumo da Integração da API FLUX.2

{Caminho de acesso rápido à API FLUX.2} {Conclua a integração em 5 minutos através da plataforma APIYI}

{1} {Registrar conta}

<text x="60" y="140" text-anchor="middle" fill="#e2e8f0" font-size="11" font-family="Arial, sans-serif">{Acesse apiyi.com}</text>
<text x="60" y="158" text-anchor="middle" fill="#94a3b8" font-size="10" font-family="Arial, sans-serif">{Conclua em 1 minuto}</text>

{2} {Obter Key}

<text x="60" y="140" text-anchor="middle" fill="#e2e8f0" font-size="11" font-family="Arial, sans-serif">{Criar Chave de API}</text>
<text x="60" y="158" text-anchor="middle" fill="#94a3b8" font-size="10" font-family="Arial, sans-serif">{Crédito de teste gratuito}</text>

{3} {Chamar API}

<text x="60" y="140" text-anchor="middle" fill="#e2e8f0" font-size="11" font-family="Arial, sans-serif">{Exemplos de uso de código}</text>
<text x="60" y="158" text-anchor="middle" fill="#94a3b8" font-size="10" font-family="Arial, sans-serif">{Formato compatível com OpenAI}</text>

{4} {Obter imagem}

<text x="60" y="140" text-anchor="middle" fill="#e2e8f0" font-size="11" font-family="Arial, sans-serif">{Geração concluída}</text>
<text x="60" y="158" text-anchor="middle" fill="#94a3b8" font-size="10" font-family="Arial, sans-serif">{Saída de alta definição de 4MP}</text>

{Interface unificada} {Compatível com OpenAI SDK}

{Serviço estável} {99,9% de disponibilidade}

{Cobrança flexível} {Pagamento por uso / Assinatura mensal}

{Suporte técnico} {Resposta de equipe profissional}

A série FLUX.2 representa o que há de mais moderno na tecnologia de geração de imagens atual. Confira os pontos principais abordados neste artigo:

Caminho de integração recomendado:

1. Acesse apiyi.com e registre uma conta
2. Obtenha sua API Key
3. Use os exemplos de código deste artigo para uma integração rápida
4. Ajuste os comandos e parâmetros conforme os resultados obtidos

Através da plataforma APIYI, você pode acessar rapidamente o FLUX.2 Pro e Max, aproveitando as vantagens de uma interface unificada, serviço estável e faturamento flexível.

Leitura complementar:

• Documentação oficial do FLUX.2: docs.bfl.ai
• Apresentação dos modelos FLUX.2: bfl.ai/models/flux-2
• Blog oficial do FLUX.2: bfl.ai/blog/flux-2

Este artigo foi escrito pela equipe técnica da APIYI. Para saber mais sobre soluções de integração de APIs de modelos de IA, visite apiyi.com