Construa com CometAPIPrecisa de uma API para vários modelos?Teste o fluxo no Playground e depois crie uma chave da API quando o modelo e o custo atenderem ao seu caso de uso.
Como usar a API Flux.2? Tudo o que você precisa saber
FLUX.2 é a família de modelos de geração e edição de imagens de segunda geração da Black Forest Labs (lançada em Nov 25, 2025). Oferece nível de produção
FLUX.2 é a família de segunda geração de modelos de geração e edição de imagens da Black Forest Labs (lançada em 25 de nov. de 2025). Ela oferece fotorrealismo de nível de produção, edição com múltiplas referências de até 4 MP, prompting estruturado/JSON e a opção entre endpoints gerenciados (Pro, Flex) e opções de pesos abertos (Dev).
A boa notícia é que a CometAPI integrou a API do Flux.2. Este guia explica o que é o FLUX.2, como chamar a API e fluxos de trabalho avançados (texto→imagem, controle flexível, edição com múltiplas referências), com exemplos de código e boas práticas.
O que é o FLUX.2 e por que ele importa?
O FLUX.2 é a continuação da família FLUX de modelos de imagem — projetado para geração de texto para imagem com alta fidelidade e edição de imagens com múltiplas referências em resoluções de produção (até ~4 megapixels). O FLUX.2 foi criado para fluxos de trabalho criativos reais (ativos seguros para marca, consistência de personagens e estilos entre referências, melhor tipografia e pequenos detalhes), e não apenas para demonstrações, com o objetivo de reduzir a diferença entre imagens geradas e imagens reais.
Revisado para maior clareza, atribuição de fontes e terminologia de API atual.
Principais resultados que o FLUX.2 foi projetado para entregar
Saídas fotorrealistas adequadas para publicidade, imagens de produtos e mockups de UI.
Edição nativa com múltiplas referências: combine, troque ou componha elementos de várias imagens de entrada em uma única edição.
Variantes para diferentes casos de uso: modelos para desenvolvedores com disponibilidade aberta, um endpoint Pro otimizado para produção e um endpoint Flex para controle de baixo nível.
Em alto nível, o FLUX.2 combina uma base generativa latente (arquitetura flow/transformer) com um modelo visão-linguagem para ancoragem semântica, além de um VAE treinado recentemente para fornecer um espaço latente compartilhado entre variantes. Esse design permite que o modelo faça tanto geração quanto reconstrução (edição) com maior fidelidade, mantendo a representação treinável para treinamento e fine-tuning. O VAE aberto é particularmente notável porque padroniza o espaço latente para fluxos de trabalho hospedados e auto-hospedados.
Por que isso importa: acoplar linguagem e correspondência de fluxo latente gera melhor aderência ao prompt (assim, instruções compostas por várias partes se comportam de forma previsível), melhor tipografia e uma arquitetura única que oferece suporte tanto à geração quanto à edição com múltiplas referências. Para criadores, isso significa saídas mais confiáveis para instruções complexas e entradas mistas (texto + imagens).
Como acesso a API do FLUX.2?
Prepare o ambiente
Cadastre-se e faça login na CometAPI e obtenha sua chave de API no painel do seu perfil. Idealmente, você deve ter algum conhecimento de API como desenvolvedor (forneceremos assistência nesse sentido, então não se preocupe).
Você também precisará selecionar o método de solicitação desejado e o modelo Flux.2 apropriado.
Quais endpoints e autenticação são necessários?
A API de Predictions da Replicate fornece acesso para gerar imagens de alta qualidade usando vários modelos FLUX da Black Forest Labs por meio do formato padrão da Replicate. Esta API oferece suporte a uma ampla gama de variantes do modelo FLUX, cada uma otimizada para diferentes casos de uso, desde prototipagem rápida até geração de imagens de nível profissional. Os usuários podem alternar facilmente entre diferentes modelos simplesmente alterando o nome do modelo no caminho da URL(https://api.cometapi.com/replicate/v1/models/{models}/predictions), tornando-a flexível para várias aplicações criativas e comerciais.
CometAPI expõe endpoints gerenciados em https://api.cometapi.com/flux/v1/{model} e nomeia endpoints como flux-2-pro, flux-2-flex e flux-2-flex para criação e edição de imagens. As solicitações exigem uma chave de API no cabeçalho x-key .
Família de modelos e trade-offs de computação
FLUX.2 (pesos abertos) — Use quando precisar de controle local, experimentos de pesquisa ou executar inferência em sua própria infraestrutura. Dev tem pesos abertos (32B) e é excelente para pesquisa exploratória e fine-tuning. É mais configurável, mas você é responsável pela infraestrutura e otimização.
FLUX.2 pro — Melhor equilíbrio entre velocidade, qualidade e custo para produção. O Pro é ajustado para latência previsível, aderência consistente ao prompt, alto throughput e suporta até 8 imagens de referência por API (9 MP no total via API). Use-o para edição em alto volume e quando precisar de confiabilidade e preços previsíveis.
FLUX.2 (gerenciado + controlabilidade) — Expõe controles de geração de baixo nível (por exemplo, steps, guidance) e suporta mais referências (até 10) e qualidade/detalhe um pouco maiores quando você aceita maior latência e custo. Use o Flex quando precisar do controle criativo final — fidelidade tipográfica, cores exatas ou ajustes de composição altamente detalhados.
Crie protótipos no Dev ou em um plano Pro de baixo custo e depois migre para o Pro para escalar ou para o Flex para renders finais altamente controlados.
Como uso a API do FLUX.2?
Ciclo de vida da solicitação (modelo de tarefa + polling)
As respostas para solicitações de edição/geração são objetos de tarefa que incluem um polling_url e id; você cria uma solicitação e depois faz polling (ou usa webhooks) para recuperar a URL assinada do resultado. URLs assinadas têm curta duração (normalmente ~10 minutos), portanto recupere as saídas prontamente.
A API hospedada segue um modelo de tarefa assíncrona:
Faça POST de uma solicitação de geração → retorna um task id e polling_url mais o cost estimado.
Faça polling do polling_url até status == "Ready" e, em seguida, recupere o resultado da imagem (geralmente base64 ou uma URL hospedada).
Exemplo: Python (requests) — enviar e consultar
import time, requests, os
API_KEY = os.environ
API_URL = "https://api.cometapi.com/flux/v1/flux-2-pro"
payload = {
"prompt": "A high-end product photo of a ceramic mug on a wooden desk, soft window light.",
"width": 1024, "height": 1024, "seed": 42
}
r = requests.post(API_URL, headers={"x-key": API_KEY, "accept":"application/json"}, json=payload)
r.raise_for_status()
task = r.json()
polling_url = task
while True:
time.sleep(0.5)
status_r = requests.get(polling_url, headers={"x-key": API_KEY})
status_r.raise_for_status()
status = status_r.json()
if status == "Ready":
print("Result URL:", status)
break
elif status in ("Error", "Failed"):
print("Generation failed:", status)
break
Esse padrão (enviar → polling ou webhook) é o principal fluxo síncrono/assíncrono para os endpoints gerenciados.
Edição de imagem — exemplo mínimo (curl com URL de entrada)
curl -X POST "https://api.cometapi.com/flux/v1/flux-2-pro" \
-H "accept: application/json" \
-H "x-key: $CometAPI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"prompt": "Replace the background with a sunlit seaside boardwalk, keep the person intact and match lighting",
"input_image": "https://example.com/my-photo.jpg",
"width": 2048,
"height": 1536
}'
Para edição com múltiplas referências, use input_image, input_image_2, input_image_3, … (o Pro suporta até 8 referências via API; o Flex até 10; no Dev, o máximo recomendado é ~6, dependendo da memória).
Quais parâmetros básicos devo enviar?
Campos importantes do corpo da solicitação (edição / geração de imagem) incluem:
guidance e steps — permitem controle refinado.
prompt (string) — até 32K tokens; linguagem natural detalhada ou JSON estruturado.
input_image (string) — obrigatório para edições (URL ou base64).
input_image_2 … input_image_9 — imagens de múltiplas referências.
width / height — múltiplos de 16; saída máxima de 4 MP.
seed — inteiro para reprodutibilidade.
safety_tolerance — nível de moderação.
Como posso aproveitar o FLUX.2 Pro para geração profissional de texto para imagem?
O FLUX.2 Pro é ajustado para saídas confiáveis e de alta qualidade. Use-o quando precisar de resultados consistentes em nível de marca, retorno rápido e SLAs empresariais.
Receita de fluxo de trabalho — imagens de produção
Pré-processe os prompts: mantenha uma linha curta de “intenção” mais uma seção estruturada de atributos (iluminação, lente, clima, códigos hexadecimais de cor para cores da marca). O FLUX.2 oferece suporte a direcionamento por cores hexadecimais para ajudar a preservar paletas de marca.
Comece com padrões conservadores: steps 30–50 e escala de guidance 6–9.0; aumente os steps para mais detalhes, aumente a guidance para fazer com que os resultados sigam o prompt mais estritamente.
Use seeds + amostragem determinística para reprodutibilidade em testes A/B.
Use o endpoint Pro para amostragem com múltiplas tentativas: solicite N variações em paralelo e escolha a melhor — mais barato e rápido do que ajuste manual de hiperparâmetros.
Pós-processe: denoise, pequeno tone mapping ou retoques em estilo vetorial em um pipeline determinístico. Considere um pequeno GAN ou uma etapa de super-resolução se precisar de saída maior que a nativa.
Por que essas etapas ajudam: o Pro equilibra velocidade e fidelidade e geralmente aplica filtros de segurança/conteúdo após a geração, então é a escolha padrão sensata para ativos voltados ao cliente.
Melhores dicas para gerar imagens
1. Prompting estruturado vence em produção. Organize os prompts por prioridade: assunto → ação → estilo → contexto. Use prompting em JSON (scene, subjects, camera, lighting, color_palette) quando precisar de composição determinística em muitas imagens. Exemplo de uso de esquema JSON (pseudo):
2. Reprodutibilidade: passe seed para reproduzir depois. Mantenha um catálogo que mapeie prompt + seed → imagem para rastreabilidade.
3. Lote e orquestração: para grandes execuções de produção, envie muitas solicitações em paralelo para o Pro, mas limite a taxa para evitar throttling; prefira o endpoint Pro para latência previsível. Use filas de tarefas e pools de workers para baixar rapidamente os resultados assinados assim que estiverem prontos.
4. Moderação e segurança: use safety_tolerance para controlar o rigor da moderação. Os endpoints Pro incluem políticas de uso e hooks de moderação de conteúdo; integre verificações do lado do servidor antes da publicação.
5. Pós-processamento: as saídas do Pro são de alta qualidade, mas ocasionalmente precisam de pequenos retoques. Crie uma etapa automatizada de pós-processamento (crop, color grading, composição) no seu pipeline e mantenha revisão humana para ativos sensíveis à marca.
Como posso personalizar saídas com o endpoint FLUX.2 Flex?
O Flex é a variante de “ferramenta cirúrgica”: ajuste steps, guidance, prompts negativos, tamanhos de tile e contagem de referências para moldar a saída com precisão.
Quando escolher o Flex
Você precisa de renderização tipográfica precisa (mockups de UI, rótulos).
Você precisa compor múltiplas referências com controle sobre pose e iluminação.
Você está experimentando técnicas avançadas de prompt (prompts estruturados, cadeias de restrições).
Exemplo — chaves de controle do Flex e seus efeitos
steps — mais steps = detalhes mais finos (com custo de latência).
guidance_scale — mais alto = mais próximo do prompt de texto, mais baixo = mais criatividade.
negative_prompt — remove explicitamente elementos (por exemplo, “no watermark, no extra fingers”).
tile_size / tiled_inference — para geração em resolução muito alta, divide o espaço de inferência em tiles para trocar memória por velocidade.
reference_weights — alguns endpoints permitem ponderar referências para influenciar qual imagem conduz pose vs. estilo.
Dica prática: para composições complexas, execute uma prévia curta com baixa guidance para verificar a composição e depois faça upscale com mais steps e guidance mais alta. Essa técnica em duas passagens reduz o custo enquanto fornece saídas finais precisas.
Exemplo: solicitação Flex com steps e guidance
curl -X POST "https://api.bfl.ai/v1/flux-2-flex" \
-H "Content-Type: application/json" \
-H "x-key: $BFL_API_KEY" \
-d '{
"prompt": "Cinematic movie poster, bold typography at top, main character centered, dramatic rim lighting",
"width": 1536, "height": 2048,
"steps": 50,
"guidance": 7.5,
"seed": 99999
}'
Dica: use o Flex durante aprovações criativas finais e o Pro para pipelines maiores e mais rápidos. O Flex é visivelmente mais controlável para tipografia e tarefas de microdetalhes.
Boas práticas para uso em produção
Abaixo estão padrões testados em campo e conselhos pragmáticos para integrar o FLUX.2 em escala.
1) Controle o custo acompanhando megapixels e cache
A cobrança do FLUX.2 é baseada nos megapixels de entrada + saída. Para geração em alto volume, prefira renders de prévia menores (baixa resolução com poucos steps) e só aumente para renders finais com mais MP quando necessário. Faça cache dos ativos renderizados (ou armazene diffs) para não renderizar novamente trabalhos idênticos. Sempre exponha cost nas respostas e registre-o por solicitação.
2) Use as camadas de forma inteligente: divisão entre prévia e render final
Execute renders Pro rápidos com poucos steps para prototipagem ou muitas variantes.
Use o Flex ou execuções Pro com alto MP para saídas finais aprovadas, quando a fidelidade for importante. Essa abordagem híbrida equilibra throughput e qualidade final da imagem.
3) Engenharia de prompt → prompts estruturados e JSON
Aproveite o prompting em JSON estruturado do FLUX.2 quando precisar de composição determinística (objetos da cena, câmera, poses, amostras de cores hexadecimais). Isso reduz ciclos iterativos de prompting e leva a lotes mais reproduzíveis. Exemplos da Cloudflare mostram prompts JSON incorporados em formulários multipart.
4) Seed + versionamento para reprodutibilidade
Quando precisar de resultados reproduzíveis, passe um seed e registre a versão/timestamp do modelo nos metadados. Para pipelines determinísticos de ativos, mantenha um manifesto: prompt, seed, variante do modelo, resolução, hashes das imagens de referência. Isso melhora a rastreabilidade e as opções de rollback.
Conclusão
O FLUX.2 foi claramente projetado para fechar a lacuna entre “demo impressionante” e “ferramenta criativa de produção”. Com edição com múltiplas referências, saídas em alta resolução e um conjunto de endpoints hospedados (além de código de inferência aberto e builds quantizadas para consumidores), ele oferece às equipes muitas opções práticas: executar localmente para pesquisa e personalização, ou usar os endpoints hospedados Pro/Flex para pipelines de produção estáveis.
Os desenvolvedores podem acessar a Flux.2 Dev API, a Flux.2 Flex API e a Flux.2 Pro API por meio da CometAPI. Para começar, explore os recursos dos modelos da CometAPI no Playground e consulte o guia da API para obter instruções detalhadas. Antes de acessar, certifique-se de ter feito login na CometAPI e obtido a chave de API. A CometAPI oferece um preço muito inferior ao preço oficial para ajudar você na integração.
