Crie um app gerador de imagens com IA: ferramentas, API e custos

Um app gerador de imagens com IA parece um produto grande por fora e um pequeno por dentro. Uma pessoa digita uma frase, seu servidor a entrega a um modelo, alguns segundos depois uma imagem volta, e você a salva em algum lugar onde a pessoa possa encontrá-la de novo. Todo o resto é acabamento: contas, uma galeria, créditos, uma forma de impedir abusos. A parte que mais surpreende quem desenvolve não é o código. É a conta. Custo por imagem, multiplicado pelas vezes que as pessoas apertam o botão, decide se o app ganha dinheiro ou o queima.

Este artigo apresenta um conjunto de ferramentas que você pode montar em uma semana, mostra como as chamadas da API se encaixam com código funcional na API do PicassoIA e faz as contas honestas do custo mensal, para que você possa precificar o produto antes do dia do lançamento.

O que você está realmente construindo

Tirando a marca, todo app gerador de imagens faz o mesmo trabalho: transforma um pedido de texto em um arquivo, sem obrigar a pessoa a esperar em uma tela travada. Quando você enxerga o app como um ciclo de requisições com uma galeria acoplada, o desenvolvimento fica bem menor.

O ciclo de requisições em cinco passos

1. O navegador envia o prompt e algumas opções (tamanho, estilo, número de imagens) para o seu back end.
2. Seu back end verifica o usuário, a cota e o prompt, e então cria uma predição na API de imagens.
3. A API responde na hora com um id, porque a geração é assíncrona e leva segundos, não milissegundos.
4. Seu back end consulta esse id (ou aguarda um webhook). Quando o status indicar succeeded, ele copia o arquivo para o seu próprio armazenamento.
5. O navegador mostra a imagem e a adiciona à galeria do usuário.

Todo recurso que você adicionar no futuro vai se apoiar nesses cinco passos. Os créditos se conectam ao passo 2. As galerias se conectam ao passo 5. A geração de vídeo é o mesmo ciclo, com um passo 4 mais lento.

Defina primeiro o formato do produto

Escolha a versão mais enxuta pela qual alguém pagaria. Cada tipo extra de entrada aumenta o trabalho no back end.

💡 Comece com uma caixa de texto e um botão. Recursos que você adiciona depois custam menos do que recursos que você precisa remover quando os usuários já dependem deles.

Escolha um conjunto de ferramentas que funcione

Ferramentas simples e confiáveis vencem aqui. O modelo faz a parte difícil, então seu conjunto de ferramentas só precisa ser confiável, barato de manter e fácil de trocar quando surgir um modelo melhor no mês seguinte.

Opções de front end

Um framework React como o Next.js oferece uma página de prompt, uma galeria e rotas de servidor em um único projeto. Se a maioria dos seus usuários estiver no celular, lance primeiro como um progressive web app e migre para React Native ou Flutter apenas quando precisar de acesso mais profundo à câmera ou a arquivos. A tela em si é simples: uma caixa de texto, um seletor de tamanho, um botão e uma grade.

Back end e fila

Use Node ou Python, o que sua equipe já escreve. A peça que você não deve pular é uma fila de tarefas. A geração de imagens é lenta em comparação com uma requisição web comum, e as APIs de imagem limitam quantas tarefas podem rodar ao mesmo tempo. Uma fila (Redis com BullMQ, ou Celery em Python) permite aceitar cada clique na hora e alimentar a API em um ritmo seguro.

Mantenha uma única tabela generations no Postgres com estas colunas: id, user_id, prompt, model, status, cost_usd, image_url, created_at. Essa tabela alimenta a galeria, a verificação de cota e seus relatórios de custo.

Armazenamento e entrega

Copie cada imagem pronta para seu próprio bucket atrás de um CDN. Não dependa de uma URL temporária do provedor que fique ativa para sempre. Salve o original mais uma miniatura WebP menor, para que a galeria carregue rápido no celular.

Escolha uma API de imagens

Você pode alugar um modelo por chamada ou rodar suas próprias GPUs. Para um primeiro lançamento, a resposta quase sempre é a primeira.

API hospedada ou sua própria GPU

Uma API hospedada significa sem drivers, sem trabalho de escalonamento, muitos modelos atrás de uma única interface, e você paga por imagem. Uma GPU alugada significa uma conta fixa por hora e uma longa lista de tarefas: pesos do modelo, limites de memória, atualizações, filas, travamentos às 3 da manhã.

A conta decide. Digamos que uma GPU alugada custe US$ 1,50 por hora e gere 120 imagens por hora. Se ela nunca ficar ociosa, cada imagem custa cerca de US$ 0,0125. Se ficar ocupada só 20% do tempo, você na prática gera 24 imagens por hora e cada uma custa US$ 0,0625. São números de exemplo, mas a forma do resultado se mantém: rodar a própria infraestrutura só compensa com tráfego constante e alto.

Modelos que vale integrar

A coleção de texto para imagem do PicassoIA lista mais de 200 modelos, o que é útil porque nenhum modelo único é o melhor em tudo. Escolha um padrão e mantenha uma ou duas alternativas atrás de uma configuração, para trocar quando a qualidade, a velocidade ou o preço mudarem.

Adicione um modelo de linguagem para os prompts

A maioria das pessoas escreve prompts como "um cachorro na praia". Um modelo de linguagem pequeno pode expandir isso em um prompt mais rico antes da chamada de imagem, e custa uma fração de centavo. Claude Sonnet 5 e Gemini 3.5 Flash servem bem a essa tarefa, e GPT 5 Structured devolve JSON limpo quando você precisa que a reescrita seja dividida em campos como assunto, iluminação e lente.

A mesma família de modelos pode fazer um segundo trabalho: verificar os prompts antes que cheguem ao modelo de imagem. Mais sobre isso adiante.

Conecte-se à API do PicassoIA

O PicassoIA oferece uma API REST no estilo Replicate, então o fluxo é o mesmo do ciclo de requisições: criar uma predição, consultá-la e buscar o resultado. Os endpoints e limites abaixo vêm da página pública da API, e essa página é o lugar para confirmar os detalhes antes de lançar.

Como usar o PicassoIA Image

Antes de escrever qualquer código, teste o modelo manualmente. Leva dez minutos e economiza dias de adivinhação.

1. Abra a página do PicassoIA Image.
2. Digite cinco prompts parecidos com os que seus usuários realmente vão escrever: curtos, longos e vagos.
3. Teste as proporções que seu app vai oferecer, como 1:1, 16:9 e 9:16.
4. Gere cada prompt várias vezes e anote o quanto os resultados variam.
5. Anote quais formulações deram as melhores fotos. Essa lista vira a base para o seu reescritor de prompts.

💡 Se seu app edita fotos, repita o mesmo teste com o PicassoIA Image Editor Pro usando uploads reais, não amostras de banco de imagens.

URL base e autenticação

A URL base é https://api.picassoia.com/v1. Toda requisição carrega um cabeçalho Authorization: Bearer com um segredo que começa com pia_sk_. Você o cria na página de API da conta, e uma conta pode ter no máximo duas chaves, então gire uma de cada vez. Nunca coloque esse segredo em código de navegador ou de aplicativo móvel. Ele pertence ao seu servidor, em uma variável de ambiente. Os requisitos do plano e os preços de acesso à API estão listados nessa página e podem mudar, então leia antes de montar um orçamento com base nela.

Quatro modelos são acessíveis pela API:

Planeje considerando estes limites:

O teto de cinco tarefas define toda a sua arquitetura, e é por isso que a fila de antes não é opcional.

Criar, consultar, buscar

Os endpoints são POST /v1/models/{owner}/{name}/predictions para iniciar uma tarefa, GET /v1/predictions/{id} para ler o status dela, POST /v1/predictions/{id}/cancel para interrompê-la e GET /v1/predictions para listar as tarefas recentes. Aqui está o ciclo completo em Node 18 ou mais recente:

const BASE = "https://api.picassoia.com/v1";
const headers = {
  Authorization: `Bearer ${process.env.PICASSOIA_TOKEN}`,
  "Content-Type": "application/json",
};

async function call(url, options) {
  const res = await fetch(url, { headers, ...options });
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json();
}

export async function generate(prompt) {
  const created = await call(
    `${BASE}/models/picassoia/picassoia-image/predictions`,
    {
      method: "POST",
      body: JSON.stringify({ input: { prompt, aspect_ratio: "16:9" } }),
    }
  );

  let job = created;
  while (!["succeeded", "failed", "canceled"].includes(job.status)) {
    await new Promise((r) => setTimeout(r, 2000));
    job = await call(`${BASE}/predictions/${created.id}`);
  }

  if (job.status !== "succeeded") throw new Error(job.error ?? job.status);
  return Array.isArray(job.output) ? job.output[0] : job.output;
}

Copiar prompt

Duas observações sobre esse código. Primeiro, os nomes dos campos de entrada variam de modelo para modelo, então leia a página de cada modelo e combine-os exatamente. Segundo, em produção você salva created.id no seu banco de dados antes de começar a consulta, para que a reinicialização do servidor nunca perca uma tarefa paga.

Quanto custa de verdade

Os custos se dividem em dois grupos: custos variáveis, que crescem a cada clique, e custos fixos, que permanecem. Os custos variáveis são os perigosos.

O custo por imagem é o número que importa

A fórmula central é curta:

Custo mensal = usuários × gerações por usuário × custo por imagem + custos fixos

A palavra a observar é gerações. As pessoas apertam o botão várias vezes para cada imagem que guardam, então meça gerações por imagem mantida desde o primeiro dia do seu beta e faça o orçamento com esse número, e não com a quantidade de imagens salvas.

Um orçamento mensal trabalhado

Considere 2.000 usuários ativos que fazem 20 gerações por mês cada um. São 40.000 imagens. Os preços abaixo são premissas de planejamento, então substitua pela tarifa atual do modelo que você escolher. Os custos fixos de hospedagem, banco de dados e armazenamento estão definidos em US$ 100 por mês para esse porte.

A receita considera que 300 dos 2.000 usuários pagam US$ 9 por mês. A linha premium dá prejuízo mesmo com o app parecendo saudável, porque os usuários gratuitos também geram imagens. Três correções funcionam bem juntas: limitar o nível gratuito, vender créditos dimensionados ao preço real de cada modelo e enviar os pedidos de rascunho para o modelo barato, reservando o premium para as renderizações finais.

Custos que as pessoas esquecem:

• Gerações com falha ou abandonadas. Você pode pagar por imagens que ninguém abre.
• Novas tentativas. Cada nova tentativa automática é outra chamada cobrável, a menos que a primeira tenha claramente falhado.
• Armazenamento e banda. Uma galeria de imagens em tamanho real soma mais rápido do que se espera, e por isso miniaturas e um CDN importam.
• Chamadas de reescrita de prompt e de moderação. Pequenas por chamada, reais em volume.
• Taxas de pagamento e taxas das lojas de aplicativos. Elas são descontadas de cada venda antes de qualquer outro valor.
• Tempo de suporte. Alguém precisa responder a "minha imagem ficou errada".

Mantenha seguro e rápido

Velocidade e segurança são baratas de adicionar cedo e dolorosas de adicionar depois do lançamento.

Filas, limites e novas tentativas

Com cinco predições simultâneas por conta no PicassoIA, uma fila decide o quão suave seu app se comporta. Considere que uma imagem leva cerca de 10 segundos. Cinco tarefas ao mesmo tempo dão aproximadamente 30 imagens por minuto, ou 1.800 por hora. As 40.000 imagens do orçamento acima dão uma média de cerca de 55 por hora. Mesmo um horário de pico com cinco vezes a média, cerca de 280 imagens, cabe com folga.

Regras que mantêm a fila saudável:

• Tente de novo apenas erros transitórios, como tempos limite e erros de servidor, com um atraso crescente entre as tentativas. Nunca repita uma requisição que a API recusou por causa de uma entrada inválida.
• Limite cada usuário a um pequeno número de tarefas ao mesmo tempo, para que uma pessoa não consiga ocupar as cinco vagas.
• Mostre o progresso, mesmo que seja um simples "Na fila, em 3º lugar", para que as pessoas não cliquem de novo.
• Use o endpoint de cancelamento quando um usuário sair, para não pagar por trabalho que ninguém vai ver.

Moderação antes da geração

Verifique o prompt antes de ele chegar ao modelo de imagem. Um classificador de segurança como o Llama Guard 4 12B lê o texto e sinaliza as categorias que você escolher bloquear. É barato, rápido e mantém sua conta longe de problemas.

Se os usuários puderem enviar fotos, revise os uploads também. Registre cada recusa com o id do usuário e o motivo, porque os padrões nesses registros mostram quem está testando os seus limites.

Duas melhorias que se pagam sozinhas:

• Faça cache por receita. Calcule o hash do prompt, do modelo, do tamanho e do seed. Quando a mesma receita aparecer de novo, devolva o arquivo armazenado em vez de pagar por um novo. Modelos de prompt e galerias de exemplo acionam o cache o tempo todo.
• Adicione vídeo depois. O ciclo é idêntico, só que mais lento. O PicassoIA Video e o Seedance 2.5 Lite estão ambos na API, e uma imagem fixa pronta pode servir como primeiro quadro de um clipe. Planeje o orçamento de vídeo separadamente, já que os clipes custam mais que as imagens e seus arquivos são maiores.

Seu plano da primeira semana

Uma equipe pequena pode lançar um beta privado em sete dias se o escopo ficar enxuto.

Os erros que mais custam tempo: construir um pipeline de modelo personalizado antes de provar que alguém quer o produto, fixar o nome de um modelo no código em vinte lugares e esquecer de registrar o custo de cada geração. Corrija o último no quarto dia e todas as decisões seguintes ficam mais fáceis, porque você vai ver quais prompts, usuários e modelos geram a maior parte da conta.

Faça sua primeira imagem no PicassoIA

A forma mais rápida de avaliar um modelo é usá-lo. Abra o PicassoIA Image, digite o prompt que um usuário real digitaria e veja o que volta. Depois teste o mesmo prompt em dois ou três outros modelos da lista completa de modelos e compare qualidade, velocidade e estilo lado a lado.

Quando os resultados parecerem certos, leia a página da API do PicassoIA, crie seu primeiro segredo e execute o trecho em Node acima. Um prompt, uma predição, uma imagem salva no seu próprio armazenamento: esse é o app inteiro em miniatura, e tudo o que vem depois é escalar. Comece a experimentar hoje, e a primeira imagem criada pelo seu próprio código vai te ensinar mais do que qualquer plano.